Trabalhar com calendáriosWorking with calendars

Embora um valor de data e hora representem um momento, sua representação de cadeia de caracteres depende da cultura e também das convenções usadas para exibir valores de data e hora por uma cultura específica e do calendário usado por essa cultura.Although a date and time value represents a moment in time, its string representation is culture-sensitive and depends both on the conventions used for displaying date and time values by a specific culture and on the calendar used by that culture. Este tópico explora o suporte para calendários no .NET e discute o uso das classes de calendário ao trabalhar com valores de data.This topic explores the support for calendars in .NET and discusses the use of the calendar classes when working with date values.

Calendários no .NETCalendars in .NET

Todos os calendários no .net derivam System.Globalization.Calendar da classe, que fornece a implementação do calendário base.All calendars in .NET derive from the System.Globalization.Calendar class, which provides the base calendar implementation. Uma das classes que herda da classe Calendar é a classe EastAsianLunisolarCalendar, a qual é a classe base para todos os calendários lunissolares.One of the classes that inherits from the Calendar class is the EastAsianLunisolarCalendar class, which is the base class for all lunisolar calendars. O .NET inclui as seguintes implementações de calendário:.NET includes the following calendar implementations:

Um calendário pode ser usado em uma de duas formas:A calendar can be used in one of two ways:

  • Como o calendário usado por uma cultura específica.As the calendar used by a specific culture. Cada objeto CultureInfo contém um calendário atual, que é o calendário que o objeto está usando no momento.Each CultureInfo object has a current calendar, which is the calendar that the object is currently using. As representações de cadeia de caracteres de todos os valores de data e hora refletem automaticamente a cultura e seu calendário atual.The string representations of all date and time values automatically reflect the current culture and its current calendar. Normalmente, o calendário atual é o calendário padrão da cultura.Typically, the current calendar is the culture's default calendar. CultureInfoos objetos também têm calendários opcionais, que incluem calendários adicionais que a cultura pode usar.CultureInfo objects also have optional calendars, which include additional calendars that the culture can use.

  • Como calendário autônomo independente de uma cultura específica.As a standalone calendar independent of a specific culture. Nesse caso, os métodos Calendar são usados para expressar datas como os valores que refletem o calendário.In this case, Calendar methods are used to express dates as values that reflect the calendar.

Observe que seis classes de calendário – ChineseLunisolarCalendar, JapaneseLunisolarCalendar, JulianCalendar, KoreanLunisolarCalendar, PersianCalendar e TaiwanLunisolarCalendar – podem ser usadas apenas como calendários autônomos.Note that six calendar classes – ChineseLunisolarCalendar, JapaneseLunisolarCalendar, JulianCalendar, KoreanLunisolarCalendar, PersianCalendar, and TaiwanLunisolarCalendar – can be used only as standalone calendars. Elas não são usadas por nenhuma cultura, seja como o calendário padrão ou como um calendário opcional.They are not used by any culture as either the default calendar or as an optional calendar.

Calendários e culturasCalendars and cultures

Cada cultura tem um calendário padrão, o qual é definido pela propriedade CultureInfo.Calendar.Each culture has a default calendar, which is defined by the CultureInfo.Calendar property. A propriedade CultureInfo.OptionalCalendars retorna uma matriz de objetos Calendar que especifica todos os calendários suportados por uma cultura específica, inclusive o calendário padrão da cultura.The CultureInfo.OptionalCalendars property returns an array of Calendar objects that specifies all the calendars supported by a particular culture, including that culture's default calendar.

O exemplo a seguir ilustra as propriedades CultureInfo.Calendar e CultureInfo.OptionalCalendars.The following example illustrates the CultureInfo.Calendar and CultureInfo.OptionalCalendars properties. Ele cria objetos CultureInfo para as culturas Tailandês (Tailândia) e Japonês (Japão) e exibe seus calendários padrão e opcionais.It creates CultureInfo objects for the Thai (Thailand) and Japanese (Japan) cultures and displays their default and optional calendars. Observe que, em ambos os casos, o calendário padrão da cultura também é incluído na coleção CultureInfo.OptionalCalendars.Note that in both cases, the culture's default calendar is also included in the CultureInfo.OptionalCalendars collection.

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)

O calendário em uso no momento por um objeto CultureInfo específico é definido pela propriedade DateTimeFormatInfo.Calendar da cultura.The calendar currently in use by a particular CultureInfo object is defined by the culture's DateTimeFormatInfo.Calendar property. O objeto DateTimeFormatInfo de uma cultura é retornado pela propriedade CultureInfo.DateTimeFormat.A culture's DateTimeFormatInfo object is returned by the CultureInfo.DateTimeFormat property. Quando uma cultura é criada, o valor padrão é o mesmo valor da propriedade CultureInfo.Calendar.When a culture is created, its default value is the same as the value of the CultureInfo.Calendar property. No entanto, você pode mudar o calendário atual da cultura para qualquer calendário contido na matriz retornada pela propriedade CultureInfo.OptionalCalendars.However, you can change the culture's current calendar to any calendar contained in the array returned by the CultureInfo.OptionalCalendars property. Se você tentar definir o calendário atual como um calendário que não está incluído no valor da propriedade CultureInfo.OptionalCalendars, uma ArgumentException será gerada.If you try to set the current calendar to a calendar that is not included in the CultureInfo.OptionalCalendars property value, an ArgumentException is thrown.

O exemplo a seguir altera o calendário usado pela cultura Árabe (Arábia Saudita).The following example changes the calendar used by the Arabic (Saudi Arabia) culture. Ele primeiro cria uma instância de um valor DateTime e o exibe usando a cultura atual – que, nesse caso, é Inglês (Estados Unidos) – e o calendário atual da cultura (que, nesse caso, é o calendário gregoriano).It first instantiates a DateTime value and displays it using the current culture - which, in this case, is English (United States) - and the current culture's calendar (which, in this case, is the Gregorian calendar). Em seguida, ele muda a cultura atual para Árabe (Arábia Saudita) e exibe a data usando seu calendário padrão Um Al Qura.Next, it changes the current culture to Arabic (Saudi Arabia) and displays the date using its default Um Al-Qura calendar. Finalmente, ele chama o método CalendarExists para determinar se o calendário islâmico é suportado pela cultura Árabe (Arábia Saudita).It then calls the CalendarExists method to determine whether the Hijri calendar is supported by the Arabic (Saudi Arabia) culture. Como o calendário é suportado, ele muda o calendário atual para Hijri e, novamente, exibe a data.Because the calendar is supported, it changes the current calendar to Hijri and again displays the date. Observe que, em cada caso, a data é exibida usando o calendário atual da cultura atual.Note that in each case, the date is displayed using the current culture's current calendar.

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

Datas e calendáriosDates and calendars

Com exceção dos construtores que incluem um parâmetro de tipo Calendar e permitem que os elementos de uma data (ou seja, mês, dia e ano), reflitam valores em um calendário designado, os valores de DateTime e DateTimeOffset sempre são baseados no calendário gregoriano.With the exception of the constructors that include a parameter of type Calendar and allow the elements of a date (that is, the month, the day, and the year) to reflect values in a designated calendar, both DateTime and DateTimeOffset values are always based on the Gregorian calendar. Isso significa, por exemplo, que a propriedade DateTime.Year retorna o ano no calendário gregoriano e que a propriedade DateTime.Day retorna o dia do mês no calendário gregoriano.This means, for example, that the DateTime.Year property returns the year in the Gregorian calendar, and the DateTime.Day property returns the day of the month in the Gregorian calendar.

Importante

É importante lembrar que há uma diferença entre um valor de data e sua representação de cadeia de caracteres.It is important to remember that there is a difference between a date value and its string representation. O primeiro baseia-se no calendário gregoriano; o último baseia-se no calendário atual de uma determinada cultura.The former is based on the Gregorian calendar; the latter is based on the current calendar of a specific culture.

O exemplo a seguir ilustra a diferença entre as propriedades DateTime e seus métodos Calendar correspondentes.The following example illustrates this difference between DateTime properties and their corresponding Calendar methods. No exemplo, a cultura atual é Árabe (Egito), e o calendário atual é Um Al Qura.In the example, the current culture is Arabic (Egypt), and the current calendar is Um Al Qura. Um valor de DateTime é definido como o décimo quinto dia do sétimo mês de 2011.A DateTime value is set to the fifteenth day of the seventh month of 2011. Está claro que esse é interpretado como uma data gregoriana, pois esses mesmos valores são retornados pelo método DateTime.ToString(String, IFormatProvider) quando as convenções da cultura invariável são usadas.It is clear that this is interpreted as a Gregorian date, because these same values are returned by the DateTime.ToString(String, IFormatProvider) method when it uses the conventions of the invariant culture. A representação de cadeia de caracteres da data que é formatada usando as convenções de cultura atual é 14/08/32, que é a data equivalente no calendário Um Al Qura.The string representation of the date that is formatted using the conventions of the current culture is 14/08/32, which is the equivalent date in the Um Al Qura calendar. Em seguida, membros de DateTime e Calendar são usados para retornar o dia, mês e o ano do valor de DateTime.Next, members of DateTime and Calendar are used to return the day, the month, and the year of the DateTime value. Em cada caso, os valores retornados pelos membros de DateTime refletem os valores do calendário gregoriano, enquanto que os valores retornados pelos membros de UmAlQuraCalendar refletem os valores do calendário Um Al Qura.In each case, the values returned by DateTime members reflect values in the Gregorian calendar, whereas values returned by UmAlQuraCalendar members reflect values in the Uum al-Qura calendar.

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

Criando uma instância de datas com base em um calendárioInstantiating dates based on a calendar

Como os valores DateTime e DateTimeOffset baseiam-se no calendário gregoriano, você deve chamar um construtor sobrecarregado que inclua um parâmetro do tipo Calendar para criar uma instância de um valor de data se você quiser usar os valores de dia, mês ou ano em um calendário diferente.Because DateTime and DateTimeOffset values are based on the Gregorian calendar, you must call an overloaded constructor that includes a parameter of type Calendar to instantiate a date value if you want to use the day, month, or year values from a different calendar. Você também pode chamar uma das sobrecargas do método Calendar.ToDateTime de um calendário específico para criar uma instância de um objeto DateTime com base nos valores de um calendário específico.You can also call one of the overloads of a specific calendar's Calendar.ToDateTime method to instantiate a DateTime object based on the values of a particular calendar.

O exemplo a seguir cria uma instância de um valor de DateTime ao passar um objeto HebrewCalendar para um construtor de DateTime e cria uma instância de um segundo valor DateTime ao chamar o método HebrewCalendar.ToDateTime(Int32, Int32, Int32, Int32, Int32, Int32, Int32, Int32).The following example instantiates one DateTime value by passing a HebrewCalendar object to a DateTime constructor, and instantiates a second DateTime value by calling the HebrewCalendar.ToDateTime(Int32, Int32, Int32, Int32, Int32, Int32, Int32, Int32) method. Como os dois valores são criados com valores idênticos do calendário hebraico, a chamada ao método DateTime.Equals mostra que os dois valores de DateTime são iguais.Because the two values are created with identical values from the Hebrew calendar, the call to the DateTime.Equals method shows that the two DateTime values are equal.

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

Representando datas no calendário atualRepresenting dates in the current calendar

Os métodos de formatação de data e hora sempre usam o calendário atual ao converter datas em cadeias de caracteres.Date and time formatting methods always use the current calendar when converting dates to strings. Isso significa que a representação de cadeia de caracteres do ano, mês e dia do mês reflete o calendário atual, e não necessariamente o calendário gregoriano.This means that the string representation of the year, the month, and the day of the month reflect the current calendar, and do not necessarily reflect the Gregorian calendar.

O exemplo a seguir mostra como o calendário atual afeta a representação de cadeia de caracteres de uma data.The following example shows how the current calendar affects the string representation of a date. Ele muda a cultura atual de Chinês (Tradicional, Taiwan) e cria uma instância de um valor de data.It changes the current culture to Chinese (Traditional, Taiwan), and instantiates a date value. Ele então exibe o calendário e a data atuais, altera o calendário atual para TaiwanCalendar e exibe o calendário e a data atuais mais uma vez.It then displays the current calendar and the date, changes the current calendar to TaiwanCalendar, and displays the current calendar and date once again. Na primeira vez que a data é exibida, ela é representada como uma data no calendário gregoriano.The first time the date is displayed, it is represented as a date in the Gregorian calendar. Na segunda vez que a data é exibida, ela é representada como uma data no calendário de Taiwan.The second time it is displayed, it is represented as a date in the Taiwan calendar.

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

Representando datas em um calendário não atualRepresenting dates in a non-current calendar

Para representar uma data usando um calendário que não é o calendário atual de uma cultura específica, você deve chamar métodos do objeto Calendar.To represent a date using a calendar that is not the current calendar of a particular culture, you must call methods of that Calendar object. Por exemplo, os métodos Calendar.GetYear, Calendar.GetMonth e Calendar.GetDayOfMonth convertem o ano, o mês e o dia para valores que refletem um calendário específico.For example, the Calendar.GetYear, Calendar.GetMonth, and Calendar.GetDayOfMonth methods convert the year, month, and day to values that reflect a particular calendar.

Aviso

Como alguns calendários são calendários não opcionais de qualquer cultura, representar datas nesses calendários sempre exige que você chame métodos de calendário.Because some calendars are not optional calendars of any culture, representing dates in these calendars always requires that you call calendar methods. Isso é verdadeiro para todos os calendários que derivam das classes EastAsianLunisolarCalendar, de JulianCalendar e PersianCalendar.This is true of all calendars that derive from the EastAsianLunisolarCalendar, JulianCalendar, and PersianCalendar classes.

O exemplo a seguir usa um objeto JulianCalendar para criar uma instância de uma data, 9 de janeiro de 1905, no calendário juliano.The following example uses a JulianCalendar object to instantiate a date, January 9, 1905, in the Julian calendar. Quando essa data é exibida no calendário gregoriano (padrão), ela é representada como 22 de janeiro de 1905.When this date is displayed using the default (Gregorian) calendar, it is represented as January 22, 1905. Chamadas para métodos JulianCalendar individuais permitem que a data seja representada no calendário juliano.Calls to individual JulianCalendar methods enable the date to be represented in the Julian calendar.

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

Calendários e intervalos de datasCalendars and date ranges

A data mais antiga suportada por um calendário é indicada pela propriedade Calendar.MinSupportedDateTime desse calendário.The earliest date supported by a calendar is indicated by that calendar's Calendar.MinSupportedDateTime property. Para a classe GregorianCalendar, essa data é 1º de janeiro de 0001. C.E.For the GregorianCalendar class, that date is January 1, 0001 C.E. A maioria dos outros calendários no .NET oferece suporte a uma data posterior.Most of the other calendars in .NET support a later date. Tentar trabalhar com um valor de data e hora que antecedem a data com suporte mais antiga de um calendário gerará uma exceção ArgumentOutOfRangeException.Trying to work with a date and time value that precedes a calendar's earliest supported date throws an ArgumentOutOfRangeException exception.

Porém, há uma exceção importante.However, there is one important exception. O valor padrão (não inicializado) de um objeto DateTime e um objeto DateTimeOffset é igual ao valor de GregorianCalendar.MinSupportedDateTime.The default (uninitialized) value of a DateTime object and a DateTimeOffset object is equal to the GregorianCalendar.MinSupportedDateTime value. Se você tentar formatar essa data em um calendário que não dá suporte a 1º de janeiro de 0001 C.E.If you try to format this date in a calendar that does not support January 1, 0001 C.E. e você não fornece um especificador de formato, o método de formatação usa o especificador de formato "s" (padrão de data/hora classificável) em vez do especificador de formato "G" (padrão de data/hora geral).and you do not provide a format specifier, the formatting method uses the "s" (sortable date/time pattern) format specifier instead of the "G" (general date/time pattern) format specifier. Como resultado, a operação de formatação não gerará uma exceção ArgumentOutOfRangeException.As a result, the formatting operation does not throw an ArgumentOutOfRangeException exception. Em vez disso, retornará uma data sem suporte.Instead, it returns the unsupported date. Isso é ilustrado no exemplo a seguir, que exibe o valor de DateTime.MinValue quando a cultura atual é configurada para Japonês (Japão) com o calendário japonês, e para Árabe (Egito) com o calendário Um Al Qura.This is illustrated in the following example, which displays the value of DateTime.MinValue when the current culture is set to Japanese (Japan) with the Japanese calendar, and to Arabic (Egypt) with the Um Al Qura calendar. Ela também define a cultura atual como Inglês (Estados Unidos) e chama o método DateTime.ToString(IFormatProvider) com cada um desses objetos CultureInfo.It also sets the current culture to English (United States) and calls the DateTime.ToString(IFormatProvider) method with each of these CultureInfo objects. Em cada caso, a data é exibida usando o padrão classificável de data/hora.In each case, the date is displayed by using the sortable date/time pattern.

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

Trabalhando com apagarWorking with eras

Os calendários normalmente dividem as datas em eras.Calendars typically divide dates into eras. No entanto Calendar , as classes no .net não oferecem suporte a toda era definida por um calendário, e Calendar a maioria das classes dá suporte apenas a uma única época.However, the Calendar classes in .NET do not support every era defined by a calendar, and most of the Calendar classes support only a single era. Somente as classes JapaneseCalendar e JapaneseLunisolarCalendar oferecem suporte a várias eras.Only the JapaneseCalendar and JapaneseLunisolarCalendar classes support multiple eras.

Importante

A era Reiwa, uma nova era no JapaneseCalendar e JapaneseLunisolarCalendar, começa em 1º de maio de 2019.The Reiwa era, a new era in the JapaneseCalendar and JapaneseLunisolarCalendar, begins on May 1, 2019. Essa alteração afeta todos os aplicativos que usam esses calendários.This change affects all applications that use these calendars. Consulte os seguintes artigos para obter mais informações:See the following articles for more information:

Uma era na maioria dos calendários denota um período de tempo muito longo.An era in most calendars denotes an extremely long time period. No calendário gregoriano, por exemplo, a era atual se estende por mais de duas milênios.In the Gregorian calendar, for example, the current era spans more than two millennia. Para o JapaneseLunisolarCalendare o, os dois calendários que dão suporte a vários apagar, esse não é o caso. JapaneseCalendarFor the JapaneseCalendar and the JapaneseLunisolarCalendar, the two calendars that support multiple eras, this is not the case. Uma era corresponde ao período do Reino de um imperador.An era corresponds to the period of an emperor's reign. O suporte para vários apagamentos, especialmente quando o limite superior da era atual é desconhecido, apresenta desafios especiais.Support for multiple eras, particularly when the upper limit of the current era is unknown, poses special challenges.

Apagar e nomes de eraEras and era names

No .net, os inteiros que representam o apagamento com suporte de uma implementação de calendário em particular são armazenados em ordem Calendar.Eras inversa na matriz.In .NET, integers that represent the eras supported by a particular calendar implementation are stored in reverse order in the Calendar.Eras array. A era atual (que é a era com o intervalo de tempo mais recente) está no índice zero e Calendar para classes que dão suporte a vários apagamentos, cada índice sucessivo reflete a era anterior.The current era (which is the era with the latest time range) is at index zero, and for Calendar classes that support multiple eras, each successive index reflects the previous era. A propriedade estática Calendar.CurrentEra define o índice de era atual na matriz Calendar.Eras ; ela é uma constante cujo valor é sempre zero.The static Calendar.CurrentEra property defines the index of the current era in the Calendar.Eras array; it is a constant whose value is always zero. As classes Calendar individuais também incluem os campos estáticos que retornam o valor da era atual.Individual Calendar classes also include static fields that return the value of the current era. Elas são listadas na tabela a seguir.They are listed in the following table.

Classe do calendárioCalendar class Campo de era atualCurrent era field
ChineseLunisolarCalendar ChineseEra
GregorianCalendar ADEra
HebrewCalendar HebrewEra
HijriCalendar HijriEra
JapaneseLunisolarCalendar JapaneseEra
JulianCalendar JulianEra
KoreanCalendar KoreanEra
KoreanLunisolarCalendar GregorianEra
PersianCalendar PersianEra
ThaiBuddhistCalendar ThaiBuddhistEra
UmAlQuraCalendar UmAlQuraEra

O nome que corresponde a um número de era específico não pode ser recuperado com a passagem do número da era para o método DateTimeFormatInfo.GetEraName ou DateTimeFormatInfo.GetAbbreviatedEraName.The name that corresponds to a particular era number can be retrieved by passing the era number to the DateTimeFormatInfo.GetEraName or DateTimeFormatInfo.GetAbbreviatedEraName method. O exemplo a seguir chama esses métodos para recuperar informações sobre o suporte a eras na classe GregorianCalendar.The following example calls these methods to retrieve information about era support in the GregorianCalendar class. Ele exibe a data do calendário gregoriano que corresponde a 1º de Janeiro do segundo ano da era atual, bem como a data do calendário gregoriano que corresponde a 1º de Janeiro do segundo ano de cada era do calendário japonês com suporte.It displays the Gregorian calendar date that corresponds to January 1 of the second year of the current era, as well as the Gregorian calendar date that corresponds to January 1 of the second year of each supported Japanese calendar era.

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

Além disso, a cadeia de caracteres de formato de data e hora personalizado "g" inclui o nome da era na representação de cadeia de caracteres de uma data e hora.In addition, the "g" custom date and time format string includes a calendar's era name in the string representation of a date and time. Para obter mais informações, consulte cadeias de caracteres de formato personalizado de data e hora.For more information, see Custom date and time format strings.

Criando uma instância de uma data com uma eraInstantiating a date with an era

Para as duas Calendar classes que dão suporte a vários apagamentos, uma data que consiste em um determinado ano, mês e dia do valor do mês pode ser ambígua.For the two Calendar classes that support multiple eras, a date that consists of a particular year, month, and day of the month value can be ambiguous. Por exemplo, todos os apagados têm JapaneseCalendar suporte do que têm anos cujo número é 1.For example, all eras supported by the JapaneseCalendar have years whose number is 1. Normalmente, se uma era não é especificada, os métodos de data e hora e calendário assumem que os valores pertencem à era atual.Ordinarily, if an era is not specified, both date and time and calendar methods assume that values belong to the current era. Isso é DateTime verdadeiro nos construtores e DateTimeOffset que incluem parâmetros do tipo Calendar, bem como os métodos JapaneseCalendar. ToDateTime e JapaneseLunisolarCalendar. ToDateTime .This is true of the DateTime and DateTimeOffset constructors that include parameters of type Calendar, as well as the JapaneseCalendar.ToDateTime and JapaneseLunisolarCalendar.ToDateTime methods. O exemplo a seguir instancia uma data que representa 1 de Janeiro do segundo ano de uma era não especificada.The following example instantiates a date that represents January 1 of the second year of an unspecified era. Se você executar o exemplo quando a era Reiwa for a época atual, a data será interpretada como o segundo ano da era Reiwa.If you execute the example when the Reiwa era is the current era, the date is interpreted as the second year of the Reiwa era. A era, 令和, precede o ano na cadeia de caracteres retornada pelo DateTime.ToString(String, IFormatProvider) método e corresponde a 1º de janeiro de 2020, no calendário gregoriano.The era, 令和, precedes the year in the string returned by the DateTime.ToString(String, IFormatProvider) method and corresponds to January 1, 2020, in the Gregorian calendar. (A era Reiwa começa no ano 2019 do calendário gregoriano.)(The Reiwa era begins in the year 2019 of the Gregorian calendar.)

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

No entanto, se a era for alterada, a intenção desse código se tornará ambígua.However, if the era changes, the intent of this code becomes ambiguous. A data deve representar o segundo ano da era atual ou se pretende representar o segundo ano da era do Heisei?Is the date intended to represent the second year of the current era, or is it intended to represent the second year of the Heisei era? Há duas maneiras de evitar essa ambiguidade:There are two ways to avoid this ambiguity:

  • Crie uma instância do valor de data e hora GregorianCalendar usando a classe padrão.Instantiate the date and time value using the default GregorianCalendar class. Você pode usar o calendário japonês ou o calendário lunisolar japonês para a representação de cadeia de caracteres de datas, como mostra o exemplo a seguir.You can then use the Japanese calendar or the Japanese Lunisolar calendar for the string representation of dates, as the following example shows.

    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
    
    
    
  • Chame um método de data e hora que especifica explicitamente uma era.Call a date and time method that explicitly specifies an era. Isso inclui os seguintes métodos:This includes the following methods:

    O exemplo a seguir usa três desses métodos para criar uma instância de data e hora na era Meiji, que começou em 8 de setembro de 1868 e terminou em 29 de julho de 1912.The following example uses three of these methods to instantiate a date and time in the Meiji era, which began on September 8, 1868, and ended on July 29, 1912.

    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($"{date1.ToString("d", jaJp)} (Gregorian {date1:d}");
            }
            catch (FormatException)
            {
                Console.WriteLine("The parsing operation failed.");
            }
    
            try {
                var date3 = DateTime.ParseExact("明治23/9/8", "gyy/m/d", jaJp);
                Console.WriteLine($"{date1.ToString("d", jaJp)} (Gregorian {date1: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($"{date1.ToString("d", jaJp)} (Gregorian {date1: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($"{date1.ToString("d", jaJp)} (Gregorian {date1: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
    

Dica

Ao trabalhar com calendários que dão suporte a vários apagamentos, sempre use a data gregoriana para criar uma instância de uma data ou especifique a era quando você criar uma instância de uma data e hora com base nesse calendário.When working with calendars that support multiple eras, always use the Gregorian date to instantiate a date, or specify the era when you instantiate a date and time based on that calendar.

Ao especificar uma era para o ToDateTime(Int32, Int32, Int32, Int32, Int32, Int32, Int32, Int32) método, você fornece o índice da era na Propriedade do Eras calendário.In specifying an era to the ToDateTime(Int32, Int32, Int32, Int32, Int32, Int32, Int32, Int32) method, you provide the index of the era in the calendar's Eras property. No entanto, para calendários cujo apagamento está sujeito a alterações, esses índices não são valores constantes; a era atual está no índice 0 e a era mais antiga está no índice Eras.Length - 1.For calendars whose eras are subject to change, however, these indexes are not constant values; the current era is at index 0, and the oldest era is at index Eras.Length - 1. Quando uma nova era adicionada a um calendário, os índices do apagamento anterior são aumentados em um.When a new era is added to a calendar, the indexes of the previous eras increase by one. Você pode fornecer o índice de era apropriado da seguinte maneira:You can supply the appropriate era index as follows:

Calendários, apagar e intervalos de datas: Verificações de intervalo relaxadasCalendars, eras, and date ranges: Relaxed range checks

Muito parecido com os calendários individuais têm suporte para intervalos de datas, JapaneseCalendar o JapaneseLunisolarCalendar apagamento nas classes e também tem intervalos com suporte.Very much like individual calendars have supported date ranges, eras in the JapaneseCalendar and JapaneseLunisolarCalendar classes also have supported ranges. Anteriormente, o .NET usava verificações de intervalo de era estrito para garantir que uma data específica era dentro do intervalo dessa era.Previously, .NET used strict era range checks to ensure that an era-specific date was within the range of that era. Ou seja, se uma data estiver fora do intervalo da era especificada, o método lançará um ArgumentOutOfRangeException.That is, if a date is outside of the range of the specified era, the method throws an ArgumentOutOfRangeException. Atualmente, o .NET usa a verificação de intervalo reduzida por padrão.Currently, .NET uses relaxed ranged checking by default. As atualizações para todas as versões do .NET introduziram verificações de intervalo de era reduzida; a tentativa de criar uma instância de uma data específica que está fora do intervalo da era "estouros" de uma época especificada na seguinte era e nenhuma exceção é lançada.Updates to all versions of .NET introduced relaxed era range checks; the attempt to instantiate an era-specific date that is outside the range of the specified era "overflows" into the following era, and no exception is thrown.

O exemplo a seguir tenta criar uma instância de uma data no ano 65th da era Showa, que começou em 25 de dezembro de 1926 e terminou em 7 de janeiro de 1989.The following example attempts to instantiate a date in the 65th year of the Showa era, which began on December 25, 1926 and ended on January 7, 1989. Essa data corresponde a 9 de janeiro de 1990, que está fora do intervalo da era de Showa no JapaneseCalendar.This date corresponds to January 9, 1990, which is outside the range of the Showa era in the JapaneseCalendar. Como a saída do exemplo ilustra, a data exibida pelo exemplo é 9 de janeiro de 1990, no segundo ano da era do Heisei.As the output from the example illustrates, the date displayed by the example is January 9, 1990, in the second year of the Heisei era.

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

Se as verificações de intervalo relaxadas não forem indesejáveis, você poderá restaurar verificações de intervalo estritas de várias maneiras, dependendo da versão do .NET na qual seu aplicativo está sendo executado:If relaxed range checks are undesirable, you can restore strict range checks in a number of ways, depending on the version of .NET on which your application is running:

  • .NET Core: Você pode adicionar o seguinte ao arquivo de configuração . NetCore. Runtime. JSON :.NET Core: You can add the following to the .netcore.runtime.json config file:

    "runtimeOptions": {
      "configProperties": {
          "Switch.System.Globalization.EnforceJapaneseEraYearRanges": true
      }
    }
    
  • .NET Framework 4,6 ou posterior: Você pode definir a seguinte opção AppContext:.NET Framework 4.6 or later: You can set the following AppContext switch:

    <?xml version="1.0" encoding="utf-8"?>
    <configuration>
      <runtime>
        <AppContextSwitchOverrides value="Switch.System.Globalization.EnforceJapaneseEraYearRanges=true" />
      </runtime>
    </configuration>
    
  • .NET Framework 4.5.2 ou anterior: Você pode definir o seguinte valor de registro:.NET Framework 4.5.2 or earlier: You can set the following registry value:

    ChaveKey HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft.NETFramework\AppContextHKEY_LOCAL_MACHINE\Software\Microsoft.NETFramework\AppContext
    NomeName Switch.System.Globalization.EnforceJapaneseEraYearRangesSwitch.System.Globalization.EnforceJapaneseEraYearRanges
    TipoType REG_SZREG_SZ
    ValorValue truetrue

Com as verificações de intervalo estrita habilitadas, o exemplo ArgumentOutOfRangeException anterior gera um e exibe a seguinte saída:With strict range checks enabled, the previous example throws an ArgumentOutOfRangeException and displays the following output:

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

Representando datas em calendários com vários apagamentosRepresenting dates in calendars with multiple eras

Se um objeto Calendar oferece suporte a eras e é o calendário atual de um objeto CultureInfo, a era está incluída na representação de cadeia de caracteres de um valor de data e hora para os padrões de data e hora completa, data completa e data abreviada.If a Calendar object supports eras and is the current calendar of a CultureInfo object, the era is included in the string representation of a date and time value for the full date and time, long date, and short date patterns. O exemplo a seguir exibe esses padrões de data quando a cultura atual é Japão (japanese) e o calendário atual é o calendário japonês.The following example displays these date patterns when the current culture is Japan (Japanese) and the current calendar is the Japanese calendar.

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 

Aviso

A JapaneseCalendar classe é a única classe Calendar no .NET que dá suporte a datas em mais de uma era e que pode ser o calendário atual de CultureInfo um objeto, especificamente, de CultureInfo um objeto que representa a cultura japonesa (Japão).The JapaneseCalendar class is the only calendar class in .NET that both supports dates in more than one era and that can be the current calendar of a CultureInfo object - specifically, of a CultureInfo object that represents the Japanese (Japan) culture.

Para todos os calendários, o especificador de formato personalizado “g” inclui a era na cadeia de caracteres de resultado.For all calendars, the "g" custom format specifier includes the era in the result string. O exemplo a seguir usa a cadeia de caracteres de formato personalizado "MM-dd-aaaa g" para incluir a era na cadeia de caracteres de resultado quando o calendário atual é o calendário gregoriano.The following example uses the "MM-dd-yyyy g" custom format string to include the era in the result string when the current calendar is the Gregorian calendar.

   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.      

Em casos em que a representação de cadeia de caracteres de uma data é expressa em um calendário que não é o calendário atual, a classe Calendar inclui um método Calendar.GetEra que pode ser usado junto com Calendar.GetYear, Calendar.GetMonth e os métodos Calendar.GetDayOfMonth para indicar inequivocamente uma data e a era à qual ela pertence.In cases where the string representation of a date is expressed in a calendar that is not the current calendar, the Calendar class includes a Calendar.GetEra method that can be used along with the Calendar.GetYear, Calendar.GetMonth, and Calendar.GetDayOfMonth methods to unambiguously indicate a date as well as the era to which it belongs. O exemplo a seguir usa a classe JapaneseLunisolarCalendar para fornecer uma ilustração.The following example uses the JapaneseLunisolarCalendar class to provide an illustration. No entanto, observe que incluir um nome ou abreviação significativa em vez de um inteiro para a era na cadeia de caracteres de resultado exige que você crie uma instância de um objeto DateTimeFormatInfo e faça de JapaneseCalendar o calendário atual.However, note that including a meaningful name or abbreviation instead of an integer for the era in the result string requires that you instantiate a DateTimeFormatInfo object and make JapaneseCalendar its current calendar. (O calendário JapaneseLunisolarCalendar não pode ser o calendário atual de qualquer cultura, mas, nesse caso, os dois calendários compartilham as mesmas eras.)(The JapaneseLunisolarCalendar calendar cannot be the current calendar of any culture, but in this case the two calendars share the same eras.)

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

Nos calendários japoneses, o primeiro ano de uma era chamado de Gannen (元年).In the Japanese calendars, the first year of an era is called Gannen (元年). Por exemplo, em vez de Heisei 1, o primeiro ano da era Heisei pode ser descrito como Heisei Gannen.For example, instead of Heisei 1, the first year of the Heisei era can be described as Heisei Gannen. O .net adota essa convenção em operações de formatação para datas e horas formatadas com as seguintes cadeias de caracteres de formato de data e hora personalizadas ou CultureInfo padrão quando são usadas com um objeto que representa a cultura japonesa-Japão ("ja-JP") com o JapaneseCalendar classe:.NET adopts this convention in formatting operations for dates and times formatted with the following standard or custom date and time format strings when they are used with a CultureInfo object that represents the Japanese-Japan ("ja-JP") culture with the JapaneseCalendar class:

Por exemplo, o exemplo a seguir exibe uma data no primeiro ano da era do Heisei no JapaneseCalendar .For example, the following example displays a date in the first year of the Heisei era in the JapaneseCalendar .

using System;
using System.Globalization;

public class Example
{
    public static void Main()
    {
         var enUs = new CultureInfo("en-US");
        var japaneseCal = new JapaneseCalendar();
        var jaJp = new CultureInfo("ja-JP");
        jaJp.DateTimeFormat.Calendar = japaneseCal;
        string heiseiEra = "平成";

        var date = japaneseCal.ToDateTime(1, 8, 18, 0, 0, 0, 0, GetEraIndex(heiseiEra));
        FormattableString fmt = $"{date:D}";
        Console.WriteLine($"Japanese calendar date: {fmt.ToString(jaJp)} (Gregorian: {fmt.ToString(enUs)})");

        int GetEraIndex(string eraName)
        {
           foreach (var ctr in japaneseCal.Eras)
              if (jaJp.DateTimeFormat.GetEraName(ctr) == eraName)
                 return ctr;

           return 0; 
        }
    }
}
// The example displays the following output:
//    Japanese calendar date: 平成元年8月18日 (Gregorian: Friday, August 18, 1989)




Imports System.Globalization

Module Program
    Dim jaJp As CultureInfo
    Dim japaneseCal As Calendar

    Sub Main()
        Dim enUs = New CultureInfo("en-US")
        japaneseCal = New JapaneseCalendar()
        jaJp = New CultureInfo("ja-JP")
        jaJp.DateTimeFormat.Calendar = japaneseCal
        Dim heiseiEra = "平成"

        Dim dat = japaneseCal.ToDateTime(1, 8, 18, 0, 0, 0, 0, GetEraIndex(heiseiEra))
        Dim fmt As FormattableString = $"{dat:D}"
        Console.WriteLine($"Japanese calendar date: {fmt.ToString(jaJp)} (Gregorian: {fmt.ToString(enUs)})")
    End Sub

    Private Function GetEraIndex(eraName As String) As Integer
        For Each ctr In japaneseCal.Eras
            If jaJp.DateTimeFormat.GetEraName(ctr) = eraName Then
                Return ctr
            End If
        Next
        Return 0 
    End Function
End Module
' The example displays the following output:
'    Japanese calendar date: 平成元年8月18日 (Gregorian: Friday, August 18, 1989)

Se esse comportamento for indesejável em operações de formatação, você poderá restaurar o comportamento anterior, que sempre representa o primeiro ano de uma era como "1" em vez de "gannen", fazendo o seguinte, dependendo da versão do .NET:If this behavior is undesirable in formatting operations, you can restore the previous behavior, which always represents the first year of an era as “1” rather than “Gannen”, by doing the following, depending on the version of .NET:

  • .NET Core: Você pode adicionar o seguinte ao arquivo de configuração . NetCore. Runtime. JSON :.NET Core: You can add the following to the .netcore.runtime.json config file:

    "runtimeOptions": {
      "configProperties": {
          "Switch.System.Globalization.FormatJapaneseFirstYearAsANumber": true
      }
    }
    
  • .NET Framework 4,6 ou posterior: Você pode definir a seguinte opção AppContext:.NET Framework 4.6 or later: You can set the following AppContext switch:

    <?xml version="1.0" encoding="utf-8"?>
    <configuration>
      <runtime>
        <AppContextSwitchOverrides value="Switch.System.Globalization.FormatJapaneseFirstYearAsANumber=true" />
      </runtime>
    </configuration>
    
  • .NET Framework 4.5.2 ou anterior: Você pode definir o seguinte valor de registro:.NET Framework 4.5.2 or earlier: You can set the following registry value:

    ChaveKey HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft.NETFramework\AppContextHKEY_LOCAL_MACHINE\Software\Microsoft.NETFramework\AppContext
    NomeName Switch.System.Globalization.FormatJapaneseFirstYearAsANumberSwitch.System.Globalization.FormatJapaneseFirstYearAsANumber
    TipoType REG_SZREG_SZ
    ValorValue truetrue

Com o suporte do Gannen nas operações de formatação desabilitadas, o exemplo anterior exibe a seguinte saída:With gannen support in formatting operations disabled, the previous example displays the following output:

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

O .NET também foi atualizado para que as operações de análise de data e hora ofereçam suporte a cadeias de caracteres que contêm o ano representado como "1" ou Gannen..NET has also been updated so that date and time parsing operations support strings that contain the year represented as either "1" or Gannen. Embora não seja necessário fazer isso, você pode restaurar o comportamento anterior para que ele reconheça apenas "1" como o primeiro ano de uma era.Although you should not need to do this, you can restore the previous behavior to recognizes only “1” as the first year of an era. Você pode fazer isso da seguinte maneira, dependendo da versão do .NET:You can do this as follows, depending on the version of .NET:

  • .NET Core: Você pode adicionar o seguinte ao arquivo de configuração . NetCore. Runtime. JSON :.NET Core: You can add the following to the .netcore.runtime.json config file:

    "runtimeOptions": {
      "configProperties": {
          "Switch.System.Globalization.EnforceLegacyJapaneseDateParsing": true
      }
    }
    
  • .NET Framework 4,6 ou posterior: Você pode definir a seguinte opção AppContext:.NET Framework 4.6 or later: You can set the following AppContext switch:

    <?xml version="1.0" encoding="utf-8"?>
    <configuration>
      <runtime>
        <AppContextSwitchOverrides value="Switch.System.Globalization.EnforceLegacyJapaneseDateParsing=true" />
      </runtime>
    </configuration>
    
  • .NET Framework 4.5.2 ou anterior: Você pode definir o seguinte valor de registro:.NET Framework 4.5.2 or earlier: You can set the following registry value:

    ChaveKey HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft.NETFramework\AppContextHKEY_LOCAL_MACHINE\Software\Microsoft.NETFramework\AppContext
    NomeName Switch.System.Globalization.EnforceLegacyJapaneseDateParsingSwitch.System.Globalization.EnforceLegacyJapaneseDateParsing
    TipoType REG_SZREG_SZ
    ValorValue truetrue

Consulte tambémSee also