Aracılığıyla paylaş

Takvimlerle çalışma

Tarih ve saat değeri zaman içindeki bir anı temsil etmesine rağmen, dize gösterimi kültüre duyarlıdır ve hem belirli bir kültür tarafından tarih ve saat değerlerini görüntülemek için kullanılan kurallar hem de bu kültür tarafından kullanılan takvime bağlı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 . Calendar sınıfından devralan sınıflardan biri, tüm lunisolar takvimler için temel sınıf olan EastAsianLunisolarCalendar sınıfıdır. .NET aşağıdaki takvim uygulamalarını içerir:

Takvim iki yoldan biriyle 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 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 kültürden bağımsız tek başına 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 veya isteğe bağlı takvim olarak kullanılmazlar.

Takvimler ve kültürler

Her kültürün, CultureInfo.Calendar özelliği tarafından tanımlanan bir varsayılan 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 örnek, CultureInfo.Calendar ve CultureInfo.OptionalCalendars özelliklerini göstermektedir. Tay (Tayland) ve Japon (Japonya) kültürleri için CultureInfo nesneler oluşturur ve varsayılan ile 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 {ci.Name} culture:");

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

      if (defaultCalendar is GregorianCalendar)
         Console.WriteLine($" ({((GregorianCalendar) defaultCalendar).CalendarType})");
      else
         Console.WriteLine();

      // Get the culture's optional calendars.
      Console.WriteLine("   Optional Calendars:");
      foreach (var optionalCalendar in ci.OptionalCalendars) {
         Console.Write("{0,6}{1}", "", GetCalendarName(optionalCalendar));
         if (optionalCalendar is GregorianCalendar)
            Console.Write(" ({0})",
                          ((GregorianCalendar) optionalCalendar).CalendarType);

         Console.WriteLine();
      }
      Console.WriteLine();
   }

   static string GetCalendarName(Calendar cal)
   {
      return cal.ToString().Replace("System.Globalization.", "");
   }
}
// The example displays the following output:
//       Calendars for the th-TH culture:
//          Default Calendar: ThaiBuddhistCalendar
//          Optional Calendars:
//             ThaiBuddhistCalendar
//             GregorianCalendar (Localized)
//
//       Calendars for the ja-JP culture:
//          Default Calendar: GregorianCalendar (Localized)
//          Optional Calendars:
//             GregorianCalendar (Localized)
//             JapaneseCalendar
//             GregorianCalendar (USEnglish)

Imports System.Globalization

Public Module Example
    Public Sub Main()
        ' Create a CultureInfo for Thai in Thailand.
        Dim th As CultureInfo = CultureInfo.CreateSpecificCulture("th-TH")
        DisplayCalendars(th)

        ' Create a CultureInfo for Japanese in Japan.
        Dim ja As CultureInfo = CultureInfo.CreateSpecificCulture("ja-JP")
        DisplayCalendars(ja)
    End Sub

    Sub DisplayCalendars(ci As CultureInfo)
        Console.WriteLine("Calendars for the {0} culture:", ci.Name)

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

        If TypeOf defaultCalendar Is GregorianCalendar Then
            Console.WriteLine(" ({0})",
                              CType(defaultCalendar, GregorianCalendar).CalendarType)
        Else
            Console.WriteLine()
        End If

        ' Get the culture's optional calendars.
        Console.WriteLine("   Optional Calendars:")
        For Each optionalCalendar In ci.OptionalCalendars
            Console.Write("{0,6}{1}", "", GetCalendarName(optionalCalendar))
            If TypeOf optionalCalendar Is GregorianCalendar Then
                Console.Write(" ({0})",
                              CType(optionalCalendar, GregorianCalendar).CalendarType)
            End If
            Console.WriteLine()
        Next
        Console.WriteLine()
    End Sub

    Function GetCalendarName(cal As Calendar) As String
        Return cal.ToString().Replace("System.Globalization.", "")
    End Function
End Module
' The example displays the following output:
'       Calendars for the th-TH culture:
'          Default Calendar: ThaiBuddhistCalendar
'          Optional Calendars:
'             ThaiBuddhistCalendar
'             GregorianCalendar (Localized)
'       
'       Calendars for the ja-JP culture:
'          Default Calendar: GregorianCalendar (Localized)
'          Optional Calendars:
'             GregorianCalendar (Localized)
'             JapaneseCalendar
'             GregorianCalendar (USEnglish)

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, CultureInfo.DateTimeFormat özelliği tarafından döndürülür. Bir kültür tanımlandığında, varsayılan değeri, CultureInfo.Calendar özelliğinin değeriyle aynıdır. Ancak, kültürün mevcut takvimini, CultureInfo.OptionalCalendars özelliği tarafından döndürülen dizide bulunan herhangi bir takvimle değiştirebilirsiniz. Geçerli takvimi CultureInfo.OptionalCalendars özelliği değerine dahil olmayan bir takvime ayarlamaya çalışırsanız, bir ArgumentException hatası oluşturulur.

Aşağıdaki örnek, Arapça (Suudi Arabistan) kültürü tarafından kullanılan takvimi değiştirir. İlk olarak bir DateTime değerin örneğini oluşturur ve geçerli kültürü (bu örnekte İngilizce (ABD) ve geçerli kültürün takvimini (bu örnekte Gregoryen takvimi) kullanarak görüntüler. Ardından, geçerli kültürü Arapça (Suudi Arabistan) olarak değiştirir ve varsayılan Um Al-Qura 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 olarak değiştirir ve tarihi yeniden görüntüler. Her durumda, tarihin geçerli kültürün geçerli takvimi kullanılarak görüntülendiğini unutmayın.

using System;
using System.Globalization;
using System.Threading;

public class Example
{
   public static void Main()
   {
      DateTime date1 = new DateTime(2011, 6, 20);

      DisplayCurrentInfo();
      // Display the date using the current culture and calendar.
      Console.WriteLine(date1.ToString("d"));
      Console.WriteLine();

      CultureInfo arSA = CultureInfo.CreateSpecificCulture("ar-SA");

      // Change the current culture to Arabic (Saudi Arabia).
      Thread.CurrentThread.CurrentCulture = arSA;
      // Display date and information about the current culture.
      DisplayCurrentInfo();
      Console.WriteLine(date1.ToString("d"));
      Console.WriteLine();

      // Change the calendar to Hijri.
      Calendar hijri = new HijriCalendar();
      if (CalendarExists(arSA, hijri)) {
         arSA.DateTimeFormat.Calendar = hijri;
         // Display date and information about the current culture.
         DisplayCurrentInfo();
         Console.WriteLine(date1.ToString("d"));
      }
   }

   private static void DisplayCurrentInfo()
   {
      Console.WriteLine($"Current Culture: {CultureInfo.CurrentCulture.Name}");
      Console.WriteLine($"Current Calendar: {DateTimeFormatInfo.CurrentInfo.Calendar}");
   }

   private static bool CalendarExists(CultureInfo culture, Calendar cal)
   {
      foreach (Calendar optionalCalendar in culture.OptionalCalendars)
         if (cal.ToString().Equals(optionalCalendar.ToString()))
            return true;

      return false;
   }
}
// The example displays the following output:
//    Current Culture: en-US
//    Current Calendar: System.Globalization.GregorianCalendar
//    6/20/2011
//
//    Current Culture: ar-SA
//    Current Calendar: System.Globalization.UmAlQuraCalendar
//    18/07/32
//
//    Current Culture: ar-SA
//    Current Calendar: System.Globalization.HijriCalendar
//    19/07/32

Imports System.Globalization
Imports System.Threading

Module Example
    Public Sub Main()
        Dim date1 As Date = #6/20/2011#

        DisplayCurrentInfo()
        ' Display the date using the current culture and calendar.
        Console.WriteLine(date1.ToString("d"))
        Console.WriteLine()

        Dim arSA As CultureInfo = CultureInfo.CreateSpecificCulture("ar-SA")

        ' Change the current culture to Arabic (Saudi Arabia).
        Thread.CurrentThread.CurrentCulture = arSA
        ' Display date and information about the current culture.
        DisplayCurrentInfo()
        Console.WriteLine(date1.ToString("d"))
        Console.WriteLine()

        ' Change the calendar to Hijri.
        Dim hijri As Calendar = New HijriCalendar()
        If CalendarExists(arSA, hijri) Then
            arSA.DateTimeFormat.Calendar = hijri
            ' Display date and information about the current culture.
            DisplayCurrentInfo()
            Console.WriteLine(date1.ToString("d"))
        End If
    End Sub

    Private Sub DisplayCurrentInfo()
        Console.WriteLine("Current Culture: {0}",
                          CultureInfo.CurrentCulture.Name)
        Console.WriteLine("Current Calendar: {0}",
                          DateTimeFormatInfo.CurrentInfo.Calendar)
    End Sub

    Private Function CalendarExists(ByVal culture As CultureInfo,
                                    cal As Calendar) As Boolean
        For Each optionalCalendar As Calendar In culture.OptionalCalendars
            If cal.ToString().Equals(optionalCalendar.ToString()) Then Return True
        Next
        Return False
    End Function
End Module
' The example displays the following output:
'    Current Culture: en-US
'    Current Calendar: System.Globalization.GregorianCalendar
'    6/20/2011
'    
'    Current Culture: ar-SA
'    Current Calendar: System.Globalization.UmAlQuraCalendar
'    18/07/32
'    
'    Current Culture: ar-SA
'    Current Calendar: System.Globalization.HijriCalendar
'    19/07/32

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 DateTime de DateTimeOffset 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

Tarih değeri ile dize gösterimi arasında bir fark olduğunu unutmamak önemlidir. İlki Gregoryen takvimi temel alır; ikincisi, belirli bir kültürün geçerli takvimini temel alır.

Aşağıdaki örnek, DateTime özellikleri ve bunlara karşılık gelen Calendar yöntemler arasındaki bu farkı göstermektedir. Örnekte, geçerli kültür Arapça (Mısır) ve geçerli takvim Um Al Qura'dır. DeğerDateTime, 2011 yılının yedinci ayının on beşinci gününe ayarlanır. Bu, sabit kültürün kurallarını kullandığında DateTime.ToString(String, IFormatProvider) yöntemi tarafından aynı değerlerin döndürüldüğü için Gregoryen tarih olarak yorumlandığı açıktır. Geçerli kültürün kuralları kullanılarak biçimlendirilmiş tarihin dize gösterimi, Um Al Qura takvimindeki eşdeğer tarih olan 14/08/32'dir. Ardından, DateTime ve Calendar üyeleri, DateTime değerinin gününü, ayını ve yılını dönmek 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: {date1:d}");
      Console.WriteLine($"Date in the Invariant Culture: {date1.ToString("d", CultureInfo.InvariantCulture)}");
      Console.WriteLine();

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

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

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

   private static void DisplayCurrentInfo()
   {
      Console.WriteLine($"Current Culture: {CultureInfo.CurrentCulture.Name}");
      Console.WriteLine($"Current Calendar: {DateTimeFormatInfo.CurrentInfo.Calendar}");
   }
}
// The example displays the following output:
//    Current Culture: ar-EG
//    Current Calendar: System.Globalization.UmAlQuraCalendar
//    Date: 14/08/32
//    Date in the Invariant Culture: 07/15/2011
//
//    DateTime.Month property: 7
//    UmAlQura.GetMonth: 8
//
//    DateTime.Day property: 15
//    UmAlQura.GetDayOfMonth: 14
//
//    DateTime.Year property: 2011
//    UmAlQura.GetYear: 1432

Imports System.Globalization
Imports System.Threading

Module Example
    Public Sub Main()
        ' Make Arabic (Egypt) the current culture 
        ' and Umm al-Qura calendar the current calendar. 
        Dim arEG As CultureInfo = CultureInfo.CreateSpecificCulture("ar-EG")
        Dim cal As Calendar = New UmAlQuraCalendar()
        arEG.DateTimeFormat.Calendar = cal
        Thread.CurrentThread.CurrentCulture = arEG

        ' Display information on current culture and calendar.
        DisplayCurrentInfo()

        ' Instantiate a date object.
        Dim date1 As Date = #07/15/2011#

        ' Display the string representation of the date.
        Console.WriteLine("Date: {0:d}", date1)
        Console.WriteLine("Date in the Invariant Culture: {0}",
                          date1.ToString("d", CultureInfo.InvariantCulture))
        Console.WriteLine()

        ' Compare DateTime properties and Calendar methods.
        Console.WriteLine("DateTime.Month property: {0}", date1.Month)
        Console.WriteLine("UmAlQura.GetMonth: {0}",
                          cal.GetMonth(date1))
        Console.WriteLine()

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

        Console.WriteLine("DateTime.Year property: {0:D4}", date1.Year)
        Console.WriteLine("UmAlQura.GetYear: {0}",
                          cal.GetYear(date1))
        Console.WriteLine()
    End Sub

    Private Sub DisplayCurrentInfo()
        Console.WriteLine("Current Culture: {0}",
                          CultureInfo.CurrentCulture.Name)
        Console.WriteLine("Current Calendar: {0}",
                          DateTimeFormatInfo.CurrentInfo.Calendar)
    End Sub
End Module
' The example displays the following output:
'    Current Culture: ar-EG
'    Current Calendar: System.Globalization.UmAlQuraCalendar
'    Date: 14/08/32
'    Date in the Invariant Culture: 07/15/2011
'    
'    DateTime.Month property: 7
'    UmAlQura.GetMonth: 8
'    
'    DateTime.Day property: 15
'    UmAlQura.GetDayOfMonth: 14
'    
'    DateTime.Year property: 2011
'    UmAlQura.GetYear: 1432

Takvime göre tarihler oluşturun.

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. Belirli bir takvimin değerlerine göre bir Calendar.ToDateTime nesnesi oluşturmak için, aynı takvimin DateTime yöntemi üzerindeki aşırı yüklemelerden birini de çağırabilirsiniz.

Aşağıdaki örnek, bir nesneyi oluşturucuya geçirerek bir DateTimeHebrewCalendar 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ıtması ve Gregoryen takvimi yansıtması gerekmediği anlamına gelir.

Aşağıdaki örnekte geçerli takvimin bir tarihin dize gösterimini nasıl etkilediği gösterilmektedir. Geçerli kültürü Çince (Geleneksel, Tayvan) olarak değiştirir ve bir tarih değeri oluşturur. 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 takvimde tarih olarak gösterilir. İkinci kez görüntülendiğinde, Tayvan takviminde 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: {zhTW.DateTimeFormat.Calendar}");
      Console.WriteLine(date1.ToString("d"));

      // Change the current calendar and display the date.
      zhTW.DateTimeFormat.Calendar = new TaiwanCalendar();
      Console.WriteLine($"Current calendar: {zhTW.DateTimeFormat.Calendar}");
      Console.WriteLine(date1.ToString("d"));
   }
}
// The example displays the following output:
//    Current calendar: System.Globalization.GregorianCalendar
//    2011/1/16
//    Current calendar: System.Globalization.TaiwanCalendar
//    100/1/16

Imports System.Globalization
Imports System.Threading

Module Example
    Public Sub Main()
        ' Change the current culture to zh-TW.
        Dim zhTW As CultureInfo = CultureInfo.CreateSpecificCulture("zh-TW")
        Thread.CurrentThread.CurrentCulture = zhTW
        ' Define a date.
        Dim date1 As Date = #1/16/2011#

        ' Display the date using the default (Gregorian) calendar.
        Console.WriteLine("Current calendar: {0}",
                          zhTW.DateTimeFormat.Calendar)
        Console.WriteLine(date1.ToString("d"))

        ' Change the current calendar and display the date.
        zhTW.DateTimeFormat.Calendar = New TaiwanCalendar()
        Console.WriteLine("Current calendar: {0}",
                          zhTW.DateTimeFormat.Calendar)
        Console.WriteLine(date1.ToString("d"))
    End Sub
End Module
' The example displays the following output:
'    Current calendar: System.Globalization.GregorianCalendar
'    2011/1/16
'    Current calendar: System.Globalization.TaiwanCalendar
'    100/1/16

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 bir kültürün isteğe bağlı takvimleri olmadığından, bu takvimlerdeki tarihleri temsil etmek için her zaman takvim yöntemlerini çağırmanız gerekir. Bu, EastAsianLunisolarCalendar, JulianCalendar ve PersianCalendar sınıflarından türetilen tüm takvimler için geçerlidir.

Aşağıdaki örnek, Jülyen takviminde 9 Ocak 1905 tarihini oluşturmak için bir JulianCalendar nesnesi kullanır. Bu tarih varsayılan (Gregoryen) takvim 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 desteklediği en erken tarihten önce gelen bir tarih ve saat değeriyle çalışmak bir ArgumentOutOfRangeException özel durum oluşturur.

Ancak, önemli bir özel durum vardır. DateTime nesnesinin ve DateTimeOffset nesnesinin varsayılan (başlatılmamış) değeri, GregorianCalendar.MinSupportedDateTime değerine 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 Japon takvimi ile Japonca (Japonya) ve Um Al Qura takvimi ile Arapça (Mısır) olarak ayarlandığında, DateTime.MinValue değerini gösteren aşağıdaki örnekte gösterilmektedir. Ayrıca geçerli kültürü İngilizce (ABD) olarak ayarlar ve bu DateTime.ToString(IFormatProvider) nesnelerin her biriyle CultureInfo yöntemini çağırır. 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 {GetCalendarName(jaJP)} calendar: {jaJP.DateTimeFormat.Calendar.MinSupportedDateTime:d}");
      // Attempt to display the date.
      Console.WriteLine(dat.ToString());
      Console.WriteLine();

      // Change the current culture to ar-EG with the Um Al Qura calendar.
      CultureInfo arEG = CultureInfo.CreateSpecificCulture("ar-EG");
      arEG.DateTimeFormat.Calendar = new UmAlQuraCalendar();
      Thread.CurrentThread.CurrentCulture = arEG;
      Console.WriteLine($"Earliest supported date by {GetCalendarName(arEG)} calendar: {arEG.DateTimeFormat.Calendar.MinSupportedDateTime:d}");
      // Attempt to display the date.
      Console.WriteLine(dat.ToString());
      Console.WriteLine();

      // Change the current culture to en-US.
      Thread.CurrentThread.CurrentCulture = CultureInfo.CreateSpecificCulture("en-US");
      Console.WriteLine(dat.ToString(jaJP));
      Console.WriteLine(dat.ToString(arEG));
      Console.WriteLine(dat.ToString("d"));
   }

   private static string GetCalendarName(CultureInfo culture)
   {
      Calendar cal = culture.DateTimeFormat.Calendar;
      return cal.GetType().Name.Replace("System.Globalization.", "").Replace("Calendar", "");
   }
}
// The example displays the following output:
//       Earliest supported date by Japanese calendar: 明治 1/9/8
//       0001-01-01T00:00:00
//
//       Earliest supported date by UmAlQura calendar: 01/01/18
//       0001-01-01T00:00:00
//
//       0001-01-01T00:00:00
//       0001-01-01T00:00:00
//       1/1/0001

Imports System.Globalization
Imports System.Threading

Module Example
    Public Sub Main()
        Dim dat As Date = DateTime.MinValue

        ' Change the current culture to ja-JP with the Japanese Calendar.
        Dim jaJP As CultureInfo = CultureInfo.CreateSpecificCulture("ja-JP")
        jaJP.DateTimeFormat.Calendar = New JapaneseCalendar()
        Thread.CurrentThread.CurrentCulture = jaJP
        Console.WriteLine("Earliest supported date by {1} calendar: {0:d}",
                          jaJP.DateTimeFormat.Calendar.MinSupportedDateTime,
                          GetCalendarName(jaJP))
        ' Attempt to display the date.
        Console.WriteLine(dat.ToString())
        Console.WriteLine()

        ' Change the current culture to ar-EG with the Um Al Qura calendar.
        Dim arEG As CultureInfo = CultureInfo.CreateSpecificCulture("ar-EG")
        arEG.DateTimeFormat.Calendar = New UmAlQuraCalendar()
        Thread.CurrentThread.CurrentCulture = arEG
        Console.WriteLine("Earliest supported date by {1} calendar: {0:d}",
                          arEG.DateTimeFormat.Calendar.MinSupportedDateTime,
                          GetCalendarName(arEG))
        ' Attempt to display the date.
        Console.WRiteLine(dat.ToString())
        Console.WRiteLine()

        ' Change the current culture to en-US.
        Thread.CurrentThread.CurrentCulture = CultureInfo.CreateSpecificCulture("en-US")
        Console.WriteLine(dat.ToString(jaJP))
        Console.WriteLine(dat.ToString(arEG))
        Console.WriteLine(dat.ToString("d"))
    End Sub

    Private Function GetCalendarName(culture As CultureInfo) As String
        Dim cal As Calendar = culture.DateTimeFormat.Calendar
        Return cal.GetType().Name.Replace("System.Globalization.", "").Replace("Calendar", "")
    End Function
End Module
' The example displays the following output:
'       Earliest supported date by Japanese calendar: 明治 1/9/8
'       0001-01-01T00:00:00
'       
'       Earliest supported date by UmAlQura calendar: 01/01/18
'       0001-01-01T00:00:00
'       
'       0001-01-01T00:00:00
'       0001-01-01T00:00:00
'       1/1/0001

Dönemlerle ç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

Reiwa çağı, JapaneseCalendar ve JapaneseLunisolarCalendar içinde yeni bir ç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ı Mevcut 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, dönem numarası DateTimeFormatInfo.GetEraName veya DateTimeFormatInfo.GetAbbreviatedEraName yöntemine geçirilerek alınabilir. Aşağıdaki örnek, GregorianCalendar sınıfında çağ desteği hakkında bilgi edinmek 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

Buna ek olarak, "g" özel tarih ve saat biçim dizesi, bir tarih ve saatin dize gösteriminde 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, JapaneseCalendar tarafından desteklenen tüm çağlarda, sayıları 1 ile başlayan yıllar vardır. Normalde, bir çağ belirtilmezse hem tarih hem saat hem de takvim yöntemleri değerlerin geçerli döneme ait olduğunu varsayar. tr-TR: Bu, DateTime türündeki parametreleri içeren DateTimeOffset ve Calendar oluşturucularının yanı sıra JapaneseCalendar.ToDateTime ve JapaneseLunisolarCalendar.ToDateTime yöntemleri için de geçerlidir. 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, DateTime.ToString(String, IFormatProvider) yöntemiyle döndürülen dizede yılın öncesinde yer alır 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:

    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)

Tavsiye

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:

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

Bireysel takvimlerin desteklenen tarih aralıklarına sahip olması gibi, JapaneseCalendar ve JapaneseLunisolarCalendar sınıflarındaki dönemlerin de desteklenen aralıkları vardır. 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ümlerinde yapılan güncelleştirmeler, gevşetilmiş dönem aralığı denetimleri içerir; belirtilen dönemin aralığı dışındaki bir çağa özgü tarihin örneğini oluşturma girişimi sonraki çağa "taşar" ve hiçbir hata durumu 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, Showa dönemi aralığı dışında kalan 9 Ocak 1990'a JapaneseCalendar denk 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
    Giriş Switch.System.Globalization.EnforceJapaneseEraYearRanges
    Türü REG_SZ
    Değer doğru

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ülenir.

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 tanımlayıcısı sonuç dizesinde çağı içerir. Aşağıdaki örnek, geçerli takvim Gregoryen takvim olduğunda sonuç dizesine çağı dahil etmek için "AA-gg-yy g" özel biçim dizesini kullanır.

   DateTime dat = new DateTime(2012, 5, 1);
   Console.WriteLine($"{dat:MM-dd-yyyy g}");
// The example displays the following output:
//     05-01-2012 A.D.

Dim dat As Date = #05/01/2012#
Console.WriteLine("{0:MM-dd-yyyy g}", dat)
' The example displays the following output:
'     05-01-2012 A.D.

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.GetErave Calendar.GetYear yöntemleriyle Calendar.GetMonthbirlikte kullanılabilecek bir yöntem içerirCalendar.GetDayOfMonth. 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 eklemek istiyorsanız, bir DateTimeFormatInfo nesne örneği oluşturmanız ve JapaneseCalendar'i onun geçerli takvimi olarak ayarlamanız gerektiğ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 Japanese-Japan ("ja-JP") kültürünü CultureInfo temsil eden bir JapaneseCalendar 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önemi'nin ilk yılındaki bir 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
    Giriş Anahtarı.Sistem.Küreselleştirme.JaponcaİlkYılıBirSayıOlarakBiçimlendir
    Türü REG_SZ
    Değer doğru

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
    Giriş Switch.System.Globalization.EnforceLegacyJapaneseDateParsing
    Türü REG_SZ
    Değer doğru

Ayrıca bakınız

  • Last updated on