Práce s kalendáři

Článek
08/11/2011

Hodnota data a času představuje časový okamžik, jeho řetězcové vyjádření je citlivý kultury a přestože závisí jak na konvence pro zobrazování hodnot data a času podle konkrétní kultury a kalendář této kultury. Toto téma prozkoumá podpora kalendáře v.NET Framework a při práci s hodnotami kalendářních dat popisuje použití tříd kalendáře.

Kalendáře v.NET Framework

Všechny kalendáře v.NET Framework odvodit z System.Globalization.Calendar třídy, který poskytuje implementaci základní kalendář. Jedné třídy, které dědí z Calendar Třída je EastAsianLunisolarCalendar třídy, která je základní třída pro všechny lunisolar kalendáře. Na.NET Framework zahrnuje následující implementací kalendáře:

ChineseLunisolarCalendar, která představuje čínských lunisolar kalendáře.
GregorianCalendar, která představuje gregoriánský kalendář. Tento kalendář je dále rozdělen na podtypy (například arabština a francouzské Střední východ), které jsou definovány System.Globalization.GregorianCalendarTypes výčtu. Vlastnost GregorianCalendar.CalendarType určuje podtyp gregoriánského kalendáře.
HebrewCalendar, která představuje hebrejský kalendář.
HijriCalendar, která představuje kalendáře hidžra.
JapaneseCalendar, která představuje japonský kalendář.
JapaneseLunisolarCalendar, která představuje lunisolar japonský kalendář.
JulianCalendar, která představuje juliánském kalendáři.
KoreanCalendar, která představuje korejský kalendář.
KoreanLunisolarCalendar, která představuje korejský lunisolar kalendáře.
PersianCalendar, která představuje Perština kalendáře.
TaiwanCalendar, která představuje Tchajwanský kalendář.
TaiwanLunisolarCalendar, která představuje lunisolar Tchajwanský kalendář.
ThaiBuddhistCalendar, která představuje thajský buddhistický kalendář.
UmAlQuraCalendar, která představuje Um Al Qura kalendáře.

Kalendář lze použít dvěma způsoby:

Jako kalendář používá konkrétní kultury. Každý CultureInfo aktuální kalendář je kalendář, který se aktuálně používá objekt má objekt. Vyjádření řetězce všechny hodnoty data a času automaticky odráží aktuální kultury a aktuální kalendář. Aktuální kalendář je obvykle výchozí kalendář kultuře. CultureInfoobjekty mají také volitelné kalendářů včetně kalendářů, používajících dané kultury.
Jako samostatný kalendář nezávislé na konkrétní kultury. V tomto případě Calendar metody se používají k vyjádření dat jako hodnoty, které odrážejí kalendáře.

Poznámka, že šest tříd – kalendář ChineseLunisolarCalendar, JapaneseLunisolarCalendar, JulianCalendar, KoreanLunisolarCalendar, PersianCalendar, a TaiwanLunisolarCalendar – lze použít pouze jako samostatný kalendářů. Jejich nejsou používány žádné kultury jako výchozí kalendář nebo volitelné kalendáře.

Kalendáře a kultury

Každá Kultura má výchozí kalendář, který je definován CultureInfo.Calendar vlastnost. CultureInfo.OptionalCalendars Vlastnost vrátí pole Calendar objekty, které určuje všechny kalendáře podporován konkrétní kultury včetně této kultury výchozí kalendář.

Následující příklad ukazuje CultureInfo.Calendar a CultureInfo.OptionalCalendars Vlastnosti. Vytvoří CultureInfo objekty Thajština (Thajsko) a japonština (Japonsko) kultur a zobrazí výchozí a volitelné kalendářů. Všimněte si, že v obou případech kultury výchozí kalendář je také součástí CultureInfo.OptionalCalendars kolekce.

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)

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)

Kalendář aktuálně používáno určité CultureInfo objekt je definován kultuře DateTimeFormatInfo.Calendar vlastnost. Kultura DateTimeFormatInfo vrátil objekt CultureInfo.DateTimeFormat vlastnost. Při vytvoření kultury jeho výchozí hodnota je stejná jako hodnota CultureInfo.Calendar vlastnost. Aktuální kalendář kultury však můžete změnit na libovolný kalendář obsažené ve vrácené matici CultureInfo.OptionalCalendars vlastnost. Pokud se pokusíte nastavit aktuální kalendář kalendář, který je součástí CultureInfo.OptionalCalendars hodnota vlastnosti ArgumentException je vyvolána.

Následující příklad změní kalendář používaný kultury Arabština (Saúdská Arábie). Nejprve konkretizuje DateTime hodnotu a zobrazí jej pomocí kalendáře aktuální prostředí (a která je v tomto případě gregoriánského kalendáře) a aktuální prostředí - a to v tomto případě je angličtina (Spojené státy)-. Potom změní aktuální prostředí Arabština (Saúdská Arábie) a zobrazí datum pomocí jeho výchozí kalendář Um Al-Qura. Pak zavolá CalendarExists Metoda k určení, zda je podporován kalendáře hidžra kultury Arabština (Saúdská Arábie). Protože je podporován kalendáře, změní aktuální kalendář hidžra a znovu zobrazí datum. Poznámka: v každém případě datum je zobrazena aktuální jazyková verze aktuálního kalendáře.

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

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

Data a kalendářů

S výjimkou produktů konstruktory, které obsahují parametr typu Calendar a umožnit tak, aby hodnoty v určených kalendář prvky datum (, měsíc, den a rok) i DateTime a DateTimeOffset hodnoty jsou vždy založeny na gregoriánském kalendáři. To například znamená, že DateTime.Year vlastnost vrátí rok gregoriánského kalendáře a DateTime.Day vlastnost vrátí den v měsíci v gregoriánském kalendáři.

Důležité
Je důležité si uvědomit, že je rozdíl mezi hodnotu data a jeho řetězcové vyjádření.Bývalé je založen na gregoriánském kalendáři. Ten je založen na aktuální kalendář konkrétní kultury.

Následující příklad ukazuje tento rozdíl mezi DateTime Vlastnosti a jejich odpovídající Calendar metod. V příkladu je aktuální prostředí Arabština (Egypt) a aktuální kalendář je Um Al Qura. A DateTime hodnotu patnáctého dne sedmého měsíce 2011. Je jasné, to je interpretován jako datum Gregoriánský, protože jsou tyto stejné hodnoty vrácené DateTime.ToString(String, IFormatProvider) Metoda používá úmluv výchozí kultury. Řetězcové vyjádření formátovaném pomocí konvence kultury aktuální datum je 14/08/32, který je ekvivalentní datum v kalendáři Um Al Qura. Další členové DateTime a Calendar slouží k vrácení den, měsíc a rok DateTime hodnotu. V každém případě vrácené hodnoty DateTime členy odrážejí hodnotami gregoriánského kalendáře, že hodnoty vrácené UmAlQuraCalendar členy odrážejí hodnoty v kalendáři al Qura Uum.

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

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

Konkretizace daty na základě kalendáře

Protože DateTime a DateTimeOffset hodnoty jsou založeny na gregoriánském kalendáři, musíte zavolat přetížená konstruktor, který obsahuje parametr typu Calendar k vytvoření instance datum, pokud chcete použít, den, měsíc nebo rok hodnot z jiné kalendáře. Můžete také volat z přetížení kalendáře konkrétní Calendar.ToDateTime Metoda konkretizovat DateTime objektu na základě hodnoty konkrétního kalendáře.

Následující příklad vytvoří instanci jednoho DateTime předáním hodnoty HebrewCalendar objekt na DateTime konstruktoru a druhé instanci DateTime hodnoty voláním HebrewCalendar.ToDateTime(Int32, Int32, Int32, Int32, Int32, Int32, Int32, Int32) metody. Kalendář s identickými hodnotami z hebrejštinu jsou vytvořena dvě hodnoty, volání DateTime.Equals Metoda ukazuje, že dva DateTime hodnoty jsou rovná.

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

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

Představující data v aktuální kalendář

Metody vždy formátování data a času použít aktuální kalendář při převodu řetězce data. To znamená odrážet aktuální kalendář řetězcové vyjádření rok, měsíc a den v měsíci a nutně neodrážejí gregoriánský kalendář.

Následující příklad ukazuje, jak ovlivňuje řetězcové vyjádření datum aktuální kalendář. Čínština (tradiční, Tchaj-wan), změní aktuální prostředí a konkretizuje hodnotu data. Pak jej zobrazí aktuální kalendář a datum, změní aktuální kalendář TaiwanCalendara znovu zobrazí aktuální kalendář a datum. Při prvním zobrazení data, je zobrazena jako datum gregoriánský kalendář. Podruhé je zobrazen, je zobrazena jako datum v kalendáři Tchaj-wanu.

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

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

Představující data v kalendáři aktuální

Chcete-li znázornit data pomocí kalendáře, který není aktuální kalendář konkrétní kultury musí volat metody, Calendar objektu. Například Calendar.GetYear, Calendar.GetMonth, a Calendar.GetDayOfMonth metody převést rok, měsíc a den hodnotami, které odrážejí konkrétní kalendáře.

Upozornění
Protože některé kalendářů není volitelný kalendáře všechny kultury, představující data v těchto kalendářů vždy vyžaduje volání metody kalendáře.To platí pro všechny kalendáře, které pocházejí z EastAsianLunisolarCalendar, JulianCalendar, a PersianCalendar tříd.

V následujícím příkladu JulianCalendar objektu konkretizovat datum 9 leden 1905 v juliánském kalendáři. Po zobrazení tohoto data pomocí kalendáře výchozí (gregoriánský) je reprezentován jako 22. ledna 1905. Volá jednotlivé JulianCalendar Povolení metody datum v juliánském kalendáři.

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

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

Práce s Arial

Data kalendáře obvykle rozdělit na Arial. Však Calendar , třídy.NET Framework nepodporuje každé EVP definovány kalendář a většina Calendar třídy podporují pouze do jediné EVP. Pouze JapaneseCalendar a JapaneseLunisolarCalendar třídy podporují více Arial.

Arial a názvy EVP

V.NET Framework celá čísla, která představují Arial podporovaných implementací zejména kalendáře jsou uloženy v obráceném pořadí v Calendar.Eras pole. Aktuální věk je indexem nula a pro Calendar tříd, které podporují více Arial, každé následné index odráží předchozí EVP. Statickými Calendar.CurrentEra vlastnost definuje index aktuální období v Calendar.Eras pole; je konstanta, jehož hodnota je vždy nula. Jednotlivé Calendar třídy zahrnují také statické pole, které vrátí hodnotu aktuální věk. Jsou uvedeny v následující tabulce.

Třída kalendáře	EVP aktuální pole
ChineseLunisolarCalendar	ChineseEra
GregorianCalendar	ADEra
HebrewCalendar	HebrewEra
HijriCalendar	HijriEra
JapaneseLunisolarCalendar	JapaneseEra
JulianCalendar	JulianEra
KoreanCalendar	KoreanEra
KoreanLunisolarCalendar	GregorianEra
PersianCalendar	PersianEra
ThaiBuddhistCalendar	ThaiBuddhistEra
UmAlQuraCalendar	UmAlQuraEra

Předáním EVP číslo lze načíst název odpovídající počet rizik pro životní prostředí zejména DateTimeFormatInfo.GetEraName nebo DateTimeFormatInfo.GetAbbreviatedEraName metody. Následující příklad volání těchto metod získat informace o podpoře v EVP GregorianCalendar Třída

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
' The example displays the following output:
'    Date instantiated without an era:
'    1/1/2 in Japanese Calendar -> 1/1/1990 in Gregorian
'    
'    Dates instantiated with eras:
'    1/1/2 era 4 in Japanese Calendar -> 1/1/1990 in Gregorian
'    1/1/2 era 3 in Japanese Calendar -> 1/1/1927 in Gregorian
'    1/1/2 era 2 in Japanese Calendar -> 1/1/1913 in Gregorian
'    1/1/2 era 1 in Japanese Calendar -> 1/1/1869 in Gregorian

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);
      }                        
   }
}
// The example displays the following output:
//    Date instantiated without an era:
//    1/1/2 in Japanese Calendar -> 1/1/1990 in Gregorian
//    
//    Dates instantiated with eras:
//    1/1/2 era 4 in Japanese Calendar -> 1/1/1990 in Gregorian
//    1/1/2 era 3 in Japanese Calendar -> 1/1/1927 in Gregorian
//    1/1/2 era 2 in Japanese Calendar -> 1/1/1913 in Gregorian
//    1/1/2 era 1 in Japanese Calendar -> 1/1/1869 in Gregorian

Kromě toho, "g" vlastní datum a čas formátovat řetězec obsahuje název EVP do kalendáře v řetězcové vyjádření data a času. Další informace naleznete v tématu Vlastní formátovací řetězce data a času.

Data se době konkretizace

Pro dva Calendar tříd, které podporují více Arial, datum, které tvoří konkrétní rok, měsíc a den v měsíci hodnota může být dvojznačný, například Arial všechny čtyři z JapaneseCalendar roky očíslovány od 1 do 15. Obvykle době není-li zadán, datum a čas a kalendář metod se předpokládá, že hodnoty patří do aktuální EVP. EVP explicitně zadat při vytváření instance datum Calendar třídy, který podporuje více Arial můžete volat Calendar.ToDateTime(Int32, Int32, Int32, Int32, Int32, Int32, Int32, Int32) metody. Tato metoda umožňuje určit explicitně EVP spolu se v kalendáři rok, měsíc, den, hodinu, minutu, sekundu a milisekund.

V následujícím příkladu Calendar.ToDateTime(Int32, Int32, Int32, Int32, Int32, Int32, Int32, Int32) Metoda vytváření instancí stejné datum, prvního dne druhého roku v jednotlivých podporovaných EVP první měsíc JapaneseCalendar Třída Potom zobrazí datum v japonštině a gregoriánským kalendářem. Také volání DateTime vytvořit konstruktoru této metody, které hodnoty data bez určení době vytvořte znázornění dat v aktuální věk.

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
' The example displays the following output:
'    Date instantiated without an era:
'    1/1/2 in Japanese Calendar -> 1/1/1990 in Gregorian
'    
'    Dates instantiated with eras:
'    1/1/2 era 4 in Japanese Calendar -> 1/1/1990 in Gregorian
'    1/1/2 era 3 in Japanese Calendar -> 1/1/1927 in Gregorian
'    1/1/2 era 2 in Japanese Calendar -> 1/1/1913 in Gregorian
'    1/1/2 era 1 in Japanese Calendar -> 1/1/1869 in Gregorian

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);
      }                        
   }
}
// The example displays the following output:
//    Date instantiated without an era:
//    1/1/2 in Japanese Calendar -> 1/1/1990 in Gregorian
//    
//    Dates instantiated with eras:
//    1/1/2 era 4 in Japanese Calendar -> 1/1/1990 in Gregorian
//    1/1/2 era 3 in Japanese Calendar -> 1/1/1927 in Gregorian
//    1/1/2 era 2 in Japanese Calendar -> 1/1/1913 in Gregorian
//    1/1/2 era 1 in Japanese Calendar -> 1/1/1869 in Gregorian

Představující data v kalendáři s Arial

Pokud Calendar objekt podporuje Arial a je aktuální kalendář CultureInfo objektu EVP je součástí řetězcové vyjádření hodnota data a času pro úplné datum a čas, dlouhé datum a krátkého vzorky. Následující příklad zobrazí tyto vzorky datum aktuální prostředí Japonsko (japonština) a japonský kalendář je aktuální kalendář.

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

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

Upozornění
TřídyJapaneseCalendar je jedinou třídou kalendáře v.Rozhraní .NET Framework podporuje obě data ve více rizik pro životní prostředí a že může být aktuální kalendář CultureInfo objekt – konkrétně o CultureInfo objektu, který reprezentuje kultury japonština (Japonsko).

Pro všechny kalendáře "g" vlastní formát specifikátor zahrnuje posouzení výsledný řetězec. Následující příklad používá "g MM-dd rrrr" vlastní formát řetězce zahrnout EVP výsledný řetězec po aktuální kalendář gregoriánský kalendář.

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.

   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.

V případech, kde je vyjádřen řetězcové vyjádření datum v kalendáři, který není aktuální kalendář Calendar zahrnuje třída Calendar.GetEra Metoda, která slouží spolu s Calendar.GetYear, Calendar.GetMonth, a Calendar.GetDayOfMonth metod jednoznačně datum, jakož i životní prostředí, k níž patří. V následujícím příkladu JapaneseLunisolarCalendar třídy poskytují obrázku. Uvědomte si ale, že včetně smysluplný název nebo zkratku namísto celé EVP výsledek řetězce vyžaduje, aby konkretizovat DateTimeFormatInfo objekt a proveďte JapaneseCalendar jeho aktuální kalendář. ( JapaneseLunisolarCalendar Kalendář nemůže být aktuální kalendář všechny kultury, ale v tomto případě dva kalendáře sdílet stejné Arial.)

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

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

Viz také

Úkoly

Postupy: Zobrazení dat v jiných než gregoriánských kalendářích

Historie změn

Datum	Poslední dokumenty	Důvod
Září 2010	Rozsáhlé revidován.	Rozšíření informace

Září 2010

Rozsáhlé revidován.

Rozšíření informace

Sdílet prostřednictvím