Arbeiten mit KalendernWorking with calendars

Obwohl ein Datums- und Uhrzeitwert eine universale zeitliche Angabe darstellt, ist die Zeichenfolgendarstellung eines solchen Werts kulturabhängig. Sie wird sowohl durch die Anzeigekonventionen für Datums- und Uhrzeitwerte einer bestimmten Kultur als auch durch den Kalender bestimmt, der in der jeweiligen Kultur verwendet wird.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. In diesem Thema wird die Unterstützung für Kalender in .net erläutert und die Verwendung der Kalender Klassen bei der Arbeit mit Datums Werten erläutert.This topic explores the support for calendars in .NET and discusses the use of the calendar classes when working with date values.

Kalender in .netCalendars in .NET

Alle Kalender in .net sind von der System.Globalization.Calendar-Klasse abgeleitet, die die Basis Kalender Implementierung bereitstellt.All calendars in .NET derive from the System.Globalization.Calendar class, which provides the base calendar implementation. Eine der Klassen, die von der Calendar-Klasse erbt, ist die EastAsianLunisolarCalendar-Klasse. Dies ist die Basisklasse für alle Mond-Sonne-Kalender.One of the classes that inherits from the Calendar class is the EastAsianLunisolarCalendar class, which is the base class for all lunisolar calendars. .NET umfasst die folgenden Kalender Implementierungen:.NET includes the following calendar implementations:

Ein Kalender kann auf zwei Arten verwendet werden:A calendar can be used in one of two ways:

  • Als Kalender, der von einer bestimmten Kultur verwendet wird.As the calendar used by a specific culture. Jedes CultureInfo-Objekt verfügt über einen aktuellen Kalender. Dies ist der Kalender, den das Objekt gegenwärtig verwendet.Each CultureInfo object has a current calendar, which is the calendar that the object is currently using. Die Zeichenfolgendarstellungen aller Datums- und Uhrzeitwerte entsprechen automatisch der aktuellen Kultur und dem aktuellen Kalender.The string representations of all date and time values automatically reflect the current culture and its current calendar. In der Regel ist als aktueller Kalender der Standardkalender der Kultur angegeben.Typically, the current calendar is the culture's default calendar. CultureInfo Objekte verfügen auch über optionale Kalender, die zusätzliche Kalender enthalten, die von der Kultur verwendet werden können.CultureInfo objects also have optional calendars, which include additional calendars that the culture can use.

  • Als eigenständiger Kalender, unabhängig von einer bestimmten Kultur.As a standalone calendar independent of a specific culture. In diesem Fall werden Calendar-Methoden verwendet, um Datumsangaben in Werten auszudrücken, die dem betreffenden Kalender entsprechen.In this case, Calendar methods are used to express dates as values that reflect the calendar.

Beachten Sie, dass die folgenden sechs Kalenderklassen nur als eigenständige Kalender verwendet werden können: ChineseLunisolarCalendar, JapaneseLunisolarCalendar, JulianCalendar, KoreanLunisolarCalendar, PersianCalendar und TaiwanLunisolarCalendar.Note that six calendar classes – ChineseLunisolarCalendar, JapaneseLunisolarCalendar, JulianCalendar, KoreanLunisolarCalendar, PersianCalendar, and TaiwanLunisolarCalendar – can be used only as standalone calendars. Sie werden von keiner Kultur verwendet, weder als Standardkalender noch als optionaler Kalender.They are not used by any culture as either the default calendar or as an optional calendar.

Kalender und KulturenCalendars and cultures

Jede Kultur verfügt über einen Standardkalender, der von der CultureInfo.Calendar-Eigenschaft definiert wird.Each culture has a default calendar, which is defined by the CultureInfo.Calendar property. Die CultureInfo.OptionalCalendars-Eigenschaft gibt ein Array von Calendar-Objekten zurück, das alle von einer bestimmten Kultur unterstützten Kalender angibt, einschließlich des Standardkalenders der Kultur.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.

Im folgenden Beispiel werden die CultureInfo.Calendar-Eigenschaft und die CultureInfo.OptionalCalendars-Eigenschaft veranschaulicht.The following example illustrates the CultureInfo.Calendar and CultureInfo.OptionalCalendars properties. Im Beispiel werden CultureInfo-Objekte für die Kulturen Thai (Thailand) und Japanisch (Japan) erstellt und die Standardkalender sowie die optionalen Kalender für diese Kulturen angezeigt.It creates CultureInfo objects for the Thai (Thailand) and Japanese (Japan) cultures and displays their default and optional calendars. Beachten Sie, dass in beiden Fällen auch der Standardkalender in der CultureInfo.OptionalCalendars-Auflistung enthalten ist.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)

Der derzeit von einem bestimmten CultureInfo-Objekt verwendete Kalender wird von der DateTimeFormatInfo.Calendar-Eigenschaft der Kultur definiert.The calendar currently in use by a particular CultureInfo object is defined by the culture's DateTimeFormatInfo.Calendar property. Das DateTimeFormatInfo-Objekt einer Kultur wird mit der CultureInfo.DateTimeFormat-Eigenschaft zurückgegeben.A culture's DateTimeFormatInfo object is returned by the CultureInfo.DateTimeFormat property. Beim Erstellen einer Kultur wird ihr Standardwert auf den Wert der CultureInfo.Calendar-Eigenschaft festgelegt.When a culture is created, its default value is the same as the value of the CultureInfo.Calendar property. Sie können den Standardwert jedoch ändern und als aktuellen Kalender für eine Kultur jeden Kalender angeben, der in dem von der CultureInfo.OptionalCalendars-Eigenschaft zurückgegebenen Array enthalten ist.However, you can change the culture's current calendar to any calendar contained in the array returned by the CultureInfo.OptionalCalendars property. Wenn Sie versuchen, den aktuellen Kalender auf einen Kalender festzulegen, der nicht in der CultureInfo.OptionalCalendars-Eigenschaft enthalten ist, wird ArgumentException ausgelöst.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.

Im folgenden Beispiel wird der Kalender geändert, der von der Kultur Arabisch (Saudi-Arabien) verwendet wird.The following example changes the calendar used by the Arabic (Saudi Arabia) culture. Zuerst wird ein DateTime-Wert instanziiert und unter Verwendung der aktuellen Kultur (in diesem Fall Englisch (USA)) sowie des aktuellen Kalenders der Kultur (gregorianischer Kalender) angezeigt.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). Anschließend wird die aktuelle Kultur in Arabisch (Saudi-Arabien) geändert und das Datum mit dem Standardkalender dieser Kultur, dem Umm al-Qura-Kalender angezeigt.Next, it changes the current culture to Arabic (Saudi Arabia) and displays the date using its default Um Al-Qura calendar. Anschließend wird die CalendarExists-Methode aufgerufen, um zu bestimmen, ob der Hijri-Kalender von der Kultur Arabisch (Saudi-Arabien) unterstützt wird.It then calls the CalendarExists method to determine whether the Hijri calendar is supported by the Arabic (Saudi Arabia) culture. Da der Kalender unterstützt wird, wird Hijri als aktueller Kalender festgelegt und das Datum erneut angezeigt.Because the calendar is supported, it changes the current calendar to Hijri and again displays the date. Beachten Sie, dass das Datum in allen Fällen mit dem aktuellen Kalender der aktuellen Kultur angezeigt wird.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

Datumsangaben und KalenderDates and calendars

Mit Ausnahme der Konstruktoren, die einen Parameter des Typs Calendar beinhalten und die es gestatten, die Elemente eines Datums (d. h. Monat, Tag und Jahr) in den Werten eines bestimmten Kalenders anzuzeigen, basieren die Werte DateTime und DateTimeOffset immer auf dem gregorianischen Kalender.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. Dies bedeutet, dass die DateTime.Year-Eigenschaft immer das Jahr und die DateTime.Day-Eigenschaft immer den Monat im gregorianischen Kalender zurückgibt.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.

Wichtig

Es ist wichtig zu beachten, dass zwischen dem Datumswert und der entsprechenden Zeichenfolgendarstellung ein Unterschied besteht.It is important to remember that there is a difference between a date value and its string representation. Der erste Wert basiert auf dem gregorianischen Kalender, während der zweite Wert auf dem aktuellen Kalender einer bestimmten Kultur basiert.The former is based on the Gregorian calendar; the latter is based on the current calendar of a specific culture.

Das folgende Beispiel veranschaulicht diesen Unterschied zwischen den DateTime-Eigenschaften und den entsprechenden Calendar-Methoden.The following example illustrates this difference between DateTime properties and their corresponding Calendar methods. Im Beispiel ist die aktuelle Kultur Arabisch (Ägypten), und der aktuelle Kalender ist Umm al-Qura.In the example, the current culture is Arabic (Egypt), and the current calendar is Um Al Qura. Ein DateTime-Wert wird auf den 15. Tag im 7. Monat des Jahres 2011 festgelegt.A DateTime value is set to the fifteenth day of the seventh month of 2011. Es ist klar, dass diese Werte als gregorianisches Datum interpretiert werden, da die DateTime.ToString(String, IFormatProvider)-Methode die gleichen Werte zurückgibt, wenn die Konventionen der invarianten Kultur verwendet werden.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. Die Zeichenfolgendarstellung des Datums, die gemäß den Konventionen der aktuellen Kultur formatiert wird, ist 14/08/32. Dies ist das entsprechende Datum im Umm al-Qura-Kalender.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. Anschließend werden Member von DateTime und Calendar verwendet, um den Tag, den Monat und das Jahr des DateTime-Werts zurückzugeben.Next, members of DateTime and Calendar are used to return the day, the month, and the year of the DateTime value. In allen Fällen entsprechen die von DateTime-Membern zurückgegebenen Werte den Werten im gregorianischen Kalender, während die von UmAlQuraCalendar-Membern zurückgegebenen Werte dem Umm al-Qura-Kalender entsprechen.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

Instanziieren von Datumsangaben auf der Grundlage eines KalendersInstantiating dates based on a calendar

Da DateTime-Werte und DateTimeOffset-Werte auf dem gregorianischen Kalender basieren, müssen Sie einen überladenen Konstruktor aufrufen, der einen Parameter vom Typ Calendar beinhaltet, wenn Sie einen Datumswert instanziieren möchten, der Tag, Monat und Jahr eines anderen Kalenders verwenden soll.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. Sie können auch eine der Überladungen der Calendar.ToDateTime-Methode eines bestimmten Kalenders aufrufen, um ein DateTime-Objekt auf Grundlage der Werte eines bestimmten Kalender zu instanziieren.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.

Im folgenden Codebeispiel wird ein DateTime-Wert instanziiert, indem ein HebrewCalendar-Objekt an einen DateTime Konstruktor übergeben wird. Anschließend wird ein zweiter DateTime-Wert durch Aufrufen der HebrewCalendar.ToDateTime(Int32, Int32, Int32, Int32, Int32, Int32, Int32, Int32)-Methode instanziiert.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. Da die beiden Werte mit identischen Werten aus dem hebräischen Kalender erstellt wurden, zeigt ein Aufruf der DateTime.Equals-Methode, dass beide DateTime-Werte gleich sind.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

Darstellen von Datumsangaben im aktuellen KalenderRepresenting dates in the current calendar

Formatierungsmethoden für Datum und Uhrzeit verwenden immer den aktuellen Kalender, wenn Datumsangaben in Zeichenfolgen konvertiert werden sollen.Date and time formatting methods always use the current calendar when converting dates to strings. Das heißt, dass die Zeichenfolgendarstellungen für Jahr, Monat und Tag des Monats denen des aktuellen Kalenders entsprechen und nicht notwendigerweise dem gregorianischen Kalender folgen.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.

Im folgenden Beispiel wird gezeigt, welchen Einfluss der aktuelle Kalender auf die Zeichenfolgendarstellung eines Datums hat.The following example shows how the current calendar affects the string representation of a date. Im Beispiel wird die aktuelle Kultur auf Chinesisch (traditionell, Taiwan) festgelegt und ein Datumswert instanziiert.It changes the current culture to Chinese (Traditional, Taiwan), and instantiates a date value. Anschließend werden der aktuelle Kalender und das Datum angezeigt, der aktuelle Kalender wird in TaiwanCalendar geändert, und Kalender und Datum werden erneut angezeigt.It then displays the current calendar and the date, changes the current calendar to TaiwanCalendar, and displays the current calendar and date once again. Der erste angezeigte Datumswert verwendet die Darstellung des gregorianischen Kalenders.The first time the date is displayed, it is represented as a date in the Gregorian calendar. Der zweite Datumswert wird im Format des taiwanesischen Kalenders dargestellt.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

Darstellen von Datumsangaben in einem nicht aktuellen KalenderRepresenting dates in a non-current calendar

Um ein Datum unter Verwendung eines anderen als des aktuellen Kalenders einer bestimmten Kultur darzustellen, müssen Sie Methoden des gewünschten Calendar-Objekts aufrufen.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. Zum Beispiel konvertieren die Methoden Calendar.GetYear, Calendar.GetMonth und Calendar.GetDayOfMonth das Jahr, den Monat und den Tag in die Darstellung eines bestimmten Kalenders.For example, the Calendar.GetYear, Calendar.GetMonth, and Calendar.GetDayOfMonth methods convert the year, month, and day to values that reflect a particular calendar.

Warnung

Da einige Kalender nicht als optionale Kalender für eine Kultur definiert sind, erfordert die Darstellung von Datumsangaben mit diesen Kalendern stets einen Aufruf der Methoden des entsprechenden Kalenders.Because some calendars are not optional calendars of any culture, representing dates in these calendars always requires that you call calendar methods. Dies gilt für alle Kalender, die von den Klassen EastAsianLunisolarCalendar, JulianCalendar und PersianCalendar abgeleitet sind.This is true of all calendars that derive from the EastAsianLunisolarCalendar, JulianCalendar, and PersianCalendar classes.

Im folgenden Beispiel wird ein JulianCalendar-Objekt verwendet, um ein Datum (9. Januar 1905) im julianischen Kalender zu instanziieren.The following example uses a JulianCalendar object to instantiate a date, January 9, 1905, in the Julian calendar. Wenn dieses Datum mit dem gregorianischen Standardkalender dargestellt wird, wird es als 22. Januar 1905 angezeigt.When this date is displayed using the default (Gregorian) calendar, it is represented as January 22, 1905. Aufrufe einzelner JulianCalendar-Methoden ermöglichen eine Darstellung des Datums mit dem julianischen Kalender.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

Kalender und DatumsbereicheCalendars and date ranges

Das früheste Datum, das von einem Kalender unterstützt wird, wird durch die Calendar.MinSupportedDateTime-Eigenschaft dieses Kalenders angegeben.The earliest date supported by a calendar is indicated by that calendar's Calendar.MinSupportedDateTime property. Für die GregorianCalendar-Klasse ist dieses Datum der 1. Januar 0001 unserer Zeitrechnung.For the GregorianCalendar class, that date is January 1, 0001 C.E. Die meisten anderen Kalender in .NET unterstützen ein späteres Datum.Most of the other calendars in .NET support a later date. Der Versuch, mit einem Datums- und Zeitwert zu arbeiten, der vor dem frühesten unterstützten Datum eines Kalenders liegt, löst eine ArgumentOutOfRangeException Ausnahme aus.Trying to work with a date and time value that precedes a calendar's earliest supported date throws an ArgumentOutOfRangeException exception.

Es gibt jedoch eine wichtige Ausnahme.However, there is one important exception. Der (nicht initialisierte) Standardwert eines DateTime-Objekts und eines DateTimeOffset-Objekts ist gleich dem GregorianCalendar.MinSupportedDateTime-Wert.The default (uninitialized) value of a DateTime object and a DateTimeOffset object is equal to the GregorianCalendar.MinSupportedDateTime value. Wenn Sie versuchen, dieses Datum in einem Kalender zu formatieren, der den 1. Januar 0001 nicht unterstützt,If you try to format this date in a calendar that does not support January 1, 0001 C.E. und Sie geben keinen Format Bezeichner an, die Formatierungs Methode verwendet den Format Bezeichner "s" (Sortier barer Datums-/Uhrzeitmuster) anstelle des Format Bezeichnern "G" (allgemeiner Datums-/Uhrzeitmuster).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. In der Folge löst der Formatierungsvorgang keine ArgumentOutOfRangeException-Ausnahme aus.As a result, the formatting operation does not throw an ArgumentOutOfRangeException exception. Stattdessen wird das nicht unterstützte Datum zurückgegeben.Instead, it returns the unsupported date. Dies wird im folgenden Beispiel veranschaulicht. Der Wert von DateTime.MinValue wird anzeigt, wenn die aktuelle Kultur auf Japanisch (Japan) mit dem japanischen Kalender und in Arabisch (Ägypten) mit dem Um Al Qura-Kalender festgelegt wird.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. Außerdem wird die aktuelle Kultur auf Englisch (USA) festgelegt die DateTime.ToString(IFormatProvider)-Methode mit jedem dieser CultureInfo-Objekte aufgerufen.It also sets the current culture to English (United States) and calls the DateTime.ToString(IFormatProvider) method with each of these CultureInfo objects. In jedem Fall wird das Datum mithilfe des sortierbaren Datums-/Zeitmusters angezeigt.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

Arbeiten mit EpochenWorking with eras

Kalender unterteilen Datumsangaben in der Regel in Zeiträume.Calendars typically divide dates into eras. Allerdings unterstützen die Calendar Klassen in .net nicht jeden von einem Kalender definierten Zeitraum, und die meisten Calendar Klassen unterstützen nur einen einzelnen Zeitraum.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. Nur die Klassen JapaneseCalendar und JapaneseLunisolarCalendar unterstützen mehrere Zeiträume.Only the JapaneseCalendar and JapaneseLunisolarCalendar classes support multiple eras.

Wichtig

Die reiwa-Ära, ein neuer Zeitraum in der JapaneseCalendar und JapaneseLunisolarCalendar, beginnt am 1. Mai 2019.The Reiwa era, a new era in the JapaneseCalendar and JapaneseLunisolarCalendar, begins on May 1, 2019. Diese Änderung betrifft alle Anwendungen, die diese Kalender verwenden.This change affects all applications that use these calendars. Weitere Informationen finden Sie in den folgenden Artikeln:See the following articles for more information:

Ein Zeitraum in den meisten Kalendern deutet auf einen extrem langen Zeitraum hin.An era in most calendars denotes an extremely long time period. Im gregorianischen Kalender umfasst z. b. die aktuelle Ära mehr als zweitausend tausend.In the Gregorian calendar, for example, the current era spans more than two millennia. Für die JapaneseCalendar und die JapaneseLunisolarCalendarwerden die beiden Kalender unterstützt, die mehrere Zeiträume unterstützen. Dies ist nicht der Fall.For the JapaneseCalendar and the JapaneseLunisolarCalendar, the two calendars that support multiple eras, this is not the case. Ein Zeitraum entspricht dem Zeitraum der Regierung eines Kaisers.An era corresponds to the period of an emperor's reign. Unterstützung für mehrere Zeiträume, insbesondere wenn die Obergrenze des aktuellen Zeitraums unbekannt ist, stellt besondere Herausforderungen dar.Support for multiple eras, particularly when the upper limit of the current era is unknown, poses special challenges.

Zeit-und Zeit NamenEras and era names

In .net werden ganze Zahlen, die die von einer bestimmten Kalender Implementierung unterstützten Zeiträume darstellen, in umgekehrter Reihenfolge im Calendar.Eras Array gespeichert.In .NET, integers that represent the eras supported by a particular calendar implementation are stored in reverse order in the Calendar.Eras array. Der aktuelle Zeitraum (bei dem es sich um den Zeitraum mit dem letzten Zeitbereich handelt) liegt bei Index 0 (null), und bei Calendar Klassen, die mehrere Zeiträume unterstützen, reflektiert jeder aufeinander folgende Index den vorherigen Zeitraum.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. Die statische Calendar.CurrentEra-Eigenschaft definiert den Index des aktuellen Zeitraums im Calendar.Eras-Array. Dies ist eine Konstante, die stets den Wert 0 (null) hat.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. Einzelne Calendar-Klassen beinhalten darüber hinaus auch statische Felder, die den Wert des aktuellen Zeitraums zurückgeben.Individual Calendar classes also include static fields that return the value of the current era. Sie sind in der folgenden Tabelle aufgeführt.They are listed in the following table.

KalenderklasseCalendar class Feld für den aktuellen ZeitraumCurrent era field
ChineseLunisolarCalendar ChineseEra
GregorianCalendar ADEra
HebrewCalendar HebrewEra
HijriCalendar HijriEra
JapaneseLunisolarCalendar JapaneseEra
JulianCalendar JulianEra
KoreanCalendar KoreanEra
KoreanLunisolarCalendar GregorianEra
PersianCalendar PersianEra
ThaiBuddhistCalendar ThaiBuddhistEra
UmAlQuraCalendar UmAlQuraEra

Der Name, der dem Zeitraum mit einer bestimmten Nummer entspricht, kann durch Übergeben der Nummer an die DateTimeFormatInfo.GetEraName-Methode oder an die DateTimeFormatInfo.GetAbbreviatedEraName-Methode abgerufen werden.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. Im folgenden Beispiel werden diese Methoden aufgerufen, um Informationen über die Unterstützung von Zeiträumen in der GregorianCalendar-Klasse abzurufen.The following example calls these methods to retrieve information about era support in the GregorianCalendar class. Es zeigt das Gregorianische Kalenderdatum an, das dem 1. Januar des zweiten Jahres des aktuellen Zeitraums entspricht, sowie das Gregorianische Kalenderdatum, das dem 1. Januar des zweiten Jahres jedes unterstützten japanischen Kalender Zeitraums entspricht.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

Darüber hinaus enthält die benutzerdefinierte Formatzeichenfolge "g" für Datum und Uhrzeit den Namen des Zeitraums eines Kalenders in der Zeichenfolgendarstellung eines Datums- und Uhrzeitwerts.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. Weitere Informationen finden Sie unter benutzerdefinierte FormatZeichenfolgen für Datum und Uhrzeit.For more information, see Custom date and time format strings.

Instanziieren eines Datums mit einem ZeitraumInstantiating a date with an era

Für die beiden Calendar Klassen, die mehrere Zeiträume unterstützen, kann ein Datum, das aus einem bestimmten Jahr, Monat und Tag des Monats Werts besteht, mehrdeutig sein.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. Beispielsweise haben alle Zeiträume, die von der JapaneseCalendar unterstützt werden, Jahre, deren Zahl 1 ist.For example, all eras supported by the JapaneseCalendar have years whose number is 1. Wenn kein Zeitraum angegeben ist, wird daher bei Datums-, Uhrzeit- und Klassenmethoden immer davon ausgegangen, dass die Werte zum aktuellen Zeitraum gehören.Ordinarily, if an era is not specified, both date and time and calendar methods assume that values belong to the current era. Dies gilt für die DateTime-und DateTimeOffset-Konstruktoren, die Parameter vom Typ Calendarenthalten, sowie die Methoden JapaneseCalendar. ToDateTime und JapaneseLunisolarCalendar. 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. Im folgenden Beispiel wird ein Datum instanziiert, das den 1. Januar des zweiten Jahres eines nicht angegebenen Zeitraums darstellt.The following example instantiates a date that represents January 1 of the second year of an unspecified era. Wenn Sie das Beispiel ausführen, wenn der reiwa-Zeitraum der aktuelle Zeitraum ist, wird das Datum als zweites Jahr des reiwa-Zeitraums interpretiert.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. Der ERA, 令和, steht vor dem Jahr in der Zeichenfolge, die von der DateTime.ToString(String, IFormatProvider)-Methode zurückgegeben wird, und entspricht dem 1. Januar 2020 im gregorianischen Kalender.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. (Die reiwa-Ära beginnt im Jahr 2019 des gregorianischen Kalenders.)(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

Wenn sich der ERA jedoch ändert, wird der Zweck dieses Codes mehrdeutig.However, if the era changes, the intent of this code becomes ambiguous. Ist das Datum, das das zweite Jahr des aktuellen Zeitraums darstellen soll, oder soll das zweite Jahr des Heisei-Zeitraums repräsentiert werden?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? Es gibt zwei Möglichkeiten, diese Mehrdeutigkeit zu vermeiden:There are two ways to avoid this ambiguity:

  • Instanziieren Sie den Datums-und Uhrzeitwert mit der standardmäßigen GregorianCalendar-Klasse.Instantiate the date and time value using the default GregorianCalendar class. Anschließend können Sie den japanischen Kalender oder den japanischen lunisolar-Kalender für die Zeichen folgen Darstellung von Datumsangaben verwenden, wie im folgenden Beispiel gezeigt.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
    
    
    
  • Ruft eine Datums-und Uhrzeit Methode auf, die explizit einen Zeitraum angibt.Call a date and time method that explicitly specifies an era. Dies schließt die folgenden Methoden ein:This includes the following methods:

    Im folgenden Beispiel werden drei dieser Methoden verwendet, um ein Datum und eine Uhrzeit in der Meiji-Ära zu instanziieren, die am 8. September 1868 begonnen und am 29. Juli 1912 endete.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
    

Tipp

Wenn Sie Kalender arbeiten, die mehrere Zeiträume unterstützen, verwenden Sie immer das gregorianische Datum, um ein Datum zu instanziieren, oder geben Sie den Zeitraum an, wenn Sie ein Datum und eine Uhrzeit basierend auf diesem Kalender instanziieren.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.

Wenn Sie einen Zeitraum für die ToDateTime(Int32, Int32, Int32, Int32, Int32, Int32, Int32, Int32)-Methode angeben, geben Sie den Index des Zeitraums in der Eras-Eigenschaft des Kalenders an.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. Bei Kalendern, deren Zeiträume geändert werden können, handelt es sich bei diesen Indizes jedoch nicht um konstante Werte. der aktuelle Zeitraum liegt bei Index 0, und der älteste Zeitraum liegt bei Index 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. Wenn einem Kalender ein neuer Zeitraum hinzugefügt wird, werden die Indizes der vorherigen Zeiträume um 1 erhöht.When a new era is added to a calendar, the indexes of the previous eras increase by one. Sie können den entsprechenden ERA-Index wie folgt angeben:You can supply the appropriate era index as follows:

  • Verwenden Sie für Datumsangaben im aktuellen Zeitraum stets die CurrentEra-Eigenschaft des Kalenders.For dates in the current era, always use the calendar's CurrentEra property.

  • Verwenden Sie für Datumsangaben in einem bestimmten Zeitraum die DateTimeFormatInfo.GetEraName-Methode, um den Index abzurufen, der einem bestimmten Zeit Namen entspricht.For dates in a specified era, use the DateTimeFormatInfo.GetEraName method to retrieve the index that corresponds to a specified era name. Dies erfordert, dass die JapaneseCalendar der aktuelle Kalender des CultureInfo Objekts ist, das die Kultur "ja-JP" darstellt.This requires that the JapaneseCalendar be the current calendar of the CultureInfo object that represents the ja-JP culture. (Dieses Verfahren funktioniert auch für das JapaneseLunisolarCalendar, da es die gleichen Zeiträume wie die JapaneseCalendarunterstützt.) Diese Vorgehensweise wird im vorherigen Beispiel veranschaulicht.(This technique works for the JapaneseLunisolarCalendar as well, since it supports the same eras as the JapaneseCalendar.) The previous example illustrates this approach.

Kalender, Zeiträume und Datumsbereiche: gelockerte Bereichs ÜberprüfungenCalendars, eras, and date ranges: Relaxed range checks

Ganz ähnlich wie einzelne Kalender unterstützte Datumsbereiche haben, haben Zeiträume in den JapaneseCalendar-und JapaneseLunisolarCalendar Klassen auch unterstützte Bereiche.Very much like individual calendars have supported date ranges, eras in the JapaneseCalendar and JapaneseLunisolarCalendar classes also have supported ranges. Zuvor hat .net strikte Zeit Bereichs Überprüfungen verwendet, um sicherzustellen, dass ein Zeit spezifisches Datum innerhalb des Gültigkeits Bereichs liegt.Previously, .NET used strict era range checks to ensure that an era-specific date was within the range of that era. Das heißt, wenn ein Datum außerhalb des angegebenen Zeitraums liegt, löst die Methode eine ArgumentOutOfRangeExceptionaus.That is, if a date is outside of the range of the specified era, the method throws an ArgumentOutOfRangeException. Derzeit verwendet .net eine gelockerte Bereichs Überprüfung standardmäßig.Currently, .NET uses relaxed ranged checking by default. Bei Updates für alle Versionen von .net wurden gelockerte Bereichs Überprüfungen durchgeführt. der Versuch, ein Zeit spezifisches Datum zu instanziieren, das außerhalb des Bereichs des angegebenen Zeitraums liegt, wird in den folgenden Zeitraum umgewandelt, und es wird keine Ausnahme ausgelöst.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.

Im folgenden Beispiel wird versucht, ein Datum im 65. Jahr des Showa-Zeitraums zu instanziieren, das am 25. Dezember 1926 begonnen und am 7. Januar 1989 endet.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. Dieses Datum entspricht dem 9. Januar 1990, das außerhalb des Bereichs des Showa-Zeitraums in der JapaneseCalendarliegt.This date corresponds to January 9, 1990, which is outside the range of the Showa era in the JapaneseCalendar. Wie die Ausgabe aus dem Beispiel zeigt, ist das im Beispiel angezeigte Datum der 9. Januar 1990 im zweiten Jahr des Heisei-Zeitraums.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

Wenn eine gelockerte Bereichs Überprüfung nicht erwünscht ist, können Sie strikte Bereichs Überprüfungen auf verschiedene Weise wiederherstellen, abhängig von der .NET-Version, auf der die Anwendung ausgeführt wird: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: Sie können der Konfigurationsdatei . Netcore. Runtime. JSON Folgendes hinzufügen:.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 oder höher: Sie können den folgenden appContext-Schalter festlegen:.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 oder früher: Sie können den folgenden Registrierungs Wert festlegen:.NET Framework 4.5.2 or earlier: You can set the following registry value:

    KeyKey HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft.netframework\appcontextHKEY_LOCAL_MACHINE\Software\Microsoft.NETFramework\AppContext
    -NameName Switch. System. Globalization. enforcejapaneseerayearrangesSwitch.System.Globalization.EnforceJapaneseEraYearRanges
    Geben Sie Folgendes ein:Type REG_SZREG_SZ
    WertValue truetrue

Bei aktivierten strengen Bereichs Prüfungen löst das vorherige Beispiel eine ArgumentOutOfRangeException aus und zeigt die folgende Ausgabe an: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()

Darstellen von Datumsangaben in Kalendern mit mehreren EpochenRepresenting dates in calendars with multiple eras

Wenn ein Calendar-Objekt Zeiträume unterstützt und es sich um den aktuellen Kalender eines CultureInfo-Objekts handelt, beinhalten die Zeichenfolgendarstellungen für die Muster vollständiges Datum und Uhrzeit, langes Datum und kurzes Datum auch den Zeitraum des Datums- und Uhrzeitwerts.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. Das folgende Beispiel zeigt diese Datumsmuster, wenn die aktuelle Kultur auf Japan (japanisch) festgelegt und als aktueller Kalender der japanische Kalender angegeben ist.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 

Warnung

Die JapaneseCalendar-Klasse ist die einzige Calendar-Klasse in .net, die beide Datumsangaben in mehr als einem Zeitraum unterstützt. Dies kann der aktuelle Kalender eines CultureInfo Objekts sein, insbesondere eines CultureInfo Objekts, das die Kultur Japanisch (Japan) darstellt.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.

Bei allen Kalendern enthält der benutzerdefinierte Formatbezeichner "g" auch den Zeitraum in der Ergebniszeichenfolge.For all calendars, the "g" custom format specifier includes the era in the result string. Das folgende Beispiel verwendet die benutzerdefinierte Formatzeichenfolge "MM-DD-yyyy g", um den Zeitraum in der Ergebniszeichenfolge anzuzeigen, wenn als aktueller Kalender der gregorianische Kalender festgelegt ist.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.      

In Fällen, in denen die Zeichenfolgendarstellung eines Datums in einem Kalender ausgedrückt wird, der nicht der aktuelle Kalender ist, beinhaltet die Calendar-Klasse eine Calendar.GetEra-Methode, die zusammen mit den Methoden Calendar.GetYear, Calendar.GetMonth und Calendar.GetDayOfMonth verwendet werden kann, um ein Datum eindeutig zusammen mit dem Zeitraum anzugeben, zu dem es gehört.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. Im folgenden Beispiel wird dies anhand der JapaneseLunisolarCalendar-Klasse veranschaulicht.The following example uses the JapaneseLunisolarCalendar class to provide an illustration. Beachten Sie jedoch, dass Sie ein DateTimeFormatInfo-Objekt instanziieren und JapaneseCalendar als dessen aktuellen Kalender festlegen müssen, wenn Sie in der Ergebniszeichenfolge anstelle einer Zahl einen aussagekräftigen Namen oder eine Abkürzung für den Zeitraum anzeigen möchten.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. (Der JapaneseLunisolarCalendar-Kalender kann nicht als aktueller Kalender einer Kultur festgelegt werden, in diesem Fall teilen sich aber zwei Kalender dieselben Zeiträume.(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 den japanischen Kalendern heißt das erste Jahr eines Zeitraums "Gannen" (元年).In the Japanese calendars, the first year of an era is called Gannen (元年). Beispielsweise kann anstelle von Heisei 1 das erste Jahr der Heisei-Ära als Heisei-Gannen beschrieben werden.For example, instead of Heisei 1, the first year of the Heisei era can be described as Heisei Gannen. .Net übernimmt diese Konvention bei Formatierungs Vorgängen für Datumsangaben und Uhrzeiten, die mit den folgenden standardmäßigen oder benutzerdefinierten Format Zeichenfolgen für Datum und Uhrzeit formatiert sind, wenn Sie mit einem CultureInfo Objekt verwendet werden, das die Kultur Japanisch-Japan ("ja-JP") mit der JapaneseCalendar klassi.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:

Im folgenden Beispiel wird z. b. ein Datum im ersten Jahr der Heisei-Zeit im JapaneseCalendar angezeigt.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)

Wenn dieses Verhalten bei Formatierungs Vorgängen nicht erwünscht ist, können Sie das vorherige Verhalten wiederherstellen, das das erste Jahr eines Zeitraums immer als "1" anstelle von "Gannen" darstellt, und zwar je nach Version von .net: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: Sie können der Konfigurationsdatei . Netcore. Runtime. JSON Folgendes hinzufügen:.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 oder höher: Sie können den folgenden appContext-Schalter festlegen:.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 oder früher: Sie können den folgenden Registrierungs Wert festlegen:.NET Framework 4.5.2 or earlier: You can set the following registry value:

    KeyKey HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft.netframework\appcontextHKEY_LOCAL_MACHINE\Software\Microsoft.NETFramework\AppContext
    -NameName Switch. System. Globalization. formatjapanesefirstyearasanumberSwitch.System.Globalization.FormatJapaneseFirstYearAsANumber
    Geben Sie Folgendes ein:Type REG_SZREG_SZ
    WertValue truetrue

Mit der Unterstützung von Gannen in Formatierungs Vorgängen wird im vorherigen Beispiel die folgende Ausgabe angezeigt: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 wurde ebenfalls aktualisiert, sodass Datums-und Uhrzeit-Verarbeitungsvorgänge Zeichen folgen unterstützen, die das Jahr enthalten, das entweder als "1" oder als "Gannen" dargestellt wird..NET has also been updated so that date and time parsing operations support strings that contain the year represented as either "1" or Gannen. Dies ist zwar nicht erforderlich, aber Sie können das vorherige Verhalten wiederherstellen, um nur "1" als erstes Jahr eines Zeitraums zu erkennen.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. Sie können dies abhängig von der .NET-Version wie folgt ausführen:You can do this as follows, depending on the version of .NET:

  • .Net Core: Sie können der Konfigurationsdatei . Netcore. Runtime. JSON Folgendes hinzufügen:.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 oder höher: Sie können den folgenden appContext-Schalter festlegen:.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 oder früher: Sie können den folgenden Registrierungs Wert festlegen:.NET Framework 4.5.2 or earlier: You can set the following registry value:

    KeyKey HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft.netframework\appcontextHKEY_LOCAL_MACHINE\Software\Microsoft.NETFramework\AppContext
    -NameName Switch. System. Globalization. enforcelegacyjapanesedateparamesingSwitch.System.Globalization.EnforceLegacyJapaneseDateParsing
    Geben Sie Folgendes ein:Type REG_SZREG_SZ
    WertValue truetrue

Siehe auchSee also