Freigeben über

Arbeiten mit Kalendern

Obwohl ein Datums- und Uhrzeitwert einen Moment in der Zeit darstellt, ist die Zeichenfolgendarstellung kulturempfindlich und hängt sowohl von den Konventionen ab, die zum Anzeigen von Datums- und Uhrzeitwerten durch eine bestimmte Kultur und den von dieser Kultur verwendeten Kalender verwendet werden. In diesem Thema wird die Unterstützung für Kalender in .NET erläutert und die Verwendung der Kalenderklassen beim Arbeiten mit Datumswerten erläutert.

Kalender in .NET

Alle Kalender in .NET werden von der System.Globalization.Calendar Klasse abgeleitet, die die Basiskalenderimplementierung bereitstellt. Eine der Klassen, die von der Calendar Klasse erbt, ist die EastAsianLunisolarCalendar Klasse, die die Basisklasse für alle Lunisolarkalender ist. .NET enthält die folgenden Kalenderimplementierungen:

Ein Kalender kann auf eine von zwei Arten verwendet werden:

  • Als Kalender, der von einer bestimmten Kultur verwendet wird. Jedes CultureInfo Objekt verfügt über einen aktuellen Kalender, d. h. den Kalender, den das Objekt derzeit verwendet. Die Zeichenfolgendarstellungen aller Datums- und Uhrzeitwerte spiegeln automatisch die aktuelle Kultur und den aktuellen Kalender wider. In der Regel ist der aktuelle Kalender der Standardkalender der Kultur. CultureInfo Objekte verfügen auch über optionale Kalender, die zusätzliche Kalender enthalten, die von der Kultur verwendet werden können.

  • Als eigenständiger Kalender unabhängig von einer bestimmten Kultur. In diesem Fall werden Methoden verwendet, um Datumsangaben als Werte auszudrücken, Calendar die den Kalender widerspiegeln.

Beachten Sie, dass sechs Kalenderklassen – ChineseLunisolarCalendar, , JapaneseLunisolarCalendarJulianCalendar, KoreanLunisolarCalendar, PersianCalendarund TaiwanLunisolarCalendar – nur als eigenständige Kalender verwendet werden können. Sie werden von keiner Kultur als Standardkalender oder als optionaler Kalender verwendet.

Kalender und Kulturen

Jede Kultur verfügt über einen Standardkalender, der von der CultureInfo.Calendar Eigenschaft definiert wird. 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 dieser Kultur.

Das folgende Beispiel veranschaulicht die CultureInfo.Calendar und CultureInfo.OptionalCalendars Eigenschaften. 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. Beachten Sie, dass in beiden Fällen auch der Standardkalender der Kultur in der CultureInfo.OptionalCalendars Sammlung enthalten ist.

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 {ci.Name} culture:");

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

      if (defaultCalendar is GregorianCalendar)
         Console.WriteLine($" ({((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 aktuell von einem bestimmten CultureInfo Objekt verwendete Kalender wird durch die Eigenschaft der Kultur DateTimeFormatInfo.Calendar definiert. Das DateTimeFormatInfo Objekt einer Kultur wird von der CultureInfo.DateTimeFormat Eigenschaft zurückgegeben. Beim Erstellen einer Kultur wird ihr Standardwert auf den Wert der CultureInfo.Calendar-Eigenschaft festgelegt. Sie können jedoch den aktuellen Kalender der Kultur in einen beliebigen Kalender ändern, der in dem Array enthalten ist, das von der CultureInfo.OptionalCalendars Eigenschaft zurückgegeben wird. Wenn Sie versuchen, den aktuellen Kalender auf einen Kalender festzulegen, der nicht im CultureInfo.OptionalCalendars-Eigenschaftswert enthalten ist, wird eine ArgumentException ausgelöst.

Im folgenden Beispiel wird der von der arabischen Kultur (Saudi-Arabien) verwendete Kalender geändert. Zunächst instanziiert er einen DateTime Wert und zeigt ihn mithilfe der aktuellen Kultur an, die in diesem Fall Englisch (Vereinigte Staaten) ist, und dem Kalender der aktuellen Kultur, der in diesem Fall der gregorianische Kalender ist. Als Nächstes ändert sie die aktuelle Kultur in Arabisch (Saudi-Arabien) und zeigt das Datum mit dem Standardkalender Um Al-Qura an. Anschließend wird die CalendarExists Methode aufgerufen, um festzustellen, ob der Hijri-Kalender von der arabischen Kultur (Saudi-Arabien) unterstützt wird. Da der Kalender unterstützt wird, ändert er den aktuellen Kalender in Hijri und zeigt das Datum erneut an. Beachten Sie, dass in jedem Fall das Datum mithilfe des aktuellen Kalenders der aktuellen Kultur angezeigt wird.

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: {CultureInfo.CurrentCulture.Name}");
      Console.WriteLine($"Current Calendar: {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 Kalender

Mit Ausnahme der Konstruktoren, die einen Parameter vom Typ Calendar enthalten und zulassen, dass die Elemente eines Datums (d. h. des Monats, des Tages und des Jahres) Werte in einem festgelegten Kalender widerspiegeln, basieren beide DateTime und DateTimeOffset Werte immer auf dem gregorianischen Kalender. Dies bedeutet beispielsweise, dass die DateTime.Year Eigenschaft das Jahr im gregorianischen Kalender zurückgibt und die DateTime.Day Eigenschaft den Tag des Monats im gregorianischen Kalender zurückgibt.

Von Bedeutung

Es ist wichtig zu beachten, dass es einen Unterschied zwischen einem Datumswert und seiner Zeichenfolgendarstellung gibt. Der erste basiert auf dem gregorianischen Kalender; letzteres basiert auf dem aktuellen Kalender einer bestimmten Kultur.

Im folgenden Beispiel wird dieser Unterschied zwischen DateTime Eigenschaften und den entsprechenden Calendar Methoden veranschaulicht. Im Beispiel ist die aktuelle Kultur Arabisch (Ägypten), und der aktuelle Kalender ist Um Al Qura. Ein DateTime Wert wird auf den fünfzehnten Tag des siebten Monats 2011 festgelegt. Es ist klar, dass dies als gregorianisches Datum interpretiert wird, da dieselben Werte von der DateTime.ToString(String, IFormatProvider) Methode zurückgegeben werden, wenn sie die Konventionen der invarianten Kultur verwendet. Die Zeichenfolgendarstellung des Datums, das mit den Konventionen der aktuellen Kultur formatiert ist, ist 14/08/32, das das entsprechende Datum im Um Al Qura-Kalender ist. Anschließend werden Member von DateTime und Calendar verwendet, um den Tag, den Monat und das Jahr des DateTime-Werts zurückzugeben. In jedem Fall spiegeln die von DateTime Mitgliedern zurückgegebenen Werte Werte im gregorianischen Kalender wider, während von UmAlQuraCalendar Mitgliedern zurückgegebene Werte Werte im Kalender "Uum al-Qura" widerspiegeln.

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: {date1:d}");
      Console.WriteLine($"Date in the Invariant Culture: {date1.ToString("d", CultureInfo.InvariantCulture)}");
      Console.WriteLine();

      // Compare DateTime properties and Calendar methods.
      Console.WriteLine($"DateTime.Month property: {date1.Month}");
      Console.WriteLine($"UmAlQura.GetMonth: {cal.GetMonth(date1)}");
      Console.WriteLine();

      Console.WriteLine($"DateTime.Day property: {date1.Day}");
      Console.WriteLine($"UmAlQura.GetDayOfMonth: {cal.GetDayOfMonth(date1)}");
      Console.WriteLine();

      Console.WriteLine($"DateTime.Year property: {date1.Year:D4}");
      Console.WriteLine($"UmAlQura.GetYear: {cal.GetYear(date1)}");
      Console.WriteLine();
   }

   private static void DisplayCurrentInfo()
   {
      Console.WriteLine($"Current Culture: {CultureInfo.CurrentCulture.Name}");
      Console.WriteLine($"Current Calendar: {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 basierend auf einem Kalender

Da DateTime und DateTimeOffset Werte auf dem gregorianischen Kalender basieren, müssen Sie einen überladenen Konstruktor aufrufen, der einen Parameter vom Typ Calendar enthält, um einen Datumswert zu instanziieren, wenn Sie die Werte für Tag, Monat oder Jahr aus einem anderen Kalender verwenden möchten. Sie können auch eine der Überladungen der Methode eines bestimmten Kalenders Calendar.ToDateTime aufrufen, um ein Objekt DateTime basierend auf den Werten dieses Kalenders zu instanziieren.

Im folgenden Beispiel wird ein DateTime Wert instanziiert, indem ein HebrewCalendar Objekt an einen DateTime Konstruktor übergeben wird, und ein zweiter DateTime Wert wird durch Aufrufen der HebrewCalendar.ToDateTime(Int32, Int32, Int32, Int32, Int32, Int32, Int32, Int32) Methode instanziiert. Da die beiden Werte mit identischen Werten aus dem hebräischen Kalender erstellt werden, zeigt der Aufruf der DateTime.Equals Methode an, dass die beiden DateTime Werte gleich sind.

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 Kalender

Datums- und Uhrzeitformatierungsmethoden verwenden beim Konvertieren von Datumsangaben in Zeichenfolgen immer den aktuellen Kalender. Dies bedeutet, dass die Zeichenfolgendarstellung des Jahres, des Monats und des Tages im Monat den aktuellen Kalender widerspiegelt und nicht unbedingt den gregorianischen Kalender.

Das folgende Beispiel zeigt, wie sich der aktuelle Kalender auf die Zeichenfolgendarstellung eines Datums auswirkt. Im Beispiel wird die aktuelle Kultur auf Chinesisch (traditionell, Taiwan) festgelegt und ein Datumswert instanziiert. Anschließend werden der aktuelle Kalender und das Datum angezeigt, der aktuelle Kalender wird zu TaiwanCalendar geändert, und der aktuelle Kalender und das Datum werden erneut angezeigt. Wenn das Datum zum ersten Mal angezeigt wird, wird es als Datum im gregorianischen Kalender dargestellt. Das zweite Mal, wenn es angezeigt wird, wird es als Datum im Taiwan-Kalender dargestellt.

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: {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: {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 Kalender

Um ein Datum mithilfe eines Kalenders darzustellen, der nicht der aktuelle Kalender einer bestimmten Kultur ist, müssen Sie Methoden dieses Calendar Objekts aufrufen. Beispielsweise konvertieren die Calendar.GetYearMethoden Calendar.GetMonthCalendar.GetDayOfMonth Jahr, Monat und Tag in Werte, die einen bestimmten Kalender widerspiegeln.

Warnung

Da einige Kalender keine optionalen Kalender einer Kultur sind, erfordert die Darstellung von Datumsangaben in diesen Kalendern immer, dass Sie Kalendermethoden aufrufen. Dies gilt für alle Kalender, die von den Klassen EastAsianLunisolarCalendar, JulianCalendar, und PersianCalendar abgeleitet sind.

Im folgenden Beispiel wird ein Objekt verwendet, um ein JulianCalendar Datum vom 9. Januar 1905 im julianischen Kalender instanziieren zu können. Wenn dieses Datum mithilfe des Standardkalenders (Gregorianischer Kalender) angezeigt wird, wird es als 22. Januar 1905 dargestellt. Aufrufe einzelner JulianCalendar Methoden ermöglichen die Darstellung des Datums im julianischen Kalender.

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 Datumsbereiche

Das früheste Datum, das von einem Kalender unterstützt wird, wird durch die Eigenschaft dieses Kalenders Calendar.MinSupportedDateTime angegeben. Für die GregorianCalendar Klasse ist dieses Datum der 1. Januar 0001 n. Chr. Die meisten anderen Kalender in .NET unterstützen ein späteres Anfangsdatum. Wenn Sie versuchen, mit einem Datums- und Uhrzeitwert zu arbeiten, der dem frühesten unterstützten Datum eines Kalenders vorausgeht, wird eine ArgumentOutOfRangeException Ausnahme ausgelöst.

Es gibt jedoch eine wichtige Ausnahme. Der Standardwert (nicht initialisiert) eines DateTime Objekts und eines DateTimeOffset Objekts ist gleich dem GregorianCalendar.MinSupportedDateTime Wert. Wenn Sie versuchen, dieses Datum in einem Kalender zu formatieren, der den 1. Januar 0001 C.E. nicht unterstützt, und Sie keinen Formatbezeichner angeben, verwendet die Formatierungsmethode den Formatbezeichner "s" (sortierbares Datums-/Uhrzeitmuster) anstelle des Formatbezeichners "G" (allgemeines Datums-/Uhrzeitmuster). Infolgedessen löst der Formatierungsvorgang keine ArgumentOutOfRangeException Ausnahme aus. Stattdessen wird das nicht unterstützte Datum zurückgegeben. Dies wird im folgenden Beispiel veranschaulicht, das den Wert DateTime.MinValue zeigt, wenn die aktuelle Kultur auf Japanisch (Japan) mit dem japanischen Kalender und auf Arabisch (Ägypten) mit dem Um Al Qura-Kalender festgelegt ist. Außerdem wird die aktuelle Kultur auf Englisch (USA) festgelegt und die DateTime.ToString(IFormatProvider) Methode mit jedem dieser CultureInfo Objekte aufgerufen. In jedem Fall wird das Datum mithilfe des sortierbaren Datums-/Uhrzeitmusters angezeigt.

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 {GetCalendarName(jaJP)} calendar: {jaJP.DateTimeFormat.Calendar.MinSupportedDateTime:d}");
      // 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 {GetCalendarName(arEG)} calendar: {arEG.DateTimeFormat.Calendar.MinSupportedDateTime:d}");
      // 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 Zeiträumen

Kalender teilen Datumsangaben normalerweise in Epochen auf. Calendar Die Klassen in .NET unterstützen jedoch nicht jede von einem Kalender definierte Ära, und die Calendar meisten Klassen unterstützen nur eine einzige Ära. Nur die Klassen JapaneseCalendar und JapaneseLunisolarCalendar unterstützen mehrere Epochen.

Von Bedeutung

Die Ära Reiwa, eine neue Ära in der JapaneseCalendar und JapaneseLunisolarCalendarbeginnt am 1. Mai 2019. Diese Änderung wirkt sich auf alle Anwendungen aus, die diese Kalender verwenden. Weitere Informationen finden Sie in den folgenden Artikeln:

Eine Ära in den meisten Kalendern zeigt einen extrem langen Zeitraum an. Im gregorianischen Kalender erstreckt sich beispielsweise die aktuelle Ära über mehr als zwei Millennia. Für die JapaneseCalendar und die JapaneseLunisolarCalendarbeiden Kalender, die mehrere Epochen unterstützen, ist dies nicht der Fall. Eine Ära entspricht der Zeit der Kaiserzeit. Die Unterstützung für mehrere Epochen, insbesondere wenn die Obergrenze der aktuellen Ära unbekannt ist, stellt besondere Herausforderungen dar.

Zeiträume und Namen von Zeiträumen

In .NET werden ganze Zahlen, die die von einer bestimmten Kalenderimplementierung unterstützten Epochen darstellen, in umgekehrter Reihenfolge im Calendar.Eras array gespeichert. Die aktuelle Ära (dies ist die Ära mit dem neuesten Zeitbereich) ist bei Index 0 und für Calendar Klassen, die mehrere Epochen unterstützen, spiegelt jeder aufeinander folgende Index die vorherige Ära wider. Die statische Calendar.CurrentEra Eigenschaft definiert den Index der aktuellen Ära im Calendar.Eras Array. Es handelt sich um eine Konstante, deren Wert immer null ist. Einzelne Calendar Klassen enthalten auch statische Felder, die den Wert der aktuellen Ära zurückgeben. Sie sind in der folgenden Tabelle aufgeführt.

Kalenderklasse Feld für den aktuellen Zeitraum
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 einer bestimmten Äranummer entspricht, kann abgerufen werden, indem die Äranummer an die Methode DateTimeFormatInfo.GetEraName oder DateTimeFormatInfo.GetAbbreviatedEraName übergeben wird. Im folgenden Beispiel werden diese Methoden aufgerufen, um Informationen zur Era-Unterstützung in der GregorianCalendar Klasse abzurufen. Es zeigt das gregorianische Kalenderdatum an, das dem 1. Januar des zweiten Jahres der aktuellen Ära entspricht, sowie das gregorianische Kalenderdatum, das dem 1. Januar des zweiten Jahres jeder unterstützten japanischen Kalenderzeit entspricht.

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" den Namen der Kalenderepoche in der Darstellung von Datum und Uhrzeit als Zeichenfolge. Weitere Informationen finden Sie unter Benutzerdefinierte Datums- und Uhrzeit-Formatzeichenfolgen.

Instanziieren eines Datums mit einer Ära

Für die beiden Calendar Klassen, die mehrere Epochen unterstützen, kann ein Datum, das aus einem bestimmten Jahr, Monat und Tag des Monatswerts besteht, mehrdeutig sein. Beispielsweise haben alle von JapaneseCalendar unterstützten Zeitalter Jahre, deren Zahl 1 ist. Wenn eine Ära nicht angegeben ist, gehen sowohl Datums- als auch Uhrzeit- und Kalendermethoden davon aus, dass Werte zur aktuellen Ära gehören. Dies gilt für die DateTime und DateTimeOffset Konstruktoren, die Parameter vom Typ Calendarenthalten, sowie die Methoden "JapaneseCalendar.ToDateTime " und "JapaneseLunisolarCalendar.ToDateTime" . Im folgenden Beispiel wird ein Datum instanziiert, das den 1. Januar des zweiten Jahres einer nicht angegebenen Ära darstellt. Wenn Sie das Beispiel ausführen, wenn die Reiwa-Ära die aktuelle Ära ist, wird das Datum als das zweite Jahr der Reiwa-Ära interpretiert. Der Zeitraum (令和) geht dem Jahr in der von der DateTime.ToString(String, IFormatProvider)-Methode zurückgegebenen Zeichenfolge voraus und entspricht dem 1. Januar 2020 im gregorianischen Kalender. (Die Ära Reiwa beginnt im Jahr 2019 des gregorianischen Kalenders.)

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 das Zeitalter ändert, wird die Absicht dieses Codes jedoch mehrdeutig. Soll das Datum das zweite Jahr der aktuellen Ära darstellen, oder soll es das zweite Jahr der Heisei-Ära darstellen? Es gibt zwei Möglichkeiten, diese Mehrdeutigkeit zu vermeiden:

  • Instanziieren Sie den Datums- und Uhrzeitwert mithilfe der Standardklasse GregorianCalendar . Anschließend können Sie den japanischen Kalender oder den japanischen Lunisolar-Kalender für die Zeichenfolgendarstellung von Datumsangaben verwenden, wie im folgenden Beispiel gezeigt.

    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

  • Rufen Sie eine Datums- und Uhrzeitmethode auf, die explizit eine Ära angibt. Dazu gehören die folgenden Methoden:

    Im folgenden Beispiel werden drei dieser Methoden verwendet, um ein Datum und eine Uhrzeit im Meiji-Zeitalter zu instanziieren, das am 8. September 1868 begann und am 29. Juli 1912 endete.

    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($"{date2.ToString("d", jaJp)} (Gregorian {date2:d})");
        }
        catch (FormatException)
        {
            Console.WriteLine("The parsing operation failed.");
        }

        try {
            var date3 = DateTime.ParseExact("明治23/9/8", "gyy/M/d", jaJp);
            Console.WriteLine($"{date3.ToString("d", jaJp)} (Gregorian {date3: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($"{date2.ToString("d", jaJp)} (Gregorian {date2: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($"{date3.ToString("d", jaJp)} (Gregorian {date3: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 mit Kalendern arbeiten, die mehrere Zeiträume unterstützen, verwenden Sie immer das gregorianische Datum, um ein Datum zu instanziieren, oder geben Sie die Ära an, wenn Sie ein Datum und eine Uhrzeit basierend auf diesem Kalender instanziieren.

Wenn Sie eine Ära für die ToDateTime(Int32, Int32, Int32, Int32, Int32, Int32, Int32, Int32) Methode angeben, geben Sie den Index der Ära in der Eigenschaft des Kalenders Eras an. Bei Kalendern, deren Zeitalter geändert werden können, sind diese Indizes jedoch keine konstanten Werte; die aktuelle Ära ist bei Index 0, und die älteste Ära ist am Index Eras.Length - 1. Wenn einem Kalender eine neue Ära hinzugefügt wird, werden die Indizes der vorherigen Ära um eins erhöht. Sie können den entsprechenden Era-Index wie folgt bereitstellen:

  • Verwenden Sie für Datumsangaben in der aktuellen Ära immer die Eigenschaft des Kalenders CurrentEra .

  • Verwenden Sie für Datumsangaben in einer angegebenen Ära die DateTimeFormatInfo.GetEraName Methode, um den Index abzurufen, der einem angegebenen Era-Namen entspricht. Dies erfordert, dass der JapaneseCalendar der aktuelle Kalender des CultureInfo Objekts ist, das die ja-JP Kultur darstellt. (Diese Technik funktioniert auch für die JapaneseLunisolarCalendar, da sie dieselben Epochen wie die JapaneseCalendar unterstützt.) Das vorherige Beispiel veranschaulicht diesen Ansatz.

Kalender, Zeiträume und Datumsbereiche: Gelockerte Bereichsüberprüfungen

Ähnlich wie einzelne Kalender Datumsbereiche unterstützt haben, verfügen auch die Zeiträume in den JapaneseCalendar- und JapaneseLunisolarCalendar-Klassen über unterstützte Bereiche. Zuvor hat .NET strenge Era-Bereichsprüfungen verwendet, um sicherzustellen, dass ein datumsspezifisches Datum innerhalb des Bereichs dieser Ära liegt. Das heißt, wenn ein Datum außerhalb des Bereichs der angegebenen Ära liegt, löst die Methode einen Fehler ArgumentOutOfRangeException aus. Derzeit verwendet .NET standardmäßig gelockerte Bereichsprüfung. Mit Updates für alle Versionen von .NET wurde gelockerte Überprüfung des Zeitbereichs eingeführt. Beim Versuch, ein zeitraumspezifisches Datum zu instanziieren, das außerhalb des Bereichs des angegebenen Zeitraums liegt, erfolgt ein Überlauf in den folgenden Zeitraum, und es wird keine Ausnahme ausgelöst.

Im folgenden Beispiel wird versucht, ein Datum im 65. Jahr der Showa-Ära zu instanziieren, das am 25. Dezember 1926 begann und am 7. Januar 1989 endete. Dieses Datum entspricht dem 9. Januar 1990, der sich außerhalb des Bereichs der Showa-Ära befindet im JapaneseCalendar. Wie die Ausgabe des Beispiels veranschaulicht, ist das durch das Beispiel angezeigte Datum der 9. Januar 1990 im zweiten Jahr der Heisei-Ära.

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 entspannte Bereichsüberprüfungen nicht erwünscht sind, können Sie abhängig von der Version von .NET, auf der Ihre Anwendung ausgeführt wird, strenge Bereichsüberprüfungen auf verschiedene Arten wiederherstellen:

  • .NET Core: Fügen Sie der Konfigurationsdatei .netcore.runtime.json Folgendes hinzu:

    "runtimeOptions": {
  "configProperties": {
      "Switch.System.Globalization.EnforceJapaneseEraYearRanges": true
  }
}

  • .NET Framework 4.6 oder höher: Legen Sie den folgenden AppContext-Switch in der dateiapp.config fest:

    <?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: Legen Sie den folgenden Registrierungswert fest:

    Wert
    Schlüssel HKEY_LOCAL_MACHINE\Software\Microsoft\.NETFramework\AppContext
    Eingabe Switch.System.Globalization.EnforceJapaneseEraYearRanges
    Typ REG_SZ
    Wert Wahr

Wenn strenge Bereichsprüfungen aktiviert sind, löst das vorherige Beispiel eine ArgumentOutOfRangeException aus und zeigt die folgende Ausgabe an:

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 Epochen

Wenn ein Calendar Objekt Ären unterstützt und der aktuelle Kalender eines CultureInfo Objekts ist, wird die Ära in der Zeichenfolgendarstellung eines Datums- und Uhrzeitwerts für das vollständige Datum und die Uhrzeit sowie für das lange und kurze Datumsmuster eingeschlossen. Im folgenden Beispiel werden diese Datumsmuster angezeigt, wenn die aktuelle Kultur Japan (Japanisch) ist und der aktuelle Kalender der japanische Kalender ist.

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 Kalenderklasse in .NET, die sowohl Datumsangaben in mehr als einer Ära unterstützt und der aktuelle Kalender eines CultureInfo Objekts sein kann – insbesondere eines CultureInfo Objekts, das die japanische Kultur (Japan) darstellt.

Für alle Kalender enthält der benutzerdefinierte Formatbezeichner "g" die Ära in der Ergebniszeichenfolge. Im folgenden Beispiel wird die benutzerdefinierte Formatzeichenfolge "MM-dd-yyyy g" verwendet, um die Ära in die Ergebniszeichenfolge einzuschließen, wenn der aktuelle Kalender der gregorianische Kalender ist.

   DateTime dat = new DateTime(2012, 5, 1);
   Console.WriteLine($"{dat:MM-dd-yyyy g}");
// 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, enthält die Calendar Klasse eine Calendar.GetEra Methode, die zusammen mit dem Calendar.GetYear, Calendar.GetMonthund Calendar.GetDayOfMonth methoden verwendet werden kann, um eindeutig ein Datum sowie die Ära anzugeben, zu der sie gehört. Im folgenden Beispiel wird die JapaneseLunisolarCalendar Klasse verwendet, um eine Abbildung bereitzustellen. 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. (Der JapaneseLunisolarCalendar Kalender kann nicht der aktuelle Kalender einer Kultur sein, aber in diesem Fall verwenden die beiden Kalender dieselben Epochen.)

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 einer Ära Gannen (元年). Anstelle von Heisei 1 kann beispielsweise das erste Jahr der Heisei-Ära als Heisei Gannen beschrieben werden. .NET übernimmt diese Konvention in Formatierungsvorgängen für Datums- und Uhrzeitangaben, die mit den folgenden Standard- oder benutzerdefinierten Datums- und Uhrzeitformatzeichenfolgen formatiert sind, wenn sie mit einem CultureInfo Objekt verwendet werden, das die Japanese-Japan ("ja-JP") Kultur mit der JapaneseCalendar Klasse darstellt:

Das folgende Beispiel zeigt z. B. ein Datum im ersten Jahr der Heisei-Ära in der 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 Formatierungsvorgängen nicht erwünscht ist, können Sie das vorherige Verhalten wiederherstellen, das immer das erste Jahr einer Ära als "1" anstelle von "Gannen" darstellt, indem Sie die folgenden Schritte ausführen, je nach .NET-Version:

  • .NET Core: Fügen Sie der Konfigurationsdatei .netcore.runtime.json Folgendes hinzu:

    "runtimeOptions": {
  "configProperties": {
      "Switch.System.Globalization.FormatJapaneseFirstYearAsANumber": true
  }
}

  • .NET Framework 4.6 oder höher: Legen Sie den folgenden AppContext-Switch in der dateiapp.config fest:

    <?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: Legen Sie den folgenden Registrierungswert fest:

    Wert
    Schlüssel HKEY_LOCAL_MACHINE\Software\Microsoft\.NETFramework\AppContext
    Eingabe Switch.System.Globalization.FormatJapaneseFirstYearAsANumber
    Typ REG_SZ
    Wert Wahr

Wenn die Gannen-Unterstützung für Formatierungsvorgänge deaktiviert ist, zeigt das vorherige Beispiel die folgende Ausgabe an:

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

.NET wurde auch aktualisiert, sodass Datums- und Uhrzeitanalysevorgänge Zeichenfolgen unterstützen, die das Jahr enthalten, das entweder als "1" oder "Gannen" dargestellt wird. Obwohl Sie dies nicht tun müssen, können Sie das vorherige Verhalten wiederherstellen, um nur "1" als erstes Jahr einer Ära zu erkennen. Je nach .NET-Version können Sie dies wie folgt tun:

  • .NET Core: Fügen Sie der Konfigurationsdatei .netcore.runtime.json Folgendes hinzu:

    "runtimeOptions": {
  "configProperties": {
      "Switch.System.Globalization.EnforceLegacyJapaneseDateParsing": true
  }
}

  • .NET Framework 4.6 oder höher: Legen Sie den folgenden AppContext-Switch in der dateiapp.config fest:

    <?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: Legen Sie den folgenden Registrierungswert fest:

    Wert
    Schlüssel HKEY_LOCAL_MACHINE\Software\Microsoft\.NETFramework\AppContext
    Eingabe Switch.System.Globalization.EnforceLegacyJapaneseDateParsing
    Typ REG_SZ
    Wert Wahr

Siehe auch

  • Last updated on