カレンダーの使用Working with calendars

日時の値は特定の時点を表しますが、その文字列形式はカルチャに依存し、特定のカルチャで日時の値の表示に使用される規則と、そのカルチャで使用される暦の両方に応じて決まります。Although a date and time value represents a moment in time, its string representation is culture-sensitive and depends both on the conventions used for displaying date and time values by a specific culture and on the calendar used by that culture. このトピックでは、.NET でのカレンダーのサポートについて説明し、日付の値を使用する場合に、calendar クラスの使用について説明します。This topic explores the support for calendars in .NET and discusses the use of the calendar classes when working with date values.

.NET で予定表Calendars in .NET

派生して .NET でのすべてのカレンダー、System.Globalization.Calendarクラスを基本の暦の実装を提供します。All calendars in .NET derive from the System.Globalization.Calendar class, which provides the base calendar implementation. Calendar クラスを継承するクラスの 1 つに EastAsianLunisolarCalendar クラスがあります。これは、すべての太陰太陽暦の基本クラスです。One of the classes that inherits from the Calendar class is the EastAsianLunisolarCalendar class, which is the base class for all lunisolar calendars. .NET には、次のカレンダー実装が含まれています。.NET includes the following calendar implementations:

暦は、次の 2 とおりの方法で使用できます。A calendar can be used in one of two ways:

  • 特定のカルチャで使用される暦として使用する。As the calendar used by a specific culture. CultureInfo オブジェクトにはそれぞれ、現在の暦 (オブジェクトで現在使用している暦) があります。Each CultureInfo object has a current calendar, which is the calendar that the object is currently using. あらゆる日付と時刻の値の文字列形式には、現在のカルチャとその現在の暦が自動的に反映されます。The string representations of all date and time values automatically reflect the current culture and its current calendar. 通常、現在の暦は、カルチャの既定の暦になります。Typically, the current calendar is the culture's default calendar. CultureInfo オブジェクトは、カルチャで使用できるその他の暦を含む、オプションの暦もあります。CultureInfo objects also have optional calendars, which include additional calendars that the culture can use.

  • 特定のカルチャに依存しないスタンドアロンの暦として使用する。As a standalone calendar independent of a specific culture. この場合、暦が反映された値として日付を表すには、Calendar のメソッドを使用します。In this case, Calendar methods are used to express dates as values that reflect the calendar.

ChineseLunisolarCalendarJapaneseLunisolarCalendarJulianCalendarKoreanLunisolarCalendarPersianCalendar、および TaiwanLunisolarCalendar の 6 つの Calendar クラスは、スタンドアロンの暦としてのみ使用できます。Note that six calendar classes – ChineseLunisolarCalendar, JapaneseLunisolarCalendar, JulianCalendar, KoreanLunisolarCalendar, PersianCalendar, and TaiwanLunisolarCalendar – can be used only as standalone calendars. これらは、どのカルチャでも、既定の暦またはオプションの暦としては使用されません。They are not used by any culture as either the default calendar or as an optional calendar.

暦とカルチャCalendars and cultures

各カルチャには既定の暦があり、CultureInfo.Calendar プロパティで定義されます。Each culture has a default calendar, which is defined by the CultureInfo.Calendar property. CultureInfo.OptionalCalendars プロパティは、特定のカルチャでサポートされるすべての暦を指定する Calendar オブジェクトの配列を返します。これには、そのカルチャの既定の暦も含まれます。The CultureInfo.OptionalCalendars property returns an array of Calendar objects that specifies all the calendars supported by a particular culture, including that culture's default calendar.

CultureInfo.Calendar プロパティと CultureInfo.OptionalCalendars プロパティの例を次に示します。The following example illustrates the CultureInfo.Calendar and CultureInfo.OptionalCalendars properties. この例では、タイ語 (タイ) と日本語 (日本) のカルチャの CultureInfo オブジェクトをそれぞれ作成し、それらの既定の暦とオプションの暦を表示します。It creates CultureInfo objects for the Thai (Thailand) and Japanese (Japan) cultures and displays their default and optional calendars. どちらについても、カルチャの既定の暦は CultureInfo.OptionalCalendars コレクションにも含まれます。Note that in both cases, the culture's default calendar is also included in the CultureInfo.OptionalCalendars collection.

using System;
using System.Globalization;

public class Example
{
   public static void Main()
   {
      // Create a CultureInfo for Thai in Thailand.
      CultureInfo th = CultureInfo.CreateSpecificCulture("th-TH");
      DisplayCalendars(th);

      // Create a CultureInfo for Japanese in Japan.
      CultureInfo ja = CultureInfo.CreateSpecificCulture("ja-JP");
      DisplayCalendars(ja);
   }

   static void DisplayCalendars(CultureInfo ci)
   {
      Console.WriteLine("Calendars for the {0} culture:", ci.Name);

      // Get the culture's default calendar.
      Calendar defaultCalendar = ci.Calendar;
      Console.Write("   Default Calendar: {0}", GetCalendarName(defaultCalendar));      

      if (defaultCalendar is GregorianCalendar)
         Console.WriteLine(" ({0})", 
                           ((GregorianCalendar) defaultCalendar).CalendarType);
      else
         Console.WriteLine();
      
      // Get the culture's optional calendars.
      Console.WriteLine("   Optional Calendars:");      
      foreach (var optionalCalendar in ci.OptionalCalendars) {
         Console.Write("{0,6}{1}", "", GetCalendarName(optionalCalendar));
         if (optionalCalendar is GregorianCalendar)
            Console.Write(" ({0})", 
                          ((GregorianCalendar) optionalCalendar).CalendarType);

         Console.WriteLine();
      }
      Console.WriteLine();
   }

   static string GetCalendarName(Calendar cal)
   {
      return cal.ToString().Replace("System.Globalization.", "");
   }
}
// The example displays the following output:
//       Calendars for the th-TH culture:
//          Default Calendar: ThaiBuddhistCalendar
//          Optional Calendars:
//             ThaiBuddhistCalendar
//             GregorianCalendar (Localized)
//       
//       Calendars for the ja-JP culture:
//          Default Calendar: GregorianCalendar (Localized)
//          Optional Calendars:
//             GregorianCalendar (Localized)
//             JapaneseCalendar
//             GregorianCalendar (USEnglish)
Imports System.Globalization

Public Module Example
   Public Sub Main()
      ' Create a CultureInfo for Thai in Thailand.
      Dim th As CultureInfo = CultureInfo.CreateSpecificCulture("th-TH")
      DisplayCalendars(th)

      ' Create a CultureInfo for Japanese in Japan.
      Dim ja As CultureInfo = CultureInfo.CreateSpecificCulture("ja-JP")
      DisplayCalendars(ja)
   End Sub

   Sub DisplayCalendars(ci As CultureInfo)
      Console.WriteLine("Calendars for the {0} culture:", ci.Name)

      ' Get the culture's default calendar.
      Dim defaultCalendar As Calendar = ci.Calendar
      Console.Write("   Default Calendar: {0}", GetCalendarName(defaultCalendar))      

      If TypeOf defaultCalendar Is GregorianCalendar Then
         Console.WriteLine(" ({0})", 
                           CType(defaultCalendar, GregorianCalendar).CalendarType)
      Else
         Console.WriteLine()
      End If
      
      ' Get the culture's optional calendars.
      Console.WriteLine("   Optional Calendars:")      
      For Each optionalCalendar In ci.OptionalCalendars
         Console.Write("{0,6}{1}", "", GetCalendarName(optionalCalendar))
         If TypeOf optionalCalendar Is GregorianCalendar Then
            Console.Write(" ({0})", 
                          CType(optionalCalendar, GregorianCalendar).CalendarType)
         End If
         Console.WriteLine()
      Next
      Console.WriteLine()
   End Sub

   Function GetCalendarName(cal As Calendar) As String
      Return cal.ToString().Replace("System.Globalization.", "")
   End Function
End Module
' The example displays the following output:
'       Calendars for the th-TH culture:
'          Default Calendar: ThaiBuddhistCalendar
'          Optional Calendars:
'             ThaiBuddhistCalendar
'             GregorianCalendar (Localized)
'       
'       Calendars for the ja-JP culture:
'          Default Calendar: GregorianCalendar (Localized)
'          Optional Calendars:
'             GregorianCalendar (Localized)
'             JapaneseCalendar
'             GregorianCalendar (USEnglish)

特定の CultureInfo オブジェクトで現在使用されている暦は、カルチャの DateTimeFormatInfo.Calendar プロパティで定義されます。The calendar currently in use by a particular CultureInfo object is defined by the culture's DateTimeFormatInfo.Calendar property. カルチャの DateTimeFormatInfo オブジェクトは、CultureInfo.DateTimeFormat プロパティから返されます。A culture's DateTimeFormatInfo object is returned by the CultureInfo.DateTimeFormat property. カルチャの作成時の既定値は CultureInfo.Calendar プロパティの値と同じですが、When a culture is created, its default value is the same as the value of the CultureInfo.Calendar property. カルチャの現在の暦は、CultureInfo.OptionalCalendars プロパティから返される配列に含まれる任意の暦に変更することができます。However, you can change the culture's current calendar to any calendar contained in the array returned by the CultureInfo.OptionalCalendars property. 現在の暦を CultureInfo.OptionalCalendars プロパティの値に含まれない暦に設定しようとすると、ArgumentException がスローされます。If you try to set the current calendar to a calendar that is not included in the CultureInfo.OptionalCalendars property value, an ArgumentException is thrown.

アラビア語 (サウジアラビア) のカルチャで使用する暦を変更する例を次に示します。The following example changes the calendar used by the Arabic (Saudi Arabia) culture. まず、DateTime 値をインスタンス化し、現在のカルチャ (この例では英語 (米国)) と現在のカルチャの暦 (この例ではグレゴリオ暦) を使用して日付を表示します。It first instantiates a DateTime value and displays it using the current culture - which, in this case, is English (United States) - and the current culture's calendar (which, in this case, is the Gregorian calendar). 次に、現在のカルチャをアラビア語 (サウジアラビア) に変更し、そのカルチャの既定のウムアルクラ暦を使用して日付を表示します。Next, it changes the current culture to Arabic (Saudi Arabia) and displays the date using its default Um Al-Qura calendar. さらに、CalendarExists メソッドを呼び出して、アラビア語 (サウジアラビア) のカルチャで回教暦がサポートされているかどうかを判別します。It then calls the CalendarExists method to determine whether the Hijri calendar is supported by the Arabic (Saudi Arabia) culture. この暦はサポートされているため、現在の暦を回教暦に変更し、日付をもう一度表示します。Because the calendar is supported, it changes the current calendar to Hijri and again displays the date. いずれの場合も、日付は、現在のカルチャの現在の暦を使用して表示されます。Note that in each case, the date is displayed using the current culture's current calendar.

using System;
using System.Globalization;
using System.Threading;

public class Example
{
   public static void Main()
   {
      DateTime date1 = new DateTime(2011, 6, 20);

      DisplayCurrentInfo();
      // Display the date using the current culture and calendar.
      Console.WriteLine(date1.ToString("d"));       
      Console.WriteLine();
      
      CultureInfo arSA = CultureInfo.CreateSpecificCulture("ar-SA");
      
      // Change the current culture to Arabic (Saudi Arabia).
      Thread.CurrentThread.CurrentCulture = arSA;
      // Display date and information about the current culture.
      DisplayCurrentInfo();
      Console.WriteLine(date1.ToString("d"));
      Console.WriteLine();
      
      // Change the calendar to Hijri.
      Calendar hijri = new HijriCalendar();
      if (CalendarExists(arSA, hijri)) {
         arSA.DateTimeFormat.Calendar = hijri;
         // Display date and information about the current culture.
         DisplayCurrentInfo();
         Console.WriteLine(date1.ToString("d"));
      }       
   }

   private static void DisplayCurrentInfo()
   {
      Console.WriteLine("Current Culture: {0}", 
                        CultureInfo.CurrentCulture.Name);
      Console.WriteLine("Current Calendar: {0}", 
                        DateTimeFormatInfo.CurrentInfo.Calendar);
   }

   private static bool CalendarExists(CultureInfo culture, Calendar cal)
   {
      foreach (Calendar optionalCalendar in culture.OptionalCalendars)
         if (cal.ToString().Equals(optionalCalendar.ToString())) 
            return true;

      return false;
   }
}
// The example displays the following output:
//    Current Culture: en-US
//    Current Calendar: System.Globalization.GregorianCalendar
//    6/20/2011
//    
//    Current Culture: ar-SA
//    Current Calendar: System.Globalization.UmAlQuraCalendar
//    18/07/32
//    
//    Current Culture: ar-SA
//    Current Calendar: System.Globalization.HijriCalendar
//    19/07/32
Imports System.Globalization
Imports System.Threading

Module Example
   Public Sub Main()
      Dim date1 As Date = #6/20/2011#

      DisplayCurrentInfo()
      ' Display the date using the current culture and calendar.
      Console.WriteLine(date1.ToString("d"))       
      Console.WriteLine()
      
      Dim arSA As CultureInfo = CultureInfo.CreateSpecificCulture("ar-SA")
      
      ' Change the current culture to Arabic (Saudi Arabia).
      Thread.CurrentThread.CurrentCulture = arSA
      ' Display date and information about the current culture.
      DisplayCurrentInfo()
      Console.WriteLine(date1.ToString("d"))
      Console.WriteLine()
      
      ' Change the calendar to Hijri.
      Dim hijri As Calendar = New HijriCalendar()
      If CalendarExists(arSA, hijri) Then
         arSA.DateTimeFormat.Calendar = hijri
         ' Display date and information about the current culture.
         DisplayCurrentInfo()
         Console.WriteLine(date1.ToString("d"))
      End If       
   End Sub
   
   Private Sub DisplayCurrentInfo()
      Console.WriteLine("Current Culture: {0}", 
                        CultureInfo.CurrentCulture.Name)
      Console.WriteLine("Current Calendar: {0}", 
                        DateTimeFormatInfo.CurrentInfo.Calendar)
   End Sub

   Private Function CalendarExists(ByVal culture As CultureInfo, 
                                   cal As Calendar) As Boolean
      For Each optionalCalendar As Calendar In culture.OptionalCalendars
         If cal.ToString().Equals(optionalCalendar.ToString()) Then Return True
      Next   
      Return False
   End Function
End Module
' The example displays the following output:
'    Current Culture: en-US
'    Current Calendar: System.Globalization.GregorianCalendar
'    6/20/2011
'    
'    Current Culture: ar-SA
'    Current Calendar: System.Globalization.UmAlQuraCalendar
'    18/07/32
'    
'    Current Culture: ar-SA
'    Current Calendar: System.Globalization.HijriCalendar
'    19/07/32

日付と暦Dates and calendars

Calendar 型のパラメーターを含み、指定した暦の値を日付の要素 (月、日、および年) に反映できるコンストラクターは例外として、DateTimeDateTimeOffset の値は、どちらも常にグレゴリオ暦に基づきます。With the exception of the constructors that include a parameter of type Calendar and allow the elements of a date (that is, the month, the day, and the year) to reflect values in a designated calendar, both DateTime and DateTimeOffset values are always based on the Gregorian calendar. つまり、たとえば DateTime.Year プロパティはグレゴリオ暦の年を返し、DateTime.Day プロパティはグレゴリオ暦の月の日付を返します。This means, for example, that the DateTime.Year property returns the year in the Gregorian calendar, and the DateTime.Day property returns the day of the month in the Gregorian calendar.

重要

日付の値とその文字列形式で処理が異なることに注意してください。It is important to remember that there is a difference between a date value and its string representation. 日付の値はグレゴリオ暦に基づき、文字列形式は特定のカルチャの現在の暦に基づきます。The former is based on the Gregorian calendar; the latter is based on the current calendar of a specific culture.

次の例は、DateTime のプロパティと、それに対応する Calendar のメソッドの違いを示しています。The following example illustrates this difference between DateTime properties and their corresponding Calendar methods. この例では、現在のカルチャはアラビア語 (エジプト)、現在の暦はウムアルクラ暦です。In the example, the current culture is Arabic (Egypt), and the current calendar is Um Al Qura. DateTime 値は、2011 年の 7 番目の月の 15 番目の日に設定されています。A DateTime value is set to the fifteenth day of the seventh month of 2011. この値は、明らかにグレゴリオ暦の日付と解釈されます。DateTime.ToString(String, IFormatProvider) メソッドでインバリアント カルチャの規則を使用した場合に、これらと同じ値が返されるためです。It is clear that this is interpreted as a Gregorian date, because these same values are returned by the DateTime.ToString(String, IFormatProvider) method when it uses the conventions of the invariant culture. 現在のカルチャの規則を使用して書式指定された日付の文字列形式は 14/08/32 です。これは、この日付に相当するウムアルクラ暦の日付です。The string representation of the date that is formatted using the conventions of the current culture is 14/08/32, which is the equivalent date in the Um Al Qura calendar. 次に、DateTimeCalendar のメンバーを使用して、DateTime 値の日、月、および年が返されます。Next, members of DateTime and Calendar are used to return the day, the month, and the year of the DateTime value. いずれの場合も、DateTime のメンバーから返される値にはグレゴリオ暦の値が反映され、UmAlQuraCalendar のメンバーから返される値にはウムアルクラ暦の値が反映されます。In each case, the values returned by DateTime members reflect values in the Gregorian calendar, whereas values returned by UmAlQuraCalendar members reflect values in the Uum al-Qura calendar.

using System;
using System.Globalization;
using System.Threading;

public class Example
{
   public static void Main()
   {
      // Make Arabic (Egypt) the current culture 
      // and Umm al-Qura calendar the current calendar. 
      CultureInfo arEG = CultureInfo.CreateSpecificCulture("ar-EG");
      Calendar cal = new UmAlQuraCalendar();
      arEG.DateTimeFormat.Calendar = cal;
      Thread.CurrentThread.CurrentCulture = arEG;

      // Display information on current culture and calendar.
      DisplayCurrentInfo();      

      // Instantiate a date object.
      DateTime date1 = new DateTime(2011, 7, 15);

      // Display the string representation of the date.
      Console.WriteLine("Date: {0:d}", date1);
      Console.WriteLine("Date in the Invariant Culture: {0}", 
                        date1.ToString("d", CultureInfo.InvariantCulture));
      Console.WriteLine();
            
      // Compare DateTime properties and Calendar methods.
      Console.WriteLine("DateTime.Month property: {0}", date1.Month);
      Console.WriteLine("UmAlQura.GetMonth: {0}", 
                        cal.GetMonth(date1));
      Console.WriteLine();

      Console.WriteLine("DateTime.Day property: {0}", date1.Day);
      Console.WriteLine("UmAlQura.GetDayOfMonth: {0}", 
                        cal.GetDayOfMonth(date1));                         
      Console.WriteLine();
      
      Console.WriteLine("DateTime.Year property: {0:D4}", date1.Year);
      Console.WriteLine("UmAlQura.GetYear: {0}", 
                        cal.GetYear(date1));                         
      Console.WriteLine();
   }

   private static void DisplayCurrentInfo()
   {
      Console.WriteLine("Current Culture: {0}", 
                        CultureInfo.CurrentCulture.Name);
      Console.WriteLine("Current Calendar: {0}", 
                        DateTimeFormatInfo.CurrentInfo.Calendar);
   }
}
// The example displays the following output:
//    Current Culture: ar-EG
//    Current Calendar: System.Globalization.UmAlQuraCalendar
//    Date: 14/08/32
//    Date in the Invariant Culture: 07/15/2011
//    
//    DateTime.Month property: 7
//    UmAlQura.GetMonth: 8
//    
//    DateTime.Day property: 15
//    UmAlQura.GetDayOfMonth: 14
//    
//    DateTime.Year property: 2011
//    UmAlQura.GetYear: 1432
Imports System.Globalization
Imports System.Threading

Module Example
   Public Sub Main()
      ' Make Arabic (Egypt) the current culture 
      ' and Umm al-Qura calendar the current calendar. 
      Dim arEG As CultureInfo = CultureInfo.CreateSpecificCulture("ar-EG")
      Dim cal As Calendar = New UmAlQuraCalendar()
      arEG.DateTimeFormat.Calendar = cal
      Thread.CurrentThread.CurrentCulture = arEG

      ' Display information on current culture and calendar.
      DisplayCurrentInfo()      

      ' Instantiate a date object.
      Dim date1 As Date = #07/15/2011#

      ' Display the string representation of the date.
      Console.WriteLine("Date: {0:d}", date1)
      Console.WriteLine("Date in the Invariant Culture: {0}", 
                        date1.ToString("d", CultureInfo.InvariantCulture))
      Console.WriteLine()
            
      ' Compare DateTime properties and Calendar methods.
      Console.WriteLine("DateTime.Month property: {0}", date1.Month)
      Console.WriteLine("UmAlQura.GetMonth: {0}", 
                        cal.GetMonth(date1))
      Console.WriteLine()

      Console.WriteLine("DateTime.Day property: {0}", date1.Day)
      Console.WriteLine("UmAlQura.GetDayOfMonth: {0}", 
                        cal.GetDayOfMonth(date1))                         
      Console.WriteLine()
      
      Console.WriteLine("DateTime.Year property: {0:D4}", date1.Year)
      Console.WriteLine("UmAlQura.GetYear: {0}", 
                        cal.GetYear(date1))                         
      Console.WriteLine()
   End Sub
   
   Private Sub DisplayCurrentInfo()
      Console.WriteLine("Current Culture: {0}", 
                        CultureInfo.CurrentCulture.Name)
      Console.WriteLine("Current Calendar: {0}", 
                        DateTimeFormatInfo.CurrentInfo.Calendar)
   End Sub
End Module
' The example displays the following output:
'    Current Culture: ar-EG
'    Current Calendar: System.Globalization.UmAlQuraCalendar
'    Date: 14/08/32
'    Date in the Invariant Culture: 07/15/2011
'    
'    DateTime.Month property: 7
'    UmAlQura.GetMonth: 8
'    
'    DateTime.Day property: 15
'    UmAlQura.GetDayOfMonth: 14
'    
'    DateTime.Year property: 2011
'    UmAlQura.GetYear: 1432

カレンダーに基づく日付をインスタンス化します。Instantiating dates based on a calendar

DateTimeDateTimeOffset の値はグレゴリオ暦に基づくため、別の暦の日、月、または年の値を使用する場合は、Calendar 型のパラメーターを含むオーバーロードされたコンストラクターを呼び出して日付の値をインスタンス化する必要があります。Because DateTime and DateTimeOffset values are based on the Gregorian calendar, you must call an overloaded constructor that includes a parameter of type Calendar to instantiate a date value if you want to use the day, month, or year values from a different calendar. また、特定の暦の Calendar.ToDateTime メソッドのいずれかのオーバーロードを呼び出して、特定の暦の値に基づいて DateTime オブジェクトをインスタンス化することもできます。You can also call one of the overloads of a specific calendar's Calendar.ToDateTime method to instantiate a DateTime object based on the values of a particular calendar.

次の例では、DateTime オブジェクトを HebrewCalendar コンストラクターに渡して 1 つの DateTime 値をインスタンス化し、DateTime メソッドを呼び出してもう 1 つの HebrewCalendar.ToDateTime(Int32, Int32, Int32, Int32, Int32, Int32, Int32, Int32) 値をインスタンス化しています。The following example instantiates one DateTime value by passing a HebrewCalendar object to a DateTime constructor, and instantiates a second DateTime value by calling the HebrewCalendar.ToDateTime(Int32, Int32, Int32, Int32, Int32, Int32, Int32, Int32) method. 2 つの値はヘブライ暦の同一の値を使用して作成されるため、DateTime.Equals メソッドを呼び出すと、2 つの DateTime 値が等しいことが示されます。Because the two values are created with identical values from the Hebrew calendar, the call to the DateTime.Equals method shows that the two DateTime values are equal.

using System;
using System.Globalization;

public class Example
{
   public static void Main()
   {
      HebrewCalendar hc = new HebrewCalendar();

      DateTime date1 = new DateTime(5771, 6, 1, hc);
      DateTime date2 = hc.ToDateTime(5771, 6, 1, 0, 0, 0, 0);
      
      Console.WriteLine("{0:d} (Gregorian) = {1:d2}/{2:d2}/{3:d4} ({4}): {5}",
                        date1, 
                        hc.GetMonth(date2),
                        hc.GetDayOfMonth(date2),
                        hc.GetYear(date2), 
                        GetCalendarName(hc),
                        date1.Equals(date2));
   }
   
   private static string GetCalendarName(Calendar cal)
   {
      return cal.ToString().Replace("System.Globalization.", ""). 
                            Replace("Calendar", "");
   }
}
// The example displays the following output:
//    2/5/2011 (Gregorian) = 06/01/5771 (Hebrew): True
Imports System.Globalization

Module Example
   Public Sub Main()
      Dim hc As New HebrewCalendar()

      Dim date1 As New Date(5771, 6, 1, hc)
      Dim date2 As Date = hc.ToDateTime(5771, 6, 1, 0, 0, 0, 0)
      
      Console.WriteLine("{0:d} (Gregorian) = {1:d2}/{2:d2}/{3:d4} ({4}): {5}",
                        date1, 
                        hc.GetMonth(date2),
                        hc.GetDayOfMonth(date2),
                        hc.GetYear(date2), 
                        GetCalendarName(hc),
                        date1.Equals(date2))
   End Sub
   
   Private Function GetCalendarName(cal As Calendar) As String
      Return cal.ToString().Replace("System.Globalization.", ""). 
                            Replace("Calendar", "")
   End Function
End Module
' The example displays the following output:
'   2/5/2011 (Gregorian) = 06/01/5771 (Hebrew): True

現在の暦で日付を表すRepresenting dates in the current calendar

日時書式指定メソッドでは、日付を文字列に変換する際に、常に現在の暦を使用します。Date and time formatting methods always use the current calendar when converting dates to strings. つまり、年、月、および日の文字列形式には現在の暦が反映され、必ずしもグレゴリオ暦が反映されるとは限りません。This means that the string representation of the year, the month, and the day of the month reflect the current calendar, and do not necessarily reflect the Gregorian calendar.

次の例は、現在の暦が日付の文字列形式にどのように影響するかを示しています。The following example shows how the current calendar affects the string representation of a date. この例では、現在のカルチャを中国語 (繁体字、台湾) に変更し、日付の値をインスタンス化します。It changes the current culture to Chinese (Traditional, Taiwan), and instantiates a date value. その後、現在の暦と日付を表示し、現在の暦を TaiwanCalendar に変更して、現在の暦と日付をもう一度表示します。It then displays the current calendar and the date, changes the current calendar to TaiwanCalendar, and displays the current calendar and date once again. 最初に日付を表示したときは、日付がグレゴリオ暦の日付として表され、The first time the date is displayed, it is represented as a date in the Gregorian calendar. 2 回目に表示したときは、台湾暦の日付として表されます。The second time it is displayed, it is represented as a date in the Taiwan calendar.

using System;
using System.Globalization;
using System.Threading;

public class Example
{
   public static void Main()
   {
      // Change the current culture to zh-TW.
      CultureInfo zhTW = CultureInfo.CreateSpecificCulture("zh-TW");
      Thread.CurrentThread.CurrentCulture = zhTW;
      // Define a date.
      DateTime date1 = new DateTime(2011, 1, 16);
      
      // Display the date using the default (Gregorian) calendar.
      Console.WriteLine("Current calendar: {0}", 
                        zhTW.DateTimeFormat.Calendar);
      Console.WriteLine(date1.ToString("d"));
      
      // Change the current calendar and display the date.
      zhTW.DateTimeFormat.Calendar = new TaiwanCalendar();      
      Console.WriteLine("Current calendar: {0}", 
                        zhTW.DateTimeFormat.Calendar);
      Console.WriteLine(date1.ToString("d"));
   }
}
// The example displays the following output:
//    Current calendar: System.Globalization.GregorianCalendar
//    2011/1/16
//    Current calendar: System.Globalization.TaiwanCalendar
//    100/1/16
Imports System.Globalization
Imports System.Threading

Module Example
   Public Sub Main()
      ' Change the current culture to zh-TW.
      Dim zhTW As CultureInfo = CultureInfo.CreateSpecificCulture("zh-TW")
      Thread.CurrentThread.CurrentCulture = zhTW
      ' Define a date.
      Dim date1 As Date = #1/16/2011#
      
      ' Display the date using the default (Gregorian) calendar.
      Console.WriteLine("Current calendar: {0}", 
                        zhTW.DateTimeFormat.Calendar)
      Console.WriteLine(date1.ToString("d"))
      
      ' Change the current calendar and display the date.
      zhTW.DateTimeFormat.Calendar = New TaiwanCalendar()      
      Console.WriteLine("Current calendar: {0}", 
                        zhTW.DateTimeFormat.Calendar)
      Console.WriteLine(date1.ToString("d"))
   End Sub
End Module
' The example displays the following output:
'    Current calendar: System.Globalization.GregorianCalendar
'    2011/1/16
'    Current calendar: System.Globalization.TaiwanCalendar
'    100/1/16

現在ではないカレンダーにおける日付を表すRepresenting dates in a non-current calendar

特定のカルチャの現在の暦以外の暦を使用して日付を表すには、その Calendar オブジェクトのメソッドを呼び出す必要があります。To represent a date using a calendar that is not the current calendar of a particular culture, you must call methods of that Calendar object. たとえば、Calendar.GetYearCalendar.GetMonth、および Calendar.GetDayOfMonth の各メソッドは、それぞれ年、月、および日を、特定の暦を反映した値に変換します。For example, the Calendar.GetYear, Calendar.GetMonth, and Calendar.GetDayOfMonth methods convert the year, month, and day to values that reflect a particular calendar.

警告

一部の暦はどのカルチャのオプションの暦にもなっていないため、そのような暦で日付を表す場合は、常に Calendar のメソッドを呼び出す必要があります。Because some calendars are not optional calendars of any culture, representing dates in these calendars always requires that you call calendar methods. これは、EastAsianLunisolarCalendar クラス、JulianCalendar クラス、および PersianCalendar クラスから派生したすべての暦に当てはまります。This is true of all calendars that derive from the EastAsianLunisolarCalendar, JulianCalendar, and PersianCalendar classes.

次の例では、JulianCalendar オブジェクトを使用して、ユリウス暦の 1905 年 1 月 9 日という日付をインスタンス化します。The following example uses a JulianCalendar object to instantiate a date, January 9, 1905, in the Julian calendar. この日付を既定の暦 (グレゴリオ暦) を使用して表示した場合は、1905 年 1 月 22 日と表されます。When this date is displayed using the default (Gregorian) calendar, it is represented as January 22, 1905. JulianCalendar の各メソッドを呼び出すことで、この日付をユリウス暦で表すことができます。Calls to individual JulianCalendar methods enable the date to be represented in the Julian calendar.

using System;
using System.Globalization;

public class Example
{
   public static void Main()
   {
      JulianCalendar julian = new JulianCalendar();
      DateTime date1 = new DateTime(1905, 1, 9, julian);
      
      Console.WriteLine("Date ({0}): {1:d}", 
                        CultureInfo.CurrentCulture.Calendar,
                        date1);
      Console.WriteLine("Date in Julian calendar: {0:d2}/{1:d2}/{2:d4}",
                        julian.GetMonth(date1),
                        julian.GetDayOfMonth(date1),
                        julian.GetYear(date1));
   }
}
// The example displays the following output:
//    Date (System.Globalization.GregorianCalendar): 1/22/1905
//    Date in Julian calendar: 01/09/1905
Imports System.Globalization

Module Example
   Public Sub Main()
      Dim julian As New JulianCalendar()
      Dim date1 As New Date(1905, 1, 9, julian)
      
      Console.WriteLine("Date ({0}): {1:d}", 
                        CultureInfo.CurrentCulture.Calendar,
                        date1)
      Console.WriteLine("Date in Julian calendar: {0:d2}/{1:d2}/{2:d4}",
                        julian.GetMonth(date1),
                        julian.GetDayOfMonth(date1),
                        julian.GetYear(date1))
   End Sub
End Module
' The example displays the following output:
'    Date (System.Globalization.GregorianCalendar): 1/22/1905
'    Date in Julian calendar: 01/09/1905

暦と日付範囲Calendars and date ranges

暦でサポートされている最も古い日付は、暦の Calendar.MinSupportedDateTime プロパティによって示されます。The earliest date supported by a calendar is indicated by that calendar's Calendar.MinSupportedDateTime property. GregorianCalendar クラスでは、その日付は西暦 0001 年 1 月 1 日 です。For the GregorianCalendar class, that date is January 1, 0001 C.E. .NET の他のカレンダーの大半は、以降の日付をサポートします。Most of the other calendars in .NET support a later date. 暦でサポートされている最も古い日付より前の日付と時刻の値を処理しようとすると、ArgumentOutOfRangeException 例外がスローされます。Trying to work with a date and time value that precedes a calendar's earliest supported date throws an ArgumentOutOfRangeException exception.

ただし、重要な例外が 1 つあります。However, there is one important exception. DateTime オブジェクトと DateTimeOffset オブジェクトの既定の (初期化されていない) 値は、GregorianCalendar.MinSupportedDateTime 値と同じです。The default (uninitialized) value of a DateTime object and a DateTimeOffset object is equal to the GregorianCalendar.MinSupportedDateTime value. 西暦 0001 年 1 月 1日をサポートしない予定表では、この日付の書式設定しようとする場合If you try to format this date in a calendar that does not support January 1, 0001 C.E. 書式指定子を指定しない、書式指定メソッドは、"G"(一般の日付/時刻のパターン) 書式指定子ではなく、"s"(並べ替え可能な日付/時刻のパターン) 書式指定子を使用します。and you do not provide a format specifier, the formatting method uses the "s" (sortable date/time pattern) format specifier instead of the "G" (general date/time pattern) format specifier. その結果、書式設定操作は ArgumentOutOfRangeException 例外をスローしません。As a result, the formatting operation does not throw an ArgumentOutOfRangeException exception. 代わりに、サポートされていない日付を返します。Instead, it returns the unsupported date. この問題を、次の例で説明します。この例は、現在のカルチャが日本語 (日本) に設定されていれば和暦で、アラビア語 (エジプト) に設定されていればウムアルクラ暦で、DateTime.MinValue の値を表示します。This is illustrated in the following example, which displays the value of DateTime.MinValue when the current culture is set to Japanese (Japan) with the Japanese calendar, and to Arabic (Egypt) with the Um Al Qura calendar. また、現在のカルチャを英語 (米国) に設定し、これらの各 DateTime.ToString(IFormatProvider) オブジェクトで CultureInfo メソッドを呼び出します。It also sets the current culture to English (United States) and calls the DateTime.ToString(IFormatProvider) method with each of these CultureInfo objects. どの場合も、並べ替え可能な日付と時刻のパターンを使用して、日付が表示されます。In each case, the date is displayed by using the sortable date/time pattern.

using System;
using System.Globalization;
using System.Threading;

public class Example
{
   public static void Main()
   {
      DateTime dat = DateTime.MinValue;
   
      // Change the current culture to ja-JP with the Japanese Calendar.
      CultureInfo jaJP = CultureInfo.CreateSpecificCulture("ja-JP");
      jaJP.DateTimeFormat.Calendar = new JapaneseCalendar();
      Thread.CurrentThread.CurrentCulture = jaJP;
      Console.WriteLine("Earliest supported date by {1} calendar: {0:d}", 
                        jaJP.DateTimeFormat.Calendar.MinSupportedDateTime,
                        GetCalendarName(jaJP));
      // Attempt to display the date.
      Console.WriteLine(dat.ToString());     
      Console.WriteLine();
      
      // Change the current culture to ar-EG with the Um Al Qura calendar.
      CultureInfo arEG = CultureInfo.CreateSpecificCulture("ar-EG");
      arEG.DateTimeFormat.Calendar = new UmAlQuraCalendar();
      Thread.CurrentThread.CurrentCulture = arEG;
      Console.WriteLine("Earliest supported date by {1} calendar: {0:d}", 
                        arEG.DateTimeFormat.Calendar.MinSupportedDateTime,
                        GetCalendarName(arEG));
      // Attempt to display the date.
      Console.WriteLine(dat.ToString());     
      Console.WriteLine();
      
      // Change the current culture to en-US.
      Thread.CurrentThread.CurrentCulture = CultureInfo.CreateSpecificCulture("en-US");
      Console.WriteLine(dat.ToString(jaJP));
      Console.WriteLine(dat.ToString(arEG));
      Console.WriteLine(dat.ToString("d"));
   }
   
   private static string GetCalendarName(CultureInfo culture)
   {
      Calendar cal = culture.DateTimeFormat.Calendar;
      return cal.GetType().Name.Replace("System.Globalization.", "").Replace("Calendar", "");  
   }
}
// The example displays the following output:
//       Earliest supported date by Japanese calendar: 明治 1/9/8
//       0001-01-01T00:00:00
//       
//       Earliest supported date by UmAlQura calendar: 01/01/18
//       0001-01-01T00:00:00
//       
//       0001-01-01T00:00:00
//       0001-01-01T00:00:00
//       1/1/0001
Imports System.Globalization
Imports System.Threading

Module Example
   Public Sub Main()
      Dim dat As Date = DateTime.MinValue
   
      ' Change the current culture to ja-JP with the Japanese Calendar.
      Dim jaJP As CultureInfo = CultureInfo.CreateSpecificCulture("ja-JP")
      jaJP.DateTimeFormat.Calendar = New JapaneseCalendar()
      Thread.CurrentThread.CurrentCulture = jaJP
      Console.WriteLine("Earliest supported date by {1} calendar: {0:d}", 
                        jaJP.DateTimeFormat.Calendar.MinSupportedDateTime,
                        GetCalendarName(jaJP))
      ' Attempt to display the date.
      Console.WriteLine(dat.ToString())     
      Console.WriteLine()
      
      ' Change the current culture to ar-EG with the Um Al Qura calendar.
      Dim arEG As CultureInfo = CultureInfo.CreateSpecificCulture("ar-EG")
      arEG.DateTimeFormat.Calendar = New UmAlQuraCalendar()
      Thread.CurrentThread.CurrentCulture = arEG
      Console.WriteLine("Earliest supported date by {1} calendar: {0:d}", 
                        arEG.DateTimeFormat.Calendar.MinSupportedDateTime,
                        GetCalendarName(arEG))
      ' Attempt to display the date.
      Console.WRiteLine(dat.ToString())     
      Console.WRiteLine()
      
      ' Change the current culture to en-US.
      Thread.CurrentThread.CurrentCulture = CultureInfo.CreateSpecificCulture("en-US")
      Console.WriteLine(dat.ToString(jaJP))
      Console.WriteLine(dat.ToString(arEG))
      Console.WriteLine(dat.ToString("d"))
   End Sub
   
   Private Function GetCalendarName(culture As CultureInfo) As String
      Dim cal As Calendar = culture.DateTimeFormat.Calendar
      Return cal.GetType().Name.Replace("System.Globalization.", "").Replace("Calendar", "")  
   End Function
End Module
' The example displays the following output:
'       Earliest supported date by Japanese calendar: 明治 1/9/8
'       0001-01-01T00:00:00
'       
'       Earliest supported date by UmAlQura calendar: 01/01/18
'       0001-01-01T00:00:00
'       
'       0001-01-01T00:00:00
'       0001-01-01T00:00:00
'       1/1/0001

時代 (年号) の操作Working with eras

暦では通常、日付が時代 (年号) に分けられます。Calendars typically divide dates into eras. ただし、 Calendar .NET のクラスは、予定表とのほとんどによって定義されたすべての時代をサポートしていません、Calendarクラスは時代は 1 つのみをサポートします。However, the Calendar classes in .NET do not support every era defined by a calendar, and most of the Calendar classes support only a single era. 複数の時代 (年号) をサポートしているのは、JapaneseCalendar クラスと JapaneseLunisolarCalendar クラスだけです。Only the JapaneseCalendar and JapaneseLunisolarCalendar classes support multiple eras.

重要

Reiwa の時代 (年号) で新しい時代 (年号)、JapaneseCalendarJapaneseLunisolarCalendar2019 年 5 月 1 日です。The Reiwa era, a new era in the JapaneseCalendar and JapaneseLunisolarCalendar, begins on May 1, 2019. この変更は、これらのカレンダーを使用するすべてのアプリケーションに影響します。This change affects all applications that use these calendars. 詳細については、次の記事を参照してください。See the following articles for more information:

ほとんどのカレンダーの時代 (年号) では、非常に長い期間を表します。An era in most calendars denotes an extremely long time period. グレゴリオ暦でなど、現在の時代 (年号) にまたがる複数の 2 つ millennia。In the Gregorian calendar, for example, the current era spans more than two millennia. JapaneseCalendarJapaneseLunisolarCalendar、複数の時代 (年号) をサポートする予定表、2 つ、これは、ケースではありません。For the JapaneseCalendar and the JapaneseLunisolarCalendar, the two calendars that support multiple eras, this is not the case. 時代 (年号) は、皇帝の量を設定の期間に対応します。An era corresponds to the period of an emperor's reign. サポートの時代 (年号) を複数にするため、特に現在の時代 (年号) の数の上限が、不明の場合は、特別な課題をもたらします。Support for multiple eras, particularly when the upper limit of the current era is unknown, poses special challenges.

時代 (年号) と時代 (年号) の名前Eras and era names

.NET では、特定の暦の実装でサポートされる時代 (年号) を表す整数が逆の順序で格納、Calendar.Eras配列。In .NET, integers that represent the eras supported by a particular calendar implementation are stored in reverse order in the Calendar.Eras array. 現在の時代 (年号) (つまり、時代 (年号) の最新の時間範囲) には、インデックス 0 位置にあると、Calendar複数の時代 (年号)、連続する各インデックスをサポートするクラスには、前の時代 (年号) が反映されます。The current era (which is the era with the latest time range) is at index zero, and for Calendar classes that support multiple eras, each successive index reflects the previous era. Calendar.CurrentEra 配列における現在の時代 (年号) のインデックスは、静的な Calendar.Eras プロパティで定義されます。これは定数であり、値は常に 0 になります。The static Calendar.CurrentEra property defines the index of the current era in the Calendar.Eras array; it is a constant whose value is always zero. 個々の Calendar クラスには、現在の時代 (年号) の値を返す静的フィールドも含まれています。Individual Calendar classes also include static fields that return the value of the current era. これらを次の表に示します。They are listed in the following table.

Calendar クラスCalendar class 現在の時代 (年号) のフィールドCurrent era field
ChineseLunisolarCalendar ChineseEra
GregorianCalendar ADEra
HebrewCalendar HebrewEra
HijriCalendar HijriEra
JapaneseLunisolarCalendar JapaneseEra
JulianCalendar JulianEra
KoreanCalendar KoreanEra
KoreanLunisolarCalendar GregorianEra
PersianCalendar PersianEra
ThaiBuddhistCalendar ThaiBuddhistEra
UmAlQuraCalendar UmAlQuraEra

特定の時代 (年号) を表す数値に対応する名前は、その数値を DateTimeFormatInfo.GetEraName メソッドまたは DateTimeFormatInfo.GetAbbreviatedEraName メソッドに渡すことで取得できます。The name that corresponds to a particular era number can be retrieved by passing the era number to the DateTimeFormatInfo.GetEraName or DateTimeFormatInfo.GetAbbreviatedEraName method. 次の例では、これらのメソッドを呼び出して、GregorianCalendar クラスでサポートされる時代 (年号) に関する情報を取得しています。The following example calls these methods to retrieve information about era support in the GregorianCalendar class. 各サポートされている日本語のカレンダーの時代 (年号) の 2 つ目の年の 1 月 1 日に対応するグレゴリオ暦の日付と現在時代 (年号) の 2 つ目の年の 1 月 1 日に対応するグレゴリオ暦の日付が表示されます。It displays the Gregorian calendar date that corresponds to January 1 of the second year of the current era, as well as the Gregorian calendar date that corresponds to January 1 of the second year of each supported Japanese calendar era.

using System;
using System.Globalization;

public class Example
{
   public static void Main()
   {
      int year = 2;
      int month = 1;
      int day = 1;
      Calendar cal = new JapaneseCalendar();

      Console.WriteLine("\nDate instantiated without an era:");
      DateTime date1 = new DateTime(year, month, day, 0, 0, 0, 0, cal);
      Console.WriteLine("{0}/{1}/{2} in Japanese Calendar -> {3:d} in Gregorian", 
                        cal.GetMonth(date1), cal.GetDayOfMonth(date1),
                        cal.GetYear(date1), date1);
      
      Console.WriteLine("\nDates instantiated with eras:");
      foreach (int era in cal.Eras) {
         DateTime date2 = cal.ToDateTime(year, month, day, 0, 0, 0, 0, era);
         Console.WriteLine("{0}/{1}/{2} era {3} in Japanese Calendar -> {4:d} in Gregorian", 
                           cal.GetMonth(date2), cal.GetDayOfMonth(date2),
                           cal.GetYear(date2), cal.GetEra(date2), date2);
      }                        
   }
}
Imports System.Globalization

Module Example
   Public Sub Main()
      Dim year As Integer = 2
      Dim month As Integer = 1
      Dim day As Integer = 1
      Dim cal As New JapaneseCalendar()

      Console.WriteLine("Date instantiated without an era:")
      Dim date1 As New Date(year, month, day, 0, 0, 0, 0, cal)
      Console.WriteLine("{0}/{1}/{2} in Japanese Calendar -> {3:d} in Gregorian", 
                        cal.GetMonth(date1), cal.GetDayOfMonth(date1),
                        cal.GetYear(date1), date1)
      Console.WriteLine()
      
      Console.WriteLine("Dates instantiated with eras:")
      For Each era As Integer In cal.Eras
         Dim date2 As Date = cal.ToDateTime(year, month, day, 0, 0, 0, 0, era)
         Console.WriteLine("{0}/{1}/{2} era {3} in Japanese Calendar -> {4:d} in Gregorian", 
                           cal.GetMonth(date2), cal.GetDayOfMonth(date2),
                           cal.GetYear(date2), cal.GetEra(date2), date2)
      Next                        
   End Sub
End Module

また、"g" カスタム日時書式指定文字列では、日付と時刻の文字列形式に暦の時代 (年号) の名前が含まれます。In addition, the "g" custom date and time format string includes a calendar's era name in the string representation of a date and time. 詳細については、次を参照してください。カスタム日時書式指定文字列します。For more information, see Custom date and time format strings.

日付、時代 (年号) のインスタンス化します。Instantiating a date with an era

2 つのCalendar複数の時代 (年号) をサポートするクラスでは、特定の年、月、および日の月の値で構成される日付をあいまいになることができます。For the two Calendar classes that support multiple eras, a date that consists of a particular year, month, and day of the month value can be ambiguous. たとえば、すべて時代 (年号) でサポートされている、JapaneseCalendarの数は 1 年があります。For example, all eras supported by the JapaneseCalendar have years whose number is 1. 通常、時代 (年号) が指定されていない場合は、日時および暦のどちらのメソッドでも、値が現在の時代 (年号) に属すると見なされます。Ordinarily, if an era is not specified, both date and time and calendar methods assume that values belong to the current era. 場合は true これは、DateTimeDateTimeOffset型のパラメーターを含むコンス トラクター Calendar、だけでなくJapaneseCalendar.ToDateTimeJapaneseLunisolarCalendar.ToDateTime。メソッド。This is true of the DateTime and DateTimeOffset constructors that include parameters of type Calendar, as well as the JapaneseCalendar.ToDateTime and JapaneseLunisolarCalendar.ToDateTime methods. 次の例は、指定されていない、時代 (年号) の 2 つ目の年の 1 月 1 日を表す日付をインスタンス化します。The following example instantiates a date that represents January 1 of the second year of an unspecified era. Reiwa の時代 (年号) が現在の時代 (年号) の例を実行する場合は、日付が Reiwa の時代 (年号) の 2 つ目の年として解釈されます。If you execute the example when the Reiwa era is the current era, the date is interpreted as the second year of the Reiwa era. 時代 (年号)、令和、によって返される文字列の年の前に、DateTime.ToString(String, IFormatProvider)メソッド、グレゴリオ暦で 2020 年 1 月 1日年に対応しています。The era, 令和, precedes the year in the string returned by the DateTime.ToString(String, IFormatProvider) method and corresponds to January 1, 2020, in the Gregorian calendar. (Reiwa の時代 (年号) を構成のグレゴリオ暦カレンダーの 2019 年の開始) します。(The Reiwa era begins in the year 2019 of the Gregorian calendar.)

using System;
using System.Globalization;

public class Example
{
    public static void Main()
    {
        var japaneseCal = new JapaneseCalendar();
        var jaJp = new CultureInfo("ja-JP");
        jaJp.DateTimeFormat.Calendar = japaneseCal;

        var date = new DateTime(2, 1, 1, japaneseCal);
        Console.WriteLine($"Gregorian calendar date: {date:d}");
        Console.WriteLine($"Japanese calendar date: {date.ToString("d", jaJp)}");

        
    }
}
Imports System.Globalization

Public Module Example
    Public Sub Main()
        Dim japaneseCal = New JapaneseCalendar()
        Dim jaJp = New CultureInfo("ja-JP")
        jaJp.DateTimeFormat.Calendar = japaneseCal

        Dim dat = New DateTime(2, 1, 1, japaneseCal)
        Console.WriteLine($"Gregorian calendar dat: {dat:d}")
        Console.WriteLine($"Japanese calendar dat: {dat.ToString("d", jaJp)}")
    End Sub
End Module

ただし、時代 (年号) が変更された場合このコードの意図はあいまいになります。However, if the era changes, the intent of this code becomes ambiguous. 現在時代 (年号) の 2 つ目の年を表すため、日付に使用またはこれ平成の時代 (年号) の 2 つ目の年を表すためのものですか。Is the date intended to represent the second year of the current era, or is it intended to represent the second year of the Heisei era? このあいまいさを回避するために 2 つの方法はあります。There are two ways to avoid this ambiguity:

  • 既定値を使用して日付と時刻の値をインスタンス化GregorianCalendarクラス。Instantiate the date and time value using the default GregorianCalendar class. 次の例のように、日付の文字列表現の日本語のカレンダーまたは日本の太陰太陽暦を使用できます。You can then use the Japanese calendar or the Japanese Lunisolar calendar for the string representation of dates, as the following example shows.

    using System;
    using System.Globalization;
    
    public class Example
    {
        public static void Main()
        {
            var japaneseCal = new JapaneseCalendar();
            var jaJp = new CultureInfo("ja-JP");
            jaJp.DateTimeFormat.Calendar = japaneseCal;
      
            var date = new DateTime(1905, 2, 12);
            Console.WriteLine($"Gregorian calendar date: {date:d}");
    
            // Call the ToString(IFormatProvider) method.
            Console.WriteLine($"Japanese calendar date: {date.ToString("d", jaJp)}");
            
            // Use a FormattableString object.
            FormattableString fmt = $"{date:d}";
            Console.WriteLine($"Japanese calendar date: {fmt.ToString(jaJp)}");
    
            // Use the JapaneseCalendar object.
            Console.WriteLine($"Japanese calendar date: {jaJp.DateTimeFormat.GetEraName(japaneseCal.GetEra(date))}" +
                              $"{japaneseCal.GetYear(date)}/{japaneseCal.GetMonth(date)}/{japaneseCal.GetDayOfMonth(date)}");
    
            // Use the current culture.
            CultureInfo.CurrentCulture = jaJp;
            Console.WriteLine($"Japanese calendar date: {date:d}");
        }
    }
    // The example displays the following output:
    //   Gregorian calendar date: 2/12/1905
    //   Japanese calendar date: 明治38/2/12
    //   Japanese calendar date: 明治38/2/12
    //   Japanese calendar date: 明治38/2/12
    //   Japanese calendar date: 明治38/2/12
    
    Imports System.Globalization
    
    Public Module Example
        Public Sub Main()
            Dim japaneseCal = New JapaneseCalendar()
            Dim jaJp = New CultureInfo("ja-JP")
            jaJp.DateTimeFormat.Calendar = japaneseCal
      
            Dim dat = New DateTime(1905, 2, 12)
            Console.WriteLine($"Gregorian calendar date: {dat:d}")
    
            ' Call the ToString(IFormatProvider) method.
            Console.WriteLine($"Japanese calendar date: {dat.ToString("d", jaJp)}")
            
            ' Use a FormattableString object.
            Dim fmt As FormattableString = $"{dat:d}"
            Console.WriteLine($"Japanese calendar date: {fmt.ToString(jaJp)}")
    
            ' Use the JapaneseCalendar object.
            Console.WriteLine($"Japanese calendar date: {jaJp.DateTimeFormat.GetEraName(japaneseCal.GetEra(dat))}" +
                              $"{japaneseCal.GetYear(dat)}/{japaneseCal.GetMonth(dat)}/{japaneseCal.GetDayOfMonth(dat)}")
    
            ' Use the current culture.
            CultureInfo.CurrentCulture = jaJp
            Console.WriteLine($"Japanese calendar date: {dat:d}")
        End Sub
    End Module
    ' The example displays the following output:
    '   Gregorian calendar date: 2/12/1905
    '   Japanese calendar date: 明治38/2/12
    '   Japanese calendar date: 明治38/2/12
    '   Japanese calendar date: 明治38/2/12
    '   Japanese calendar date: 明治38/2/12
    
    
    
  • 日付と時刻、時代 (年号) を明示的に指定するメソッドを呼び出します。Call a date and time method that explicitly specifies an era. これには、次のメソッドが含まれます。This includes the following methods:

    次の例では、これらのメソッドの 3 つを使用して、1868 年 9 月 8 日に開始され、1912 年 7 月 29 日に終了しましたが、明治で日時をインスタンス化します。The following example uses three of these methods to instantiate a date and time in the Meiji era, which began on September 8, 1868, and ended on July 29, 1912.

    using System;
    using System.Globalization;
    
    public class Example
    {
        public static void Main()
        {
            var japaneseCal = new JapaneseCalendar();
            var jaJp = new CultureInfo("ja-JP");
            jaJp.DateTimeFormat.Calendar = japaneseCal;
      
            // We can get the era index by calling DateTimeFormatInfo.GetEraName.
            int eraIndex = 0;
    
            for (int ctr = 0; ctr < jaJp.DateTimeFormat.Calendar.Eras.Length; ctr++) 
               if (jaJp.DateTimeFormat.GetEraName(ctr) == "明治")
                  eraIndex = ctr; 
            var date1 = japaneseCal.ToDateTime(23, 9, 8, 0, 0, 0, 0, eraIndex);
            Console.WriteLine($"{date1.ToString("d", jaJp)} (Gregorian {date1:d}");
    
            try {
                var date2 = DateTime.Parse("明治23/9/8", jaJp);
                Console.WriteLine($"{date1.ToString("d", jaJp)} (Gregorian {date1:d}");
            }
            catch (FormatException)
            {
                Console.WriteLine("The parsing operation failed.");
            }
    
            try {
                var date3 = DateTime.ParseExact("明治23/9/8", "gyy/m/d", jaJp);
                Console.WriteLine($"{date1.ToString("d", jaJp)} (Gregorian {date1:d}");
            }
            catch (FormatException)
            {
                Console.WriteLine("The parsing operation failed.");
            }
        }
    }
    // The example displays the following output:
    //   明治23/9/8 (Gregorian 9/8/1890
    //   明治23/9/8 (Gregorian 9/8/1890
    //   明治23/9/8 (Gregorian 9/8/1890
    
    
    Imports System.Globalization
    
    Public Module Example
        Public Sub Main()
            Dim japaneseCal = New JapaneseCalendar()
            Dim jaJp = New CultureInfo("ja-JP")
            jaJp.DateTimeFormat.Calendar = japaneseCal
      
            ' We can get the era index by calling DateTimeFormatInfo.GetEraName.
           Dim eraIndex As Integer = 0
    
            For ctr As Integer = 0 To jaJp.DateTimeFormat.Calendar.Eras.Length - 1 
               If jaJp.DateTimeFormat.GetEraName(ctr) = "明治" Then eraIndex = ctr 
            Next
            Dim date1 = japaneseCal.ToDateTime(23, 9, 8, 0, 0, 0, 0, eraIndex)
            Console.WriteLine($"{date1.ToString("d", jaJp)} (Gregorian {date1:d}")
    
            Try 
                Dim date2 = DateTime.Parse("明治23/9/8", jaJp)
                Console.WriteLine($"{date1.ToString("d", jaJp)} (Gregorian {date1:d}")
            Catch e As FormatException
                Console.WriteLine("The parsing operation failed.")
            End Try
    
            Try 
                Dim date3 = DateTime.ParseExact("明治23/9/8", "gyy/m/d", jaJp)
                Console.WriteLine($"{date1.ToString("d", jaJp)} (Gregorian {date1:d}")
            Catch e As FormatException
                Console.WriteLine("The parsing operation failed.")
            End Try
        End Sub
    End Module
    ' The example displays the following output:
    '   明治23/9/8 (Gregorian 9/8/1890
    '   明治23/9/8 (Gregorian 9/8/1890
    '   明治23/9/8 (Gregorian 9/8/1890
    

ヒント

複数の時代をサポートするカレンダーの使用時に常にグレゴリオ暦の日付を使用して、日付をインスタンス化するか、日付と時刻をカレンダーに基づくをインスタンス化するときに時代 (年号) を指定します。When working with calendars that support multiple eras, always use the Gregorian date to instantiate a date, or specify the era when you instantiate a date and time based on that calendar.

時代 (年号) を指定するときに、ToDateTime(Int32, Int32, Int32, Int32, Int32, Int32, Int32, Int32)でカレンダーの時代 (年号) のインデックスを指定するメソッド、Erasプロパティ。In specifying an era to the ToDateTime(Int32, Int32, Int32, Int32, Int32, Int32, Int32, Int32) method, you provide the index of the era in the calendar's Eras property. 暦の時代 (年号) が変更される可能性が、ただし、これらのインデックスは、定数値です。インデックス 0、現在の時代 (年号) があり、インデックス位置にある最も古い時代 (年号)Eras.Length - 1します。For calendars whose eras are subject to change, however, these indexes are not constant values; the current era is at index 0, and the oldest era is at index Eras.Length - 1. カレンダーに新しい時代 (年号) を追加するときに、前の時代 (年号) のインデックスは 1 ずつ増加します。When a new era is added to a calendar, the indexes of the previous eras increase by one. 次のように、適切な時代 (年号) のインデックスを指定できます。You can supply the appropriate era index as follows:

  • 現在の時代 (年号) の日付、カレンダーを使用して常にCurrentEraプロパティ。For dates in the current era, always use the calendar's CurrentEra property.

  • 指定した時代 (年号) の日付を使用して、DateTimeFormatInfo.GetEraNameメソッドを指定した時代 (年号) の名前に対応するインデックスを取得します。For dates in a specified era, use the DateTimeFormatInfo.GetEraName method to retrieve the index that corresponds to a specified era name. これは、ことが必要、JapaneseCalendarの現在のカレンダー、 CultureInfo JA-JP カルチャを表すオブジェクト。This requires that the JapaneseCalendar be the current calendar of the CultureInfo object that represents the ja-JP culture. (この手法はのJapaneseLunisolarCalendarとして同じ時代 (年号) をサポート後も、 JapaneseCalendar)。前の例では、このアプローチを示します。(This technique works for the JapaneseLunisolarCalendar as well, since it supports the same eras as the JapaneseCalendar.) The previous example illustrates this approach.

予定表、時代 (年号)、および日付の範囲:厳密でない範囲の確認Calendars, eras, and date ranges: Relaxed range checks

個々 の予定表に、日付範囲がサポートされているに見えるの時代 (年号)、JapaneseCalendarJapaneseLunisolarCalendarクラスもがサポートされている範囲です。Very much like individual calendars have supported date ranges, eras in the JapaneseCalendar and JapaneseLunisolarCalendar classes also have supported ranges. 以前は、.NET は、範囲が、時代 (年号) 固有の日付がその時代 (年号) の範囲内にあったことを確認しますに厳密な時代 (年号) を使用します。Previously, .NET used strict era range checks to ensure that an era-specific date was within the range of that era. つまり、日付が指定した時代 (年号) の範囲外にある場合は、メソッドがスローします。、ArgumentOutOfRangeExceptionします。That is, if a date is outside of the range of the specified era, the method throws an ArgumentOutOfRangeException. 現時点では、.NET は既定では厳密でない範囲チェックを使用します。Currently, .NET uses relaxed ranged checking by default. 更新プログラムをすべてのバージョンの .NET には緩やかな時代 (年号) が導入された範囲のチェック。次時代 (年号) に、「オーバーフロー」を指定した時代 (年号) の範囲外の時代 (年号) 固有の日付をインスタンス化しようと、例外はスローされません。Updates to all versions of .NET introduced relaxed era range checks; the attempt to instantiate an era-specific date that is outside the range of the specified era "overflows" into the following era, and no exception is thrown.

次の例は、1926 年 12 月 25 日に開始され、1989 年 1 月 7 日に終了しましたが、昭和時代 65th 年の日付をインスタンス化しようとします。The following example attempts to instantiate a date in the 65th year of the Showa era, which began on December 25, 1926 and ended on January 7, 1989. この日付に対応する、1990 年 1 月 9 日で表示する時代 (年号) の範囲外である、JapaneseCalendarします。This date corresponds to January 9, 1990, which is outside the range of the Showa era in the JapaneseCalendar. 例の出力に示すように、例では、によって表示される日付は 1990 年 1 月 9日平成の時代 (年号) の 2 つ目の年です。As the output from the example illustrates, the date displayed by the example is January 9, 1990, in the second year of the Heisei era.

using System;
using System.Globalization;

public class Example
{
   public static void Main()
   {
      var jaJp = new CultureInfo("ja-JP");
      var cal = new JapaneseCalendar();
      jaJp.DateTimeFormat.Calendar = cal;
      string showaEra = "昭和";

      var dt = cal.ToDateTime(65, 1, 9, 15, 0, 0, 0, GetEraIndex(showaEra));
      FormattableString fmt = $"{dt:d}";

      Console.WriteLine($"Japanese calendar date: {fmt.ToString(jaJp)}");
      Console.WriteLine($"Gregorian calendar date: {fmt}");

      int GetEraIndex(string eraName)
      {
         foreach (var ctr in cal.Eras)
            if (jaJp.DateTimeFormat.GetEraName(ctr) == eraName)
               return ctr;

         return 0; 
      }
   }
}
// The example displays the following output:
//   Japanese calendar date: 平成2/1/9
//   Gregorian calendar date: 1/9/1990
Imports System.Globalization

Public Module Example
   Dim jaJp As CultureInfo
   Dim cal As Calendar

   Public Sub Main()
      jaJp = New CultureInfo("ja-JP")  
      cal = New JapaneseCalendar()
      jaJp.DateTimeFormat.Calendar = cal
      Dim showaEra = "昭和"

      Dim dt = cal.ToDateTime(65, 1, 9, 15, 0, 0, 0, GetEraIndex(showaEra))
      Dim fmt As FormattableString = $"{dt:d}"
      Console.WriteLine($"Japanese calendar date: {fmt.ToString(jaJp)}")
      Console.WriteLine($"Gregorian calendar date: {fmt}")
   End Sub
  
   Private Function GetEraIndex(eraName As String) As Integer
      For Each ctr As Integer In cal.Eras
         If jaJp.DateTimeFormat.GetEraName(ctr) = eraName Then Return ctr
      Next
      Return 0
   End Function
End Module
' The example displays the following output:
'   Japanese calendar date: 平成2/1/9
'   Gregorian calendar date: 1/9/1990

厳密でない範囲の確認が望ましくない場合は、さまざまな方法は、アプリケーションが実行されている .NET のバージョンによっては、厳密な範囲の確認を戻すことができます。If relaxed range checks are undesirable, you can restore strict range checks in a number of ways, depending on the version of .NET on which your application is running:

  • .NET core: 次を追加することができます、 . netcore.runtime.json構成ファイル。.NET Core: You can add the following to the .netcore.runtime.json config file:

    "runtimeOptions": {
        "configProperties": {
           "Switch.System.Globalization.EnforceJapaneseEraYearRanges": true
        } 
    }
    
  • .NET framework 4.6 以降: 次の AppContext スイッチを設定することができます。.NET Framework 4.6 or later: You can set the following AppContext switch:

    <?xml version="1.0" encoding="utf-8"?>
    <configuration>
       <runtime>
         <AppContextSwitchOverrides value="Switch.System.Globalization.EnforceJapaneseEraYearRanges=true" />
       </runtime>
    </configuration>
    
  • .NET framework 4.5.2 以前のバージョン。 次のレジストリ値を設定することができます。.NET Framework 4.5.2 or earlier: You can set the following registry value:

    キーKey HKEY_LOCAL_MACHINE\Software\Microsoft.NETFramework\AppContextHKEY_LOCAL_MACHINE\Software\Microsoft.NETFramework\AppContext
    名前Name Switch.System.Globalization.EnforceJapaneseEraYearRangesSwitch.System.Globalization.EnforceJapaneseEraYearRanges
    Type REG_SZREG_SZ
    [値]Value 11

厳密な範囲チェックを有効に、前の例がスローされます、ArgumentOutOfRangeExceptionし、次の出力を表示します。With strict range checks enabled, the previous example throws an ArgumentOutOfRangeException and displays the following output:

Unhandled Exception: System.ArgumentOutOfRangeException: Valid values are between 1 and 64, inclusive.
Parameter name: year
   at System.Globalization.GregorianCalendarHelper.GetYearOffset(Int32 year, Int32 era, Boolean throwOnError)
   at System.Globalization.GregorianCalendarHelper.ToDateTime(Int32 year, Int32 month, Int32 day, Int32 hour, Int32 minute, Int32 second, Int32 millisecond, Int32 era)
   at Example.Main()

複数の時代 (年号) を含む暦で日付を表すRepresenting dates in calendars with multiple eras

Calendar オブジェクトの現在の暦が、時代 (年号) をサポートする CultureInfo オブジェクトである場合は、完全な日付と時刻、長い日付、および短い日付の各パターンにおいて、日付と時刻の値の文字列形式に時代 (年号) が含まれます。If a Calendar object supports eras and is the current calendar of a CultureInfo object, the era is included in the string representation of a date and time value for the full date and time, long date, and short date patterns. それらの日付パターンを表示する例を次に示します。現在のカルチャは日本 (日本語)、現在の暦は和暦です。The following example displays these date patterns when the current culture is Japan (Japanese) and the current calendar is the Japanese calendar.

using System;
using System.Globalization;
using System.IO;
using System.Threading;

public class Example
{
   public static void Main()
   {
      StreamWriter sw = new StreamWriter(@".\eras.txt");
      DateTime dt = new DateTime(2012, 5, 1);
      
      CultureInfo culture = CultureInfo.CreateSpecificCulture("ja-JP");
      DateTimeFormatInfo dtfi = culture.DateTimeFormat;
      dtfi.Calendar = new JapaneseCalendar();
      Thread.CurrentThread.CurrentCulture = culture;
      
      sw.WriteLine("\n{0,-43} {1}", "Full Date and Time Pattern:", dtfi.FullDateTimePattern);
      sw.WriteLine(dt.ToString("F"));
      sw.WriteLine();
      
      sw.WriteLine("\n{0,-43} {1}", "Long Date Pattern:", dtfi.LongDatePattern);
      sw.WriteLine(dt.ToString("D"));
      
      sw.WriteLine("\n{0,-43} {1}", "Short Date Pattern:", dtfi.ShortDatePattern);
      sw.WriteLine(dt.ToString("d"));
      sw.Close();
    }
}
// The example writes the following output to a file:
//    Full Date and Time Pattern:                 gg y'年'M'月'd'日' H:mm:ss
//    平成 24年5月1日 0:00:00
//    
//    Long Date Pattern:                          gg y'年'M'月'd'日'
//    平成 24年5月1日
//    
//    Short Date Pattern:                         gg y/M/d
//    平成 24/5/1
Imports System.Globalization
Imports System.IO
Imports System.Threading

Module Example
   Public Sub Main()
      Dim sw As New StreamWriter(".\eras.txt")
      Dim dt As Date = #05/01/2012#
      
      Dim culture As CultureInfo = CultureInfo.CreateSpecificCulture("ja-JP")
      Dim dtfi As DateTimeFormatInfo = culture.DateTimeFormat
      dtfi.Calendar = New JapaneseCalendar()
      Thread.CurrentThread.CurrentCulture = culture
      
      sw.WriteLine("{0,-43} {1}", "Full Date and Time Pattern:", dtfi.FullDateTimePattern)
      sw.WriteLine(dt.ToString("F"))
      sw.WriteLine()
      
      sw.WriteLine("{0,-43} {1}", "Long Date Pattern:", dtfi.LongDatePattern)
      sw.WriteLine(dt.ToString("D"))
      sw.WriteLine()
      
      sw.WriteLine("{0,-43} {1}", "Short Date Pattern:", dtfi.ShortDatePattern)
      sw.WriteLine(dt.ToString("d"))
      sw.WriteLine()
      sw.Close()
   End Sub
End Module
' The example writes the following output to a file:
'    Full Date and Time Pattern:                 gg y'年'M'月'd'日' H:mm:ss
'    平成 24年5月1日 0:00:00
'    
'    Long Date Pattern:                          gg y'年'M'月'd'日'
'    平成 24年5月1日
'    
'    Short Date Pattern:                         gg y/M/d
'    平成 24/5/1 

警告

JapaneseCalendarクラスが唯一のカレンダー クラスの現在の暦は、両方のサポートしている日付の 1 つ以上の時代 (年号) に .NET で、CultureInfoオブジェクト - 具体的には、CultureInfo日本語 (日本) のカルチャを表すオブジェクト。The JapaneseCalendar class is the only calendar class in .NET that both supports dates in more than one era and that can be the current calendar of a CultureInfo object - specifically, of a CultureInfo object that represents the Japanese (Japan) culture.

どの暦の場合も、"g" カスタム書式指定子の結果の文字列には時代 (年号) が含まれます。For all calendars, the "g" custom format specifier includes the era in the result string. 次の例では、"MM-dd-yyyy g" というカスタム書式指定文字列を使用して、結果の文字列に時代 (年号) を含めています。現在の暦はグレゴリオ暦です。The following example uses the "MM-dd-yyyy g" custom format string to include the era in the result string when the current calendar is the Gregorian calendar.

   DateTime dat = new DateTime(2012, 5, 1);
   Console.WriteLine("{0:MM-dd-yyyy g}", dat);
// The example displays the following output:
//     05-01-2012 A.D.      
Dim dat As Date = #05/01/2012#
Console.WriteLine("{0:MM-dd-yyyy g}", dat)
' The example displays the following output:
'     05-01-2012 A.D.      

日付の文字列形式を現在の暦以外の暦で表す場合は、Calendar クラスの Calendar.GetEra メソッドを Calendar.GetYearCalendar.GetMonth、および Calendar.GetDayOfMonth の各メソッドと一緒に使用して、日付とそれが属する時代 (年号) を明確に示すことができます。In cases where the string representation of a date is expressed in a calendar that is not the current calendar, the Calendar class includes a Calendar.GetEra method that can be used along with the Calendar.GetYear, Calendar.GetMonth, and Calendar.GetDayOfMonth methods to unambiguously indicate a date as well as the era to which it belongs. JapaneseLunisolarCalendar クラスを使用した具体的な例を次に示します。The following example uses the JapaneseLunisolarCalendar class to provide an illustration. ただし、時代 (年号) を表す整数ではなく、名前または省略形を結果の文字列に含めるには、DateTimeFormatInfo オブジェクトをインスタンス化し、その現在の暦を JapaneseCalendar にする必要があります However, note that including a meaningful name or abbreviation instead of an integer for the era in the result string requires that you instantiate a DateTimeFormatInfo object and make JapaneseCalendar its current calendar. (JapaneseLunisolarCalendar 暦をカルチャの現在の暦にすることはできませんが、この場合は 2 つの暦で同じ時代 (年号) が共有されます)。(The JapaneseLunisolarCalendar calendar cannot be the current calendar of any culture, but in this case the two calendars share the same eras.)

using System;
using System.Globalization;

public class Example
{
   public static void Main()
   {
      DateTime date1 = new DateTime(2011, 8, 28);
      Calendar cal = new JapaneseLunisolarCalendar();
      
      Console.WriteLine("{0} {1:d4}/{2:d2}/{3:d2}", 
                        cal.GetEra(date1),
                        cal.GetYear(date1),
                        cal.GetMonth(date1),
                        cal.GetDayOfMonth(date1)); 
                        
      // Display eras
      CultureInfo culture = CultureInfo.CreateSpecificCulture("ja-JP");
      DateTimeFormatInfo dtfi = culture.DateTimeFormat;
      dtfi.Calendar = new JapaneseCalendar();
      
      Console.WriteLine("{0} {1:d4}/{2:d2}/{3:d2}", 
                        dtfi.GetAbbreviatedEraName(cal.GetEra(date1)),
                        cal.GetYear(date1),
                        cal.GetMonth(date1),
                        cal.GetDayOfMonth(date1)); 
   }
}
// The example displays the following output:
//       4 0023/07/29
//       平 0023/07/29
Imports System.Globalization

Module Example
   Public Sub Main()
      Dim date1 As Date = #8/28/2011#
      Dim cal As New JapaneseLunisolarCalendar()
      Console.WriteLine("{0} {1:d4}/{2:d2}/{3:d2}", 
                        cal.GetEra(date1),
                        cal.GetYear(date1),
                        cal.GetMonth(date1),
                        cal.GetDayOfMonth(date1)) 
                        
      ' Display eras
      Dim culture As CultureInfo = CultureInfo.CreateSpecificCulture("ja-JP")
      Dim dtfi As DateTimeFormatInfo = culture.DateTimeFormat
      dtfi.Calendar = New JapaneseCalendar()
      
      Console.WriteLine("{0} {1:d4}/{2:d2}/{3:d2}", 
                        dtfi.GetAbbreviatedEraName(cal.GetEra(date1)),
                        cal.GetYear(date1),
                        cal.GetMonth(date1),
                        cal.GetDayOfMonth(date1)) 
   End Sub
End Module
' The example displays the following output:
'       4 0023/07/29
'       平 0023/07/29

日本語のカレンダー、時代 (年号) の最初の年を元年 (元年) と呼びます。In the Japanese calendars, the first year of an era is called Gannen (元年). たとえば、平成の 1 ではなく平成の時代 (年号) の最初の年を平成元年として記述することができます。For example, instead of Heisei 1, the first year of the Heisei era can be described as Heisei Gannen. .NET 書式設定の日付の操作では、この規則を採用して、時刻書式設定された次の標準またはカスタムの日付と時刻の形式で文字列を使用している場合、 CultureInfo 、日本語、日本("JA-JP")のカルチャを表すオブジェクトをJapaneseCalendarクラス。.NET adopts this convention in formatting operations for dates and times formatted with the following standard or custom date and time format strings when they are used with a CultureInfo object that represents the Japanese-Japan ("ja-JP") culture with the JapaneseCalendar class:

次の例がで平成時代 (年号) の最初の年の日付を表示するなど、JapaneseCalendarします。For example, the following example displays a date in the first year of the Heisei era in the JapaneseCalendar .

using System;
using System.Globalization;

public class Example
{
    public static void Main()
    {
         var enUs = new CultureInfo("en-US");
        var japaneseCal = new JapaneseCalendar();
        var jaJp = new CultureInfo("ja-JP");
        jaJp.DateTimeFormat.Calendar = japaneseCal;
        string heiseiEra = "平成";

        var date = japaneseCal.ToDateTime(1, 8, 18, 0, 0, 0, 0, GetEraIndex(heiseiEra));
        FormattableString fmt = $"{date:D}";
        Console.WriteLine($"Japanese calendar date: {fmt.ToString(jaJp)} (Gregorian: {fmt.ToString(enUs)})");

        int GetEraIndex(string eraName)
        {
           foreach (var ctr in japaneseCal.Eras)
              if (jaJp.DateTimeFormat.GetEraName(ctr) == eraName)
                 return ctr;

           return 0; 
        }
    }
}
// The example displays the following output:
//    Japanese calendar date: 平成元年8月18日 (Gregorian: Friday, August 18, 1989)




Imports System.Globalization

Module Program
    Dim jaJp As CultureInfo
    Dim japaneseCal As Calendar

    Sub Main()
        Dim enUs = New CultureInfo("en-US")
        japaneseCal = New JapaneseCalendar()
        jaJp = New CultureInfo("ja-JP")
        jaJp.DateTimeFormat.Calendar = japaneseCal
        Dim heiseiEra = "平成"

        Dim dat = japaneseCal.ToDateTime(1, 8, 18, 0, 0, 0, 0, GetEraIndex(heiseiEra))
        Dim fmt As FormattableString = $"{dat:D}"
        Console.WriteLine($"Japanese calendar date: {fmt.ToString(jaJp)} (Gregorian: {fmt.ToString(enUs)})")
    End Sub

    Private Function GetEraIndex(eraName As String) As Integer
        For Each ctr In japaneseCal.Eras
            If jaJp.DateTimeFormat.GetEraName(ctr) = eraName Then
                Return ctr
            End If
        Next
        Return 0 
    End Function
End Module
' The example displays the following output:
'    Japanese calendar date: 平成元年8月18日 (Gregorian: Friday, August 18, 1989)

この動作が書式設定操作で望ましくない場合は、.NET のバージョンに応じて、次の手順を実行して、「元年」ではなく「1」として時代 (年号) の最初の年を表す常に、以前の動作を復元できます。If this behavior is undesirable in formatting operations, you can restore the previous behavior, which always represents the first year of an era as “1” rather than “Gannen”, by doing the following, depending on the version of .NET:

  • .NET core: 次を追加することができます、 . netcore.runtime.json構成ファイル。.NET Core: You can add the following to the .netcore.runtime.json config file:

    "runtimeOptions": {
        "configProperties": {
           "Switch.System.Globalization.FormatJapaneseFirstYearAsANumber": true
        } 
    }
    
  • .NET framework 4.6 以降: 次の AppContext スイッチを設定することができます。.NET Framework 4.6 or later: You can set the following AppContext switch:

    <?xml version="1.0" encoding="utf-8"?>
    <configuration>
       <runtime>
         <AppContextSwitchOverrides value="Switch.System.Globalization.FormatJapaneseFirstYearAsANumber=true" />
       </runtime>
    </configuration>
    
  • .NET framework 4.5.2 以前のバージョン。 次のレジストリ値を設定することができます。.NET Framework 4.5.2 or earlier: You can set the following registry value:

    キーKey HKEY_LOCAL_MACHINE\Software\Microsoft.NETFramework\AppContextHKEY_LOCAL_MACHINE\Software\Microsoft.NETFramework\AppContext
    名前Name Switch.System.Globalization.FormatJapaneseFirstYearAsANumberSwitch.System.Globalization.FormatJapaneseFirstYearAsANumber
    Type REG_SZREG_SZ
    [値]Value 11

書式設定操作が無効になっているで元年サポートにより、前の例には、次の出力が表示されます。With gannen support in formatting operations disabled, the previous example displays the following output:

Japanese calendar date: 平成1年8月18日 (Gregorian: Friday, August 18, 1989)

.NET は、日付と時刻の解析操作は、「1」または元年として表される年間積算を含む文字列をサポートするためにも更新されています。.NET has also been updated so that date and time parsing operations support strings that contain the year represented as either "1" or Gannen. これを行うには必要ありません、ただし、時代 (年号) の最初の年として「1」のみを認識する以前の動作を復元できます。Although you should not need to do this, you can restore the previous behavior to recognizes only “1” as the first year of an era. この操作は、.NET のバージョンに応じて次のようはことができます。You can do this as follows, depending on the version of .NET:

  • .NET core: 次を追加することができます、 . netcore.runtime.json構成ファイル。.NET Core: You can add the following to the .netcore.runtime.json config file:

    "runtimeOptions": {
        "configProperties": {
           "Switch.System.Globalization.EnforceLegacyJapaneseDateParsing": true
        } 
    }
    
  • .NET framework 4.6 以降: 次の AppContext スイッチを設定することができます。.NET Framework 4.6 or later: You can set the following AppContext switch:

    <?xml version="1.0" encoding="utf-8"?>
    <configuration>
       <runtime>
         <AppContextSwitchOverrides value="Switch.System.Globalization.EnforceLegacyJapaneseDateParsing=true" />
       </runtime>
    </configuration>
    
  • .NET framework 4.5.2 以前のバージョン。 次のレジストリ値を設定することができます。.NET Framework 4.5.2 or earlier: You can set the following registry value:

    キーKey HKEY_LOCAL_MACHINE\Software\Microsoft.NETFramework\AppContextHKEY_LOCAL_MACHINE\Software\Microsoft.NETFramework\AppContext
    名前Name Switch.System.Globalization.EnforceLegacyJapaneseDateParsingSwitch.System.Globalization.EnforceLegacyJapaneseDateParsing
    Type REG_SZREG_SZ
    [値]Value 11

関連項目See also