Takvimlerle çalışma

Makale
03/13/2024

Tarih ve saat değeri zaman içinde bir anı gösterse de, dize gösterimi kültüre duyarlıdır ve hem belirli bir kültür saat tarafından saat ve tarih değerlerini görüntülemek için kullanılan kurallara, hem de kültür tarafından kullanılan takvime dayalıdır. Bu konu, .NET'teki takvimler için desteği inceler ve tarih değerleriyle çalışırken takvim sınıflarının kullanımını ele alır.

.NET'te takvimler

.NET'teki tüm takvimler, temel takvim uygulamasını sağlayan sınıfından türetilir System.Globalization.Calendar . sınıfından devralan sınıflardan Calendar EastAsianLunisolarCalendar biri, tüm lunisolar takvimler için temel sınıf olan sınıfıdır. .NET aşağıdaki takvim uygulamalarını içerir:

ChineseLunisolarCalendar, Çince lunisolar takvimini temsil eder.
GregorianCalendar, Gregoryen takvimi temsil eder. Bu takvim, numaralandırma tarafından System.Globalization.GregorianCalendarTypes tanımlanan alt türlere (Arapça ve Orta Doğu Fransızcası gibi) daha da bölünür. özelliği Gregoryen GregorianCalendar.CalendarType takvimin alt türünü belirtir.
HebrewCalendar, İbranice takvimi temsil eder.
HijriCalendar, Hicri takvimi temsil eder.
JapaneseCalendar, Japon takvimini temsil eder.
JapaneseLunisolarCalendar, Japon lunisolar takvimini temsil eder.
JulianCalendar, Jülyen takvimini temsil eder.
KoreanCalendar, Kore takvimini temsil eder.
KoreanLunisolarCalendar, Kore lunisolar takvimini temsil eder.
PersianCalendar, Farsça takvimi temsil eder.
TaiwanCalendar, Tayvan takvimini temsil eder.
TaiwanLunisolarCalendar, Tayvan lunisolar takvimini temsil eder.
ThaiBuddhistCalendar, Tayland Budist takvimini temsil eder.
UmAlQuraCalendar, Um Al Qura takvimini temsil eder.

Bir takvim iki şekilde kullanılabilir:

Belirli bir kültür tarafından kullanılan takvim olarak. Her CultureInfo nesnenin geçerli bir takvimi vardır ve bu, nesnenin şu anda kullandığı takvimdir. Tüm tarih ve saat değerlerinin dize gösterimleri, otomatik olarak geçerli kültürü ve onun geçerli takvimini yansıtır. Genellikle, geçerli takvim kültürün varsayılan takvimidir. CultureInfo nesneleri, kültürün kullanabileceği ek takvimler içeren isteğe bağlı takvimlere de sahiptir.
Belirli bir takvimden bağımsız tek başına bir takvim olarak. Bu durumda, Calendar tarihleri takvimi yansıtan değerler olarak ifade etmek için yöntemler kullanılır.

Altı takvim sınıfı ( ChineseLunisolarCalendar, JapaneseLunisolarCalendar, JulianCalendar, , KoreanLunisolarCalendar, PersianCalendarve TaiwanLunisolarCalendar – yalnızca tek başına takvimler olarak kullanılabilir. Herhangi bir kültür tarafından varsayılan takvim olarak veya isteğe bağlı bir takvim olarak kullanılmazlar.

Takvimler ve kültürler

Her kültürün özelliği tarafından CultureInfo.Calendar tanımlanan varsayılan bir takvimi vardır. özelliği, CultureInfo.OptionalCalendars söz konusu kültürün Calendar varsayılan takvimi de dahil olmak üzere belirli bir kültür tarafından desteklenen tüm takvimleri belirten bir nesne dizisi döndürür.

Aşağıdaki örnekte ve CultureInfo.OptionalCalendars özellikleri gösterilmektedirCultureInfo.Calendar. Tay dili (Tayland) ve Japonca (Japonya) kültürleri için nesneler oluşturur CultureInfo ve varsayılan ve isteğe bağlı takvimlerini görüntüler. Her iki durumda da kültürün varsayılan takviminin de koleksiyona CultureInfo.OptionalCalendars dahil olduğunu unutmayın.

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)

Belirli CultureInfo bir nesne tarafından kullanılmakta olan takvim, kültürün DateTimeFormatInfo.Calendar özelliği tarafından tanımlanır. Bir kültürün DateTimeFormatInfo nesnesi özelliği tarafından CultureInfo.DateTimeFormat döndürülür. Bir kültür oluşturulduğunda, varsayılan değeri özelliğin değeriyle CultureInfo.Calendar aynıdır. Ancak, kültürün geçerli takvimini özelliği tarafından döndürülen dizide yer alan herhangi bir takvimle CultureInfo.OptionalCalendars değiştirebilirsiniz. Geçerli takvimi özellik değerine dahil olmayan bir takvime ayarlamaya CultureInfo.OptionalCalendars çalışırsanız, bir ArgumentException oluşturulur.

Aşağıdaki örnekte, Arap (Suudi Arabistan) kültürü tarafından kullanılan takvim değiştirilmektedir. İlk olarak bir DateTime değerin örneğini oluşturur ve geçerli kültürü (bu örnekte İngilizce (Birleşik Devletler) ve geçerli kültürün takvimini (bu örnekte Gregoryen takvimdir) kullanarak görüntüler. Ardından, geçerli kültürü Arapça (Suudi Arabistan) olacak şekilde değiştirir ve kendi varsayılan Ümmül Kura takvimini kullanarak tarihi görüntüler. Ardından Hicri takvimin CalendarExists Arapça (Suudi Arabistan) kültürü tarafından desteklenip desteklenmediğini belirlemek için yöntemini çağırır. Takvim desteklendiğinden, geçerli takvimi Hicri olacak şekilde değiştirir ve yine tarihi görüntüler. Her bir durumda, tarih geçerli kültürün geçerli takvimi kullanılarak görüntülenir.

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

Tarihler ve takvimler

Tür Calendar parametresi içeren ve tarih öğelerinin (ay, gün ve yıl) belirlenen takvimdeki değerleri yansıtmasına izin veren oluşturucular dışında, hem hem DateTimeOffset de DateTime değerler her zaman Gregoryen takvimi temel alır. Bu, örneğin özelliğin DateTime.Year Gregoryen takvimdeki yılı döndürdüğü ve özelliğin DateTime.Day Gregoryen takvimde ayın gününü döndürdüğü anlamına gelir.

Önemli

Bir tarih değeri ile onun dize gösterimi arasında bir fark olduğunu unutmamak önemlidir. İlki Gregoryen takvime dayalıdır; ikincisi ise belirli bir kültürün geçerli takvimine dayalıdır.

Aşağıdaki örnekte, özellikler ve bunlara karşılık gelen Calendar yöntemler arasındaki DateTime bu fark gösterilmektedir. Örnekte, geçerli kültür Arapça (Mısır) ve geçerli Takvim Ümmül Kura'dır. Değer DateTime , 2011'in yedinci ayının on beşinci gününe ayarlanır. Sabit kültürün kurallarını kullandığında yöntemi tarafından DateTime.ToString(String, IFormatProvider) aynı değerler döndürülür çünkü bunun Gregoryen tarih olarak yorumlandığı açıktır. Geçerli kültürün kuralları kullanılarak biçimlendirilen tarihin dize gösterimi, Ümmül Kura takvimindeki denk tarih olan 14/08/32'dir. Ardından, ve Calendar üyeleri DateTime değerin gününü, ayını ve yılını döndürmek DateTime için kullanılır. Her durumda, üyeler tarafından DateTime döndürülen değerler Gregoryen takvimdeki değerleri yansıtırken, üyeler tarafından UmAlQuraCalendar döndürülen değerler Uum al-Qura takvimindeki değerleri yansıtır.

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

Takvime göre tarih örneği oluşturma

DateTime Ve DateTimeOffset değerleri Gregoryen takvimi temel aldığı için, farklı bir takvimdeki gün, ay veya yıl değerlerini kullanmak istiyorsanız tarih değerinin örneğini oluşturmak için tür Calendar parametresini içeren aşırı yüklenmiş bir oluşturucu çağırmalısınız. Bir nesneyi belirli bir takvimin değerlerine göre örneklemek için belirli bir DateTime takvimin Calendar.ToDateTime yönteminin aşırı yüklemelerinden birini de çağırabilirsiniz.

Aşağıdaki örnek, bir nesneyi oluşturucuya geçirerek bir DateTime HebrewCalendar değerin örneğini DateTime oluşturur ve yöntemini çağırarak ikinci DateTime bir değerin örneğini HebrewCalendar.ToDateTime(Int32, Int32, Int32, Int32, Int32, Int32, Int32, Int32) oluşturur. İki değer İbranice takvimden aynı değerlerle oluşturulduğundan, yöntemine DateTime.Equals yapılan çağrı iki DateTime değerin eşit olduğunu gösterir.

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

Geçerli takvimdeki tarihleri temsil eder

Tarih ve saat biçimlendirme yöntemleri, tarihleri dizelere dönüştürürken her zaman geçerli takvimi kullanır. Bu, yılın, ayın ve ayın gününün dize gösteriminin geçerli takvimi yansıttığı ve Gregoryen takvimini yansıtmasının gerekli olmadığı anlamına gelir.

Aşağıdaki örnek, geçerli takvimin bir tarihin dize gösterimini nasıl etkilediğini göstermektedir. Geçerli kültürü Çince (Geleneksel, Tayvan) olarak değiştirir ve bir tarih değerini örnekler. Ardından geçerli takvimi ve tarihi görüntüler, geçerli takvimi olarak TaiwanCalendardeğiştirir ve geçerli takvimi ve tarihi bir kez daha görüntüler. Tarih ilk kez görüntülendiğinde, Gregoryen takvimdeki bir tarih olarak gösterilir. İkinci kez görüntülendiğinde, Tayvan takvimindeki bir tarih olarak gösterilir.

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

Geçerli olmayan takvimde tarihleri temsil eder

Belirli bir kültürün geçerli takvimi olmayan bir takvimi kullanarak tarihi temsil etmek için, bu Calendar nesnenin yöntemlerini çağırmanız gerekir. Örneğin, Calendar.GetYear, Calendar.GetMonthve Calendar.GetDayOfMonth yöntemleri yıl, ay ve günü belirli bir takvimi yansıtan değerlere dönüştürür.

Uyarı

Bazı takvimler herhangi kültürün isteğe bağlı takvimleri olmadığından, bu takvimlerde tarihleri göstermek, her zaman takvim yöntemlerini çağırmanızı gerektirir. Bu, , JulianCalendarve PersianCalendar sınıflarından EastAsianLunisolarCalendartüretilen tüm takvimler için geçerlidir.

Aşağıdaki örnek, Jülyen takviminde 9 Ocak 1905 tarihi örneği oluşturmak için bir nesnesi kullanır JulianCalendar . Bu tarih varsayılan (Gregoryen) takvimi kullanılarak görüntülendiğinde, 22 Ocak 1905 olarak gösterilir. Tek tek JulianCalendar yöntemlere yapılan çağrılar, tarihin Jülyen takviminde gösterilmesini sağlar.

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

Takvimler ve tarih aralıkları

Bir takvim tarafından desteklenen en erken tarih, bu takvimin Calendar.MinSupportedDateTime özelliğiyle gösterilir. GregorianCalendar Sınıf için bu tarih 1 Ocak 0001 C.E. .NET'teki diğer takvimlerin çoğu sonraki bir tarihi destekler. Takvimin desteklenen en erken tarihinden önce gelen bir tarih ve saat değeriyle çalışmaya çalışmak bir ArgumentOutOfRangeException özel durum oluşturur.

Ancak, önemli bir istisna vardır. Bir nesnenin ve DateTimeOffset nesnenin DateTime varsayılan (başlatılmamış) değeri değere GregorianCalendar.MinSupportedDateTime eşittir. Bu tarihi 1 Ocak 0001 C.E.'yi desteklemeyen bir takvimde biçimlendirmeye çalışırsanız ve biçim tanımlayıcısı sağlamazsanız, biçimlendirme yöntemi "G" (genel tarih/saat deseni) biçim tanımlayıcısı yerine "s" (sıralanabilir tarih/saat deseni) biçim belirticisini kullanır. Sonuç olarak, biçimlendirme işlemi bir ArgumentOutOfRangeException özel durum oluşturmaz. Bunun yerine, desteklenmeyen tarihi döndürür. Bu, geçerli kültürün DateTime.MinValue Japon takvimiyle Japonca (Japonya) ve Um Al Qura takvimiyle Arapça (Mısır) olarak ayarlandığını gösteren aşağıdaki örnekte gösterilmiştir. Ayrıca geçerli kültürü İngilizce (Birleşik Devletler) olarak ayarlar ve bu CultureInfo nesnelerin her biriyle yöntemini çağırırDateTime.ToString(IFormatProvider). Her durumda, tarih sıralanabilir tarih/saat deseni kullanılarak görüntülenir.

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

Çağlarla çalışma

Takvimler genellikle tarihleri dönemlere ayırır. Ancak, Calendar .NET'teki sınıflar bir takvim tarafından tanımlanan her dönemi desteklemez ve sınıfların Calendar çoğu yalnızca tek bir dönemi destekler. JapaneseCalendar Yalnızca ve JapaneseLunisolarCalendar sınıfları birden çok dönemi destekler.

Önemli

ve JapaneseLunisolarCalendariçinde JapaneseCalendar yeni bir çağ olan Reiwa çağı 1 Mayıs 2019'da başlar. Bu değişiklik, bu takvimleri kullanan tüm uygulamaları etkiler. Daha fazla bilgi için aşağıdaki makalelere bakın:

.NET'te Japon takviminde yeni bir çağı işleme; birden çok çağa sahip takvimleri desteklemek için .NET'e eklenen özellikleri belgeler ve çok dönemli takvimleri işlerken kullanılacak en iyi yöntemleri açıklar.
Uygulamanızı, dönem değişikliğine hazır olduğundan emin olmak için Uygulamalarınızı Windows'ta test etme hakkında bilgi sağlayan Japon dönemi değişikliğine hazırlayın.
Yeni Japon takvim dönemiyle ilgili tek tek Windows sürümleri için .NET Framework güncelleştirmelerini listeleyen, çok dönemli destek için yeni .NET Framework özelliklerini not alan ve uygulamalarınızı test etmek için aranacak öğeleri içeren .NET Framework için yeni Japon Çağı güncelleştirmelerinin özeti.

Çoğu takvimdeki bir dönem, son derece uzun bir süreyi belirtir. Örneğin Gregoryen takvimde, geçerli dönem iki bin yıldan uzun bir süreye yayılmaktadır. JapaneseCalendar ve JapaneseLunisolarCalendariçin, birden çok dönemi destekleyen iki takvim için bu durum geçerli değildir. Bir çağ, bir imparatorun saltanatı dönemine karşılık gelir. Özellikle mevcut çağın üst sınırı bilinmediğinde birden çok çağa yönelik destek, özel zorluklar doğuran bir durumdur.

Çağlar ve dönem adları

.NET'te, belirli bir takvim uygulaması tarafından desteklenen dönemleri temsil eden tamsayılar dizide Calendar.Eras ters sırada depolanır. Geçerli dönem (en son zaman aralığına sahip olan dönem) dizin sıfırdadır ve birden çok dönemi destekleyen sınıflar için Calendar ardışık her dizin önceki dönemi yansıtır. statik Calendar.CurrentEra özelliği, dizideki Calendar.Eras geçerli dönemin dizinini tanımlar; değeri her zaman sıfır olan bir sabittir. Tek tek Calendar sınıflar, geçerli dönemin değerini döndüren statik alanlar da içerir. Bunlar aşağıdaki tabloda listelenmiştir.

Takvim sınıfı	Geçerli dönem alanı
ChineseLunisolarCalendar	ChineseEra
GregorianCalendar	ADEra
HebrewCalendar	HebrewEra
HijriCalendar	HijriEra
JapaneseLunisolarCalendar	JapaneseEra
JulianCalendar	JulianEra
KoreanCalendar	KoreanEra
KoreanLunisolarCalendar	GregorianEra
PersianCalendar	PersianEra
ThaiBuddhistCalendar	ThaiBuddhistEra
UmAlQuraCalendar	UmAlQuraEra

Belirli bir dönem numarasına karşılık gelen ad, veya yöntemine DateTimeFormatInfo.GetEraName DateTimeFormatInfo.GetAbbreviatedEraName dönem numarası geçirilerek alınabilir. Aşağıdaki örnek, sınıfındaki GregorianCalendar çağ desteği hakkında bilgi almak için bu yöntemleri çağırır. Geçerli dönemin ikinci yılında 1 Ocak'a karşılık gelen Gregoryen takvim tarihini ve desteklenen her Japon takvim döneminin ikinci yılının 1 Ocak'ını gösteren Gregoryen takvim tarihini görüntüler.

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

Ek olarak, "g" özel tarih ve saat biçimi dizisi, bir tarih ve saatin dize gösteriminde bir takvimin dönem adını içerir. Daha fazla bilgi için bkz . Özel tarih ve saat biçimi dizeleri.

Bir çağ ile tarih örneği oluşturma

Birden çok dönemi destekleyen iki Calendar sınıf için belirli bir yıl, ay ve ayın gününden oluşan bir tarih belirsiz olabilir. Örneğin, tarafından JapaneseCalendar desteklenen tüm çağların sayısı 1 olan yıllar vardır. Normalde, bir dönem belirtilmezse, tarih ve saat ve takvim yöntemleri değerlerin geçerli döneme ait olduğunu varsayar. Bu, türündeki parametrelerin yanı sıra JapaneseCalendar.ToDateTime ve JapaneseLunisolarCalendar.ToDateTime yöntemlerini içeren ve DateTimeOffset oluşturucuları için geçerlidirDateTime.Calendar Aşağıdaki örnek, belirtilmemiş bir dönemin ikinci yılının 1 Ocak'ını temsil eden bir tarih örneği oluşturur. Reiwa dönemi geçerli dönem olduğunda örneği yürütürseniz, tarih Reiwa döneminin ikinci yılı olarak yorumlanır. 令和 dönemi, yöntemi tarafından döndürülen dizede yıl öncesini DateTime.ToString(String, IFormatProvider) gösterir ve Gregoryen takvimde 1 Ocak 2020'ye karşılık gelir. (Reiwa dönemi Gregoryen takvimin 2019 yılında başlar.)

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

Ancak, çağ değişirse, bu kodun amacı belirsiz hale gelir. Tarih, mevcut çağın ikinci yılını mı temsil etmek için, yoksa Heisei döneminin ikinci yılını mı temsil etmek için tasarlanmıştır? Bu belirsizliği önlemenin iki yolu vardır:

Varsayılan GregorianCalendar sınıfı kullanarak tarih ve saat değerinin örneğini oluşturma. Ardından, aşağıdaki örnekte gösterildiği gibi tarihlerin dize gösterimi için Japon takvimini veya Japon Lunisolar takvimini kullanabilirsiniz.

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

Bir dönemi açıkça belirten bir tarih ve saat yöntemini çağır. Bu, aşağıdaki yöntemleri içerir:

ToDateTime(Int32, Int32, Int32, Int32, Int32, Int32, Int32, Int32) veya JapaneseLunisolarCalendar sınıfının yöntemiJapaneseCalendar.
DateTime Ayrıştırılacak dizeyi içeren , , ParseExactveya TryParseExactgibi Parse TryParsebir veya DateTimeOffset ayrıştırma yöntemi ve geçerli kültür Japonca-Japonya ("ja-JP") ise ve bu kültürün takvimi ise isteğe bağlı olarak bir DateTimeStyles bağımsız değişkendirJapaneseCalendar. Ayrıştırılacak dizenin dönemi içermesi gerekir.
DateTime türünde IFormatProviderbir parametre içeren bir provider veya DateTimeOffset ayrıştırma yöntemi. providergeçerli takvimi JapaneseCalendar olan Japon-Japonya ("ja-JP") kültürünü temsil eden bir nesne veya özelliği JapaneseCalendarolan Calendar bir DateTimeFormatInfo nesne olmalıdırCultureInfo. Ayrıştırılacak dizenin dönemi içermesi gerekir.

Aşağıdaki örnekte, 8 Eylül 1868'de başlayan ve 29 Temmuz 1912'de sona eren Meiji döneminde tarih ve saatin örneğini oluşturmak için bu yöntemlerden üçünü kullanır.

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)

İpucu

Birden çok dönemi destekleyen takvimlerle çalışırken, bir tarihin örneğini oluşturmak için her zaman Gregoryen tarihi kullanın veya bu takvime göre bir tarih ve saat örneği oluşturduğunuz dönemi belirtin.

yöntemine ToDateTime(Int32, Int32, Int32, Int32, Int32, Int32, Int32, Int32) bir çağ belirtirken, takvimin Eras özelliğinde dönemin dizinini sağlarsınız. Ancak, dönemleri değişikliğe tabi olan takvimler için bu dizinler sabit değerler değildir; geçerli dönem 0 dizininde, en eski dönem ise dizinindedir Eras.Length - 1. Takvime yeni bir dönem eklendiğinde, önceki dönemlerin dizinleri bir artar. Uygun dönem dizinini aşağıdaki gibi sağlayabilirsiniz:

Geçerli dönemdeki tarihler için her zaman takvimin CurrentEra özelliğini kullanın.
Belirtilen bir dönemdeki tarihler için yöntemini kullanarak DateTimeFormatInfo.GetEraName belirtilen dönem adına karşılık gelen dizini alın. Bunun için ja-JP kültürünü temsil eden nesnenin CultureInfo geçerli takvimi olması gerekirJapaneseCalendar. (Bu teknik, ile aynı dönemleri JapaneseCalendardesteklediğinden JapaneseLunisolarCalendar için için de çalışır.) Önceki örnekte bu yaklaşım gösterilmektedir.

Takvimler, dönemler ve tarih aralıkları: Gevşek aralık denetimleri

Tek tek takvimlerin desteklenen tarih aralıklarına sahip olması gibi, ve JapaneseLunisolarCalendar sınıflarındaki JapaneseCalendar dönemler de desteklenen aralıklara sahiptir. Daha önce .NET, döneme özgü bir tarihin o dönemin aralığında olduğundan emin olmak için katı dönem aralığı denetimleri kullanıyordu. Yani, bir tarih belirtilen dönemin aralığının dışındaysa, yöntemi bir ArgumentOutOfRangeExceptionoluşturur. Şu anda .NET varsayılan olarak gevşek aralıklı denetim kullanmaktadır. .NET'in tüm sürümlerine Güncelleştirmeler gevşek dönem aralığı denetimleri eklendi; belirtilen dönem aralığının dışında bir tarih örneği oluşturma girişimi aşağıdaki çağa "taşıyor" ve hiçbir özel durum oluşturmaz.

Aşağıdaki örnek, 25 Aralık 1926'da başlayan ve 7 Ocak 1989'da sona eren Showa döneminin 65. yılında bir tarih örneği oluşturmayı dener. Bu tarih, içindeki Showa dönemi aralığının dışında olan 9 Ocak 1990'a JapaneseCalendarkarşılık gelir. Örneğin çıktısında gösterildiği gibi, örnek tarafından görüntülenen tarih Heisei döneminin ikinci yılında 9 Ocak 1990'dır.

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

Gevşek aralık denetimleri istenmeyen bir durumsa, uygulamanızın üzerinde çalıştığı .NET sürümüne bağlı olarak çeşitli yollarla katı aralık denetimlerini geri yükleyebilirsiniz:

.NET Core: .netcore.runtime.json yapılandırma dosyasına aşağıdakileri ekleyin:

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

.NET Framework 4.6 veya üzeri: app.config dosyasında aşağıdaki AppContext anahtarını ayarlayın:

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

.NET Framework 4.5.2 veya öncesi: Aşağıdaki kayıt defteri değerini ayarlayın:

Değer

Anahtar HKEY_LOCAL_MACHINE\Software\Microsoft\. NETFramework\AppContext

Girdi Switch.System.Globalization.EnforceJapaneseEraYearRanges

Tür REG_SZ

Value true

	Değer
Anahtar	HKEY_LOCAL_MACHINE\Software\Microsoft\. NETFramework\AppContext
Girdi	Switch.System.Globalization.EnforceJapaneseEraYearRanges
Tür	REG_SZ
Value	true

Katı aralık denetimleri etkinleştirildiğinde, önceki örnek bir ArgumentOutOfRangeException oluşturur ve aşağıdaki çıkışı görüntüler:

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

Birden çok dönemi olan takvimlerdeki tarihleri temsil eder

Bir Calendar nesne dönemleri destekliyorsa ve bir CultureInfo nesnenin geçerli takvimiyse, tam tarih ve saat, uzun tarih ve kısa tarih desenleri için tarih ve saat değerinin dize gösterimine çağ eklenir. Aşağıdaki örnekte, geçerli kültür Japonya (Japonca) ve geçerli takvim Japon takvimi olduğunda bu tarih desenleri görüntülenmektedir.

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

Uyarı

sınıfı JapaneseCalendar , .NET'te hem birden fazla çağdaki tarihleri destekleyen hem de bir CultureInfo nesnenin (özellikle de Japonca (Japonya) kültürünü temsil eden bir CultureInfo nesnenin geçerli takvimi olabilecek tek takvim sınıfıdır.

Tüm takvimler için, "g" özel biçim belirleyicisi, sonuç dizesinde dönemi içerir. Aşağıdaki örnekte, geçerli takvim Gregoryen takvim olduğunda dönemi sonuç dizesine eklemek için "AA-gg-yyyy g" özel biçimi kullanılmaktadı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.

Bir tarihin dize gösteriminin geçerli takvim olmayan bir takvimde ifade edildiği durumlarda, Calendar sınıfı, bir tarihi ve ait olduğu dönemi açıkça belirtmek için , Calendar.GetMonthve Calendar.GetDayOfMonth yöntemleriyle Calendar.GetYearbirlikte kullanılabilecek bir yöntem içerirCalendar.GetEra. Aşağıdaki örnek, bir çizim sağlamak için sınıfını JapaneseLunisolarCalendar kullanır. Ancak, sonuç dizesinde çağ için tamsayı yerine anlamlı bir ad veya kısaltma eklemenin bir DateTimeFormatInfo nesne örneği oluşturmanızı ve geçerli takvimini oluşturmanızı JapaneseCalendar gerektirdiğini unutmayın. (Takvim JapaneseLunisolarCalendar herhangi bir kültürün geçerli takvimi olamaz, ancak bu durumda iki takvim aynı dönemleri paylaşır.)

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

Japon takvimlerinde bir çağın ilk yılı Gannen (元年) olarak adlandırılır. Örneğin Heisei 1 yerine Heisei çağının ilk yılı Heisei Gannen olarak tanımlanabilir. .NET, sınıfıyla Japon-Japonya ("ja-JP") kültürünü JapaneseCalendar temsil eden bir CultureInfo nesneyle kullanıldığında, aşağıdaki standart veya özel tarih ve saat biçim dizeleriyle biçimlendirilmiş tarih ve saat biçimlendirme işlemlerinde bu kuralı benimser:

Örneğin, aşağıdaki örnekte heisei döneminin ilk yılındaki JapaneseCalendarbir tarih görüntülenir.

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)

Biçimlendirme işlemlerinde bu davranış istenmeyen bir davranışsa, .NET sürümüne bağlı olarak aşağıdakileri yaparak bir çağın ilk yılını her zaman "Gannen" yerine "1" olarak temsil eden önceki davranışı geri yükleyebilirsiniz:

.NET Core: .netcore.runtime.json yapılandırma dosyasına aşağıdakileri ekleyin:

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

.NET Framework 4.6 veya üzeri: app.config dosyasında aşağıdaki AppContext anahtarını ayarlayın:

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

.NET Framework 4.5.2 veya öncesi: Aşağıdaki kayıt defteri değerini ayarlayın:

Değer

Anahtar HKEY_LOCAL_MACHINE\Software\Microsoft\. NETFramework\AppContext

Girdi Switch.System.Globalization.FormatJapaneseFirstYearAsANumber

Tür REG_SZ

Value true

	Değer
Anahtar	HKEY_LOCAL_MACHINE\Software\Microsoft\. NETFramework\AppContext
Girdi	Switch.System.Globalization.FormatJapaneseFirstYearAsANumber
Tür	REG_SZ
Value	true

Biçimlendirme işlemlerinde gannen desteği devre dışı bırakılmıştır, önceki örnekte aşağıdaki çıkış görüntülenir:

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

.NET ayrıca tarih ve saat ayrıştırma işlemlerinin "1" veya Gannen olarak temsil edilen yılı içeren dizeleri desteklemesi için güncelleştirildi. Bunu yapmanız gerekmese de, bir çağın ilk yılı olarak yalnızca "1" öğesini tanımak için önceki davranışı geri yükleyebilirsiniz. .NET sürümüne bağlı olarak bunu aşağıdaki gibi yapabilirsiniz:

.NET Core: .netcore.runtime.json yapılandırma dosyasına aşağıdakileri ekleyin:

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

.NET Framework 4.6 veya üzeri: app.config dosyasında aşağıdaki AppContext anahtarını ayarlayın:

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

.NET Framework 4.5.2 veya öncesi: Aşağıdaki kayıt defteri değerini ayarlayın:

Değer

Anahtar HKEY_LOCAL_MACHINE\Software\Microsoft\. NETFramework\AppContext

Girdi Switch.System.Globalization.EnforceLegacyJapaneseDateParsing

Tür REG_SZ

Value true

Aracılığıyla paylaş

Takvimlerle çalışma

.NET'te takvimler

Takvimler ve kültürler

Tarihler ve takvimler

Takvime göre tarih örneği oluşturma

Geçerli takvimdeki tarihleri temsil eder

Geçerli olmayan takvimde tarihleri temsil eder

Takvimler ve tarih aralıkları

Çağlarla çalışma

Çağlar ve dönem adları

Bir çağ ile tarih örneği oluşturma

Takvimler, dönemler ve tarih aralıkları: Gevşek aralık denetimleri

Birden çok dönemi olan takvimlerdeki tarihleri temsil eder

Ayrıca bkz.

Ek kaynaklar