Megosztás a következőn keresztül:

Naptárak használata

  • Cikk

Bár a dátum- és időértékek egy adott időpontot jelölnek, a sztring-ábrázolása kulturális szempontból érzékeny, és függ az adott kultúra által használt dátum- és időértékek megjelenítéséhez használt konvencióktól, valamint az adott kultúra által használt naptártól. Ez a témakör a .NET-naptárak támogatását ismerteti, és ismerteti a naptárosztályok használatát a dátumértékek használatakor.

Naptárak a .NET-ben

A .NET összes naptára az System.Globalization.Calendar osztályból származik, amely az alapnaptár implementálását biztosítja. Az osztálytól Calendar öröklő osztályok egyike az EastAsianLunisolarCalendar osztály, amely az összes lunisoláris naptár alaposztálya. A .NET a következő naptár-implementációkat tartalmazza:

A naptár kétféleképpen használható:

  • Egy adott kultúra által használt naptárként. Minden CultureInfo objektum rendelkezik egy aktuális naptárral, amely az objektum által jelenleg használt naptár. Az összes dátum- és időérték sztring-ábrázolása automatikusan tükrözi az aktuális kultúrát és annak aktuális naptárát. Általában az aktuális naptár a kultúra alapértelmezett naptára. CultureInfo az objektumokhoz opcionális naptárak is tartoznak, amelyek további naptárakat is tartalmaznak, amelyeket a kultúra használhat.

  • Önálló naptárként, egy adott kultúrától függetlenül. Ebben az esetben Calendar a metódusok a dátumokat a naptárnak megfelelő értékekként fejezik ki.

Vegye figyelembe, hogy hat naptárosztály – ChineseLunisolarCalendar, JapaneseLunisolarCalendar, JulianCalendar, KoreanLunisolarCalendarés TaiwanLunisolarCalendarPersianCalendar– csak önálló naptárként használható. Egyik kultúra sem alapértelmezett naptárként, sem választható naptárként nem használja őket.

Naptárak és kultúrák

Minden kultúra rendelkezik egy alapértelmezett naptárral, amelyet a CultureInfo.Calendar tulajdonság határoz meg. A CultureInfo.OptionalCalendars tulajdonság egy objektumtömböt Calendar ad vissza, amely meghatározza az adott kultúra által támogatott összes naptárt, beleértve a kultúra alapértelmezett naptárát is.

Az alábbi példa a tulajdonságokat és CultureInfo.OptionalCalendars a CultureInfo.Calendar tulajdonságokat mutatja be. Objektumokat hoz létre CultureInfo a thai (Thaiföld) és a japán (Japán) kultúrák számára, és megjeleníti az alapértelmezett és választható naptárakat. Vegye figyelembe, hogy mindkét esetben a kultúra alapértelmezett naptára is szerepel a CultureInfo.OptionalCalendars gyűjteményben.

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)

Az adott CultureInfo objektum által jelenleg használt naptárat a kultúra tulajdonsága DateTimeFormatInfo.Calendar határozza meg. A kulturális DateTimeFormatInfo objektumot a CultureInfo.DateTimeFormat tulajdonság adja vissza. A kultúra létrehozásakor az alapértelmezett érték megegyezik a CultureInfo.Calendar tulajdonság értékével. A kultúra aktuális naptárát azonban a tulajdonság által CultureInfo.OptionalCalendars visszaadott tömb bármely naptárára módosíthatja. Ha az aktuális naptárat olyan naptárra próbálja beállítani, amely nem szerepel a tulajdonságértékben, akkor a rendszer egy olyan naptárt ad meg, ArgumentException amely nem szerepel a CultureInfo.OptionalCalendars tulajdonságértékben.

Az alábbi példa az arab (Szaúd-Arábia) kultúra által használt naptárt módosítja. Először példányosít egy DateTime értéket, és megjeleníti azt a jelenlegi kultúrával - amely ebben az esetben angol (Egyesült Államok) - és az aktuális kultúra naptárával (amely ebben az esetben a Gergely-naptár). Ezután arabra (Szaúd-Arábia) módosítja az aktuális kultúrát, és megjeleníti a dátumot az alapértelmezett Um Al-Qura naptár használatával. Ezután meghívja a CalendarExists metódust annak meghatározására, hogy a Hijri naptárt támogatja-e az arab (Szaúd-Arábia) kultúra. Mivel a naptár támogatott, az aktuális naptárt Hijrire módosítja, és ismét megjeleníti a dátumot. Vegye figyelembe, hogy a dátum minden esetben az aktuális kultúra aktuális naptárával jelenik meg.

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

Dátumok és naptárak

A konstruktorok kivételével, amelyek egy típusparamétert Calendar tartalmaznak, és lehetővé teszik egy dátum elemeinek (azaz a hónapnak, a napnak és az évnek) az értékeit egy kijelölt naptárban, mind DateTimeDateTimeOffset az értékek mindig a Gergely-naptáron alapulnak. Ez azt jelenti például, hogy a tulajdonság az DateTime.Year évet adja vissza a Gergely-naptárban, a tulajdonság pedig DateTime.Day a hónap napját adja vissza a Gergely-naptárban.

Fontos

Fontos megjegyezni, hogy különbség van a dátumérték és a sztringábrázolás között. Az előbbi a Gergely-naptáron alapul; az utóbbi egy adott kultúra aktuális naptárán alapul.

Az alábbi példa a tulajdonságok és a hozzájuk tartozó Calendar metódusok közötti DateTime különbséget szemlélteti. A példában a jelenlegi kultúra arab (Egyiptom), a jelenlegi naptár pedig Um Al Qura. Az DateTime érték 2011 hetedik hónapjának tizenötödik napjára van beállítva. Egyértelmű, hogy ezt gergelyi dátumként értelmezik, mivel ezeket az értékeket a DateTime.ToString(String, IFormatProvider) metódus adja vissza az invariáns kultúra konvencióinak használatakor. A jelenlegi kultúra konvenciók alapján formázott dátum sztringképe 14/08/32, amely az Um Al Qura naptár azonos dátuma. Ezután az érték napjának DateTimeCalendar , hónapjának és évének DateTime visszaadására szolgálnak. A tagok által DateTime visszaadott értékek minden esetben a Gergely-naptár értékeit tükrözik, míg a tagok által UmAlQuraCalendar visszaadott értékek az Uum al-Qura naptár értékeit tükrözik.

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

Dátumok példányosítása naptár alapján

Mivel DateTime az DateTimeOffset értékek a Gergely-naptáron alapulnak, egy túlterhelt konstruktort kell meghívnia, amely egy olyan típusú Calendar paramétert tartalmaz, amely egy dátumértéket szeretne példányosítani, ha egy másik naptár nap-, hónap- vagy évértékeit szeretné használni. Egy adott naptár metódusának egyik túlterhelését Calendar.ToDateTime is meghívhatja egy objektum példányosításához DateTime egy adott naptár értékei alapján.

Az alábbi példa egy DateTime értéket példányosít azáltal, hogy átad egy HebrewCalendar objektumot egy DateTime konstruktornak, és a metódus meghívásával HebrewCalendar.ToDateTime(Int32, Int32, Int32, Int32, Int32, Int32, Int32, Int32) létrehoz egy második DateTime értéket. Mivel a két érték azonos értékekkel jön létre a héber naptárból, a DateTime.Equals metódus hívása azt mutatja, hogy a két DateTime érték egyenlő.

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

Dátumok megjelenítése az aktuális naptárban

A dátum- és időformázási módszerek mindig az aktuális naptárt használják a dátumok sztringekké alakításakor. Ez azt jelenti, hogy az év, a hónap és a hónap napja sztringképe az aktuális naptárt tükrözi, és nem feltétlenül tükrözi a Gergely-naptárt.

Az alábbi példa bemutatja, hogy az aktuális naptár hogyan befolyásolja egy dátum sztringképét. A jelenlegi kultúrát kínaira (hagyományos, Tajvan) módosítja, és dátumértéket hoz létre. Ekkor megjeleníti az aktuális naptárt és a dátumot, módosítja az aktuális naptárt TaiwanCalendar, és ismét megjeleníti az aktuális naptárt és dátumot. A dátum első megjelenésekor dátumként jelenik meg a Gergely-naptárban. A második megjelenítéskor dátumként jelenik meg a tajvani naptárban.

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

Dátumok megjelenítése nem aktuális naptárban

Ha olyan dátumot szeretne ábrázolni, amely nem egy adott kultúra aktuális naptára, az objektum metódusait Calendar kell meghívnia. A , Calendar.GetMonthés metódusok például Calendar.GetYearaz évet, a hónapot és Calendar.GetDayOfMonth a napot egy adott naptárt tükröző értékekké alakítják.

Figyelmeztetés

Mivel egyes naptárak nem választható naptárak, ezért a naptárakban szereplő dátumokat mindig meg kell hívni. Ez igaz az összes naptárra, amely a , JulianCalendarés PersianCalendar az EastAsianLunisolarCalendarosztályokból származik.

Az alábbi példa egy JulianCalendar objektumot használ egy 1905. január 9-i dátum példányosítására a Julián naptárban. Ha ez a dátum az alapértelmezett (Gergely-) naptárral jelenik meg, az 1905. január 22-én jelenik meg. Az egyes JulianCalendar metódusokra irányuló hívások lehetővé teszik, hogy a dátum szerepeljen a Julián-naptárban.

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

Naptárak és dátumtartományok

A naptár által támogatott legkorábbi dátumot a naptár tulajdonsága Calendar.MinSupportedDateTime jelzi. Az osztály esetében ez a GregorianCalendar dátum 0001. január 1. A .NET többi naptára támogatja a későbbi dátumot. A naptár legkorábbi támogatott dátumát megelőző dátum- és időértékkel való munka kivételt ArgumentOutOfRangeException eredményez.

Van azonban egy fontos kivétel. Egy objektum és egy DateTimeDateTimeOffset objektum alapértelmezett (nem inicializált) értéke megegyezik az GregorianCalendar.MinSupportedDateTime értékkel. Ha olyan naptárban próbálja formázni ezt a dátumot, amely nem támogatja a 0001. január 1-jét, és nem ad meg formátumjelölőt, a formázási módszer az "s" (rendezhető dátum/idő minta) formátumjelölőt használja a "G" (általános dátum/időminta) formátumjelölő helyett. Ennek eredményeképpen a formázási művelet nem okoz kivételt ArgumentOutOfRangeException . Ehelyett a nem támogatott dátumot adja vissza. Ezt a következő példában szemlélteti, amely azt mutatja be DateTime.MinValue , hogy az aktuális kultúra mikor van beállítva japán (Japán) a japán naptárral, és arab (Egyiptom) az Um Al Qura naptárral. Emellett a jelenlegi kultúrát angolra (Egyesült Államok) állítja be, és mindegyik objektummal CultureInfo meghívja a DateTime.ToString(IFormatProvider) metódust. A dátum minden esetben a rendezhető dátum/idő minta használatával jelenik meg.

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

Korszakok együttműködése

A naptárak általában korszakokra osztják a dátumokat. A Calendar .NET-osztályok azonban nem támogatják a naptár által meghatározott összes korszakot, és a Calendar legtöbb osztály csak egyetlen korszakot támogat. Csak az és JapaneseLunisolarCalendar az JapaneseCalendar osztályok támogatnak több korszakot.

Fontos

A Reiwa korszak, amely egy új korszak, JapaneseCalendar és JapaneseLunisolarCalendar2019. május 1-jén kezdődik. Ez a módosítás minden olyan alkalmazást érint, amely ezeket a naptárakat használja. További információkért tekintse meg az alábbi cikkeket:

  • Új korszak kezelése a japán naptárban a .NET-ben, amely a .NET-hez hozzáadott funkciókkal támogatja a több korral rendelkező naptárakat, és ismerteti a több korszakból álló naptárak kezelésekor használható ajánlott eljárásokat.
  • Készítse elő az alkalmazást a japán korszakváltásra, amely információkat nyújt az alkalmazások Windowson történő teszteléséről, így biztosítva azok felkészültségét a korszakváltásra.
  • Az .NET-keretrendszer új japán korszakfrissítéseinek összefoglalása, amely felsorolja az új japán naptárkorszakhoz kapcsolódó egyes Windows-verziók .NET-keretrendszer frissítéseit, megjegyzi az új .NET-keretrendszer funkciókat a több korszakos támogatáshoz, valamint az alkalmazások tesztelése során keresendő funkciókat.

A legtöbb naptárban egy korszak rendkívül hosszú időszakot jelöl. A Gergely-naptárban például a jelenlegi korszak több mint kétezer éves. JapaneseCalendarJapaneseLunisolarCalendarA több korszakot támogató két naptár esetében ez nem így van. A korszak egy császár uralkodásának időszakának felel meg. Több korszak támogatása, különösen akkor, ha a jelenlegi kor felső határa ismeretlen, különleges kihívásokat jelent.

Korszakok és korszaknevek

A .NET-ben az adott naptár-implementáció által támogatott korszakokat képviselő egész számok fordított sorrendben vannak tárolva a Calendar.Eras tömbben. A jelenlegi korszak (amely a legújabb időtartománysal rendelkező korszak) nulla indexnél van, és a több korszakot támogató osztályok esetében Calendar minden egymást követő index az előző korszakot tükrözi. A statikus Calendar.CurrentEra tulajdonság a tömb aktuális korszakának Calendar.Eras indexét határozza meg; egy állandó, amelynek értéke mindig nulla. Az egyes Calendar osztályok olyan statikus mezőket is tartalmaznak, amelyek az aktuális korszak értékét adják vissza. Ezek a következő táblázatban szerepelnek.

Naptárosztály Aktuális korszak mező
ChineseLunisolarCalendar ChineseEra
GregorianCalendar ADEra
HebrewCalendar HebrewEra
HijriCalendar HijriEra
JapaneseLunisolarCalendar JapaneseEra
JulianCalendar JulianEra
KoreanCalendar KoreanEra
KoreanLunisolarCalendar GregorianEra
PersianCalendar PersianEra
ThaiBuddhistCalendar ThaiBuddhistEra
UmAlQuraCalendar UmAlQuraEra

Az adott korszámnak megfelelő név lekérhető úgy, hogy a korszámot átadja a DateTimeFormatInfo.GetEraName metódusnak DateTimeFormatInfo.GetAbbreviatedEraName . Az alábbi példa ezeket a metódusokat hívja meg az osztály korának támogatásával kapcsolatos információk lekéréséhez GregorianCalendar . Megjeleníti a gergelyi naptárdátumot, amely az aktuális korszak második évének január 1-jének felel meg, valamint a Gergely-naptárdátumot, amely az egyes támogatott japán naptárkorszakok második évének január 1-jének felel meg.

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

Ezenkívül a "g" egyéni dátum- és időformátum sztringje tartalmazza a naptár korszaknevét egy dátum és idő sztring-ábrázolásában. További információ: Egyéni dátum- és időformátum-sztringek.

Dátum példányosítása egy korral

A több korszakot támogató két Calendar osztály esetében egy adott évből, hónapból és hónapból álló dátum nem egyértelmű lehet. Például az összes olyan korszak, amelyet az JapaneseCalendar évek támogatnak, amelyek száma 1. Általában, ha nincs megadva egy korszak, a dátum és az idő, valamint a naptár metódusok feltételezik, hogy az értékek az aktuális korszakhoz tartoznak. Ez igaz a DateTime típusparamétereket tartalmazó konstruktorokraCalendarDateTimeOffset, valamint a JapaneseCalendar.ToDateTime és a JapaneseLunisolarCalendar.ToDateTime metódusokra. Az alábbi példa létrehoz egy dátumot, amely egy meghatározatlan korszak második évének január 1-ét jelöli. Ha azt a példát hajtja végre, amikor a Reiwa-korszak az aktuális korszak, a dátum a Reiwa-korszak második éveként lesz értelmezve. A kor( 令和) a metódus által visszaadott sztringben DateTime.ToString(String, IFormatProvider) előzi meg az évet, és 2020. január 1-jének felel meg a Gergely-naptárban. (A Reiwa-korszak a Gergely-naptár 2019-es évével kezdődik.)

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

Ha azonban a korszak megváltozik, a kód szándéka nem egyértelmű lesz. A dátum a jelenlegi korszak második évét jelöli, vagy a Heisei-korszak második évét kívánja jelölni? Ezt a kétértelműséget kétféleképpen lehet elkerülni:

  • Példányosíthatja a dátum- és időértéket az alapértelmezett GregorianCalendar osztály használatával. Ezután használhatja a japán naptárt vagy a japán lunisoláris naptárt a dátumok sztring-ábrázoláshoz, ahogy az alábbi példa is mutatja.

    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

  • Olyan dátum- és időmetódus meghívása, amely explicit módon meghatároz egy korszakot. Ez a következő módszereket foglalja magában:

    Az alábbi példa három módszert használ egy dátum és idő példányosítására a Meiji-korszakban, amely 1868. szeptember 8-án kezdődött, és 1912. július 29-én ért véget.

    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.

Ha több korszakot támogató naptárakkal dolgozik, mindig a Gergely-dátum használatával példányosíthat egy dátumot, vagy megadhatja a dátumot, amikor a naptár alapján példányosít egy dátumot és időt.

A metódus korának ToDateTime(Int32, Int32, Int32, Int32, Int32, Int32, Int32, Int32) megadásakor meg kell adnia a kor indexét a naptár tulajdonságában Eras . Az olyan naptárak esetében, amelyek korszakai változhatnak, ezek az indexek azonban nem állandó értékek; a jelenlegi kor a 0. indexnél van, és a legrégebbi kor az indexben Eras.Length - 1van. Amikor új korszakot ad hozzá egy naptárhoz, az előző korszakok indexei eggyel növekednek. A megfelelő korindexet az alábbiak szerint adhatja meg:

Naptárak, korszakok és dátumtartományok: Nyugodt tartományellenőrzések

Az egyes naptárakhoz hasonlóan az egyes naptárak is támogatták a dátumtartományokat, a korszakok és JapaneseLunisolarCalendar az JapaneseCalendar osztályok is támogatott tartományokkal rendelkeznek. Korábban a .NET szigorú kortartomány-ellenőrzéseket használt annak biztosítására, hogy egy korszakspecifikus dátum az adott korszak tartományán belül legyen. Vagyis ha egy dátum kívül esik a megadott kor tartományán, a metódus egy ArgumentOutOfRangeException. A .NET jelenleg alapértelmezés szerint nyugodt tartományú ellenőrzést használ. Frissítések a .NET minden verziójára bevezették a nyugodt kortartomány-ellenőrzéseket; a megadott kortartományon kívül eső korszakspecifikus dátum példányosításának kísérlete a következő korszakba, és nem történik kivétel.

Az alábbi példa a Showa-korszak 65. évében próbál dátumot létrehozni, amely 1926. december 25-én kezdődött és 1989. január 7-én ért véget. Ez a dátum 1990. január 9-nek felel meg, amely kívül esik a Showa korszak tartományán a JapaneseCalendar. Ahogy a példa kimenete is mutatja, a példa által megjelenített dátum 1990. január 9., a Heisei-korszak második évében.

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

Ha a nyugodt tartományellenőrzések nem kívánatosak, a szigorú tartományellenőrzéseket többféleképpen is visszaállíthatja attól függően, hogy melyik .NET-verzión fut az alkalmazás:

  • .NET Core: Adja hozzá a következőket a .netcore.runtime.json konfigurációs fájlhoz:

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

  • .NET-keretrendszer 4.6-os vagy újabb verzió: Állítsa be a következő AppContext kapcsolót az app.config fájlban:

    <?xml version="1.0" encoding="utf-8"?>
<configuration>
  <runtime>
    <AppContextSwitchOverrides value="Switch.System.Globalization.EnforceJapaneseEraYearRanges=true" />
  </runtime>
</configuration>

  • .NET-keretrendszer 4.5.2 vagy korábbi verzió: Állítsa be a következő beállításjegyzék-értéket:

    Érték
    Kulcs HKEY_LOCAL_MACHINE\Software\Microsoft\. NETFramework\AppContext
    Bejegyzés Switch.System.Globalization.EnforceJapaneseEraYearRanges
    Típus REG_SZ
    Érték true

Ha engedélyezve van a szigorú tartományellenőrzés, az előző példa a ArgumentOutOfRangeException következő kimenetet jeleníti meg:

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()

Dátumok megjelenítése több korral rendelkező naptárakban

Ha egy Calendar objektum támogatja a korokat, és az objektum aktuális naptára CultureInfo , akkor a kor szerepel a teljes dátum és idő, a hosszú dátum és a rövid dátumminták dátum- és időértékének sztring-ábrázolásában. Az alábbi példa ezeket a dátummintákat jeleníti meg, amikor az aktuális kultúra Japán (japán), az aktuális naptár pedig a japán naptár.

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

Figyelmeztetés

Az JapaneseCalendar osztály az egyetlen olyan naptárosztály a .NET-ben, amely egyszerre több korszakban is támogatja a dátumokat, és amely lehet egy CultureInfo objektum aktuális naptára – pontosabban egy CultureInfo japán (japán) kultúrát képviselő objektum aktuális naptára.

Az összes naptár esetében a "g" egyéni formátumkijelölő tartalmazza a kort az eredménysztringben. Az alábbi példa az "MM-dd-yyyy g" egyéni formátumsztringet használja az eredménysztringbe való felvételhez, amikor az aktuális naptár a Gergely-naptár.

   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.

Azokban az esetekben, amikor a dátum sztring-ábrázolása nem az aktuális naptárban van kifejezve, az Calendar osztály tartalmaz egy Calendar.GetEra metódust, amely a , és Calendar.GetMonthCalendar.GetDayOfMonth a metódusokkal Calendar.GetYearegyütt egyértelműen jelzi a dátumot és azt a korszakot, amelyhez tartozik. Az alábbi példa az osztályt használja illusztrációként JapaneseLunisolarCalendar . Vegye figyelembe azonban, hogy az eredménysztringben szereplő korszakhoz tartozó egész szám helyett egy értelmes nevet vagy rövidítést is meg kell adnia egy DateTimeFormatInfo objektum példányosításához és az aktuális naptár létrehozásához JapaneseCalendar . (A JapaneseLunisolarCalendar naptár nem lehet egy kultúra aktuális naptára, de ebben az esetben a két naptár azonos korszakokkal rendelkezik.)

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

A japán naptárakban egy korszak első évét Gannennek (元年) nevezzük. Heisei 1 helyett például a Heisei-korszak első évét heisei Gannennek is nevezhetjük. A .NET a következő szabványos vagy egyéni dátum- és időformátum-sztringekkel formázott dátum- és időformázási műveletekre alkalmazza ezt az egyezményt, amikor olyan CultureInfo objektummal használják őket, amely a japán-japán ("ja-JP") kultúrát képviseli az JapaneseCalendar osztálysal:

Az alábbi példa például egy dátumot jelenít meg a Heisei-korszak első évében a 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)

Ha ez a viselkedés nem kívánatos a formázási műveletekben, visszaállíthatja az előző viselkedést, amely mindig a korszak első évét jelöli "1"-ként a "Gannen" helyett, a .NET verziójától függően az alábbiak szerint:

  • .NET Core: Adja hozzá a következőket a .netcore.runtime.json konfigurációs fájlhoz:

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

  • .NET-keretrendszer 4.6-os vagy újabb verzió: Állítsa be a következő AppContext kapcsolót az app.config fájlban:

    <?xml version="1.0" encoding="utf-8"?>
<configuration>
  <runtime>
    <AppContextSwitchOverrides value="Switch.System.Globalization.FormatJapaneseFirstYearAsANumber=true" />
  </runtime>
</configuration>

  • .NET-keretrendszer 4.5.2 vagy korábbi verzió: Állítsa be a következő beállításjegyzék-értéket:

    Érték
    Kulcs HKEY_LOCAL_MACHINE\Software\Microsoft\. NETFramework\AppContext
    Bejegyzés Switch.System.Globalization.FormatJapaneseFirstYearAsANumber
    Típus REG_SZ
    Érték true

Ha a gannen nem támogatja a formázási műveleteket, az előző példa a következő kimenetet jeleníti meg:

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

A .NET is frissült, így a dátum- és időelemzési műveletek támogatják azokat a sztringeket, amelyek az évet "1" vagy Gannenként jelölik. Bár ezt nem kell tennie, visszaállíthatja az előző viselkedést, hogy csak az "1" felismerhető legyen egy korszak első éveként. Ezt a .NET verziójától függően az alábbiak szerint teheti meg:

  • .NET Core: Adja hozzá a következőket a .netcore.runtime.json konfigurációs fájlhoz:

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

  • .NET-keretrendszer 4.6-os vagy újabb verzió: Állítsa be a következő AppContext kapcsolót az app.config fájlban:

    <?xml version="1.0" encoding="utf-8"?>
<configuration>
  <runtime>
    <AppContextSwitchOverrides value="Switch.System.Globalization.EnforceLegacyJapaneseDateParsing=true" />
  </runtime>
</configuration>

  • .NET-keretrendszer 4.5.2 vagy korábbi verzió: Állítsa be a következő beállításjegyzék-értéket:

    Érték
    Kulcs HKEY_LOCAL_MACHINE\Software\Microsoft\. NETFramework\AppContext
    Bejegyzés Switch.System.Globalization.EnforceLegacyJapaneseDateParsing
    Típus REG_SZ
    Érték true

Lásd még