Trabajar con calendariosWorking with calendars

Aunque un valor de fecha y hora representa un momento en el tiempo, su representación de cadena tiene en cuenta la referencia cultural y depende tanto de las convenciones empleadas para mostrar los valores de fecha y hora por una referencia cultural específica como del calendario usado por esa referencia cultural.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. En este tema se explora la compatibilidad con calendarios de .NET y describe el uso de las clases de calendario al trabajar con valores de fecha.This topic explores the support for calendars in .NET and discusses the use of the calendar classes when working with date values.

Calendarios de .NETCalendars in .NET

Todos los calendarios de .NET derivan de la System.Globalization.Calendar (clase), que proporciona la implementación de calendario base.All calendars in .NET derive from the System.Globalization.Calendar class, which provides the base calendar implementation. Una de las clases que hereda de la clase Calendar es EastAsianLunisolarCalendar, que es la clase base para todos los calendarios lunisolares.One of the classes that inherits from the Calendar class is the EastAsianLunisolarCalendar class, which is the base class for all lunisolar calendars. .NET incluye las siguientes implementaciones de calendario:.NET includes the following calendar implementations:

Un calendario se puede usar de dos maneras:A calendar can be used in one of two ways:

  • Como el calendario empleado por una referencia cultural específica.As the calendar used by a specific culture. Cada objeto CultureInfo tiene un calendario actual, que es el calendario que el objeto está usando actualmente.Each CultureInfo object has a current calendar, which is the calendar that the object is currently using. Las representaciones de cadena de todos los valores de fecha y hora reflejan automáticamente la referencia cultural actual y su calendario actual.The string representations of all date and time values automatically reflect the current culture and its current calendar. Normalmente, el calendario actual es el calendario predeterminado de la referencia cultural.Typically, the current calendar is the culture's default calendar. CultureInfo los objetos tienen también calendarios opcionales, que incluyen los calendarios adicionales que puede usar la referencia cultural.CultureInfo objects also have optional calendars, which include additional calendars that the culture can use.

  • Como calendario independiente de una referencia cultural concreta.As a standalone calendar independent of a specific culture. En este caso, los métodos de Calendar se emplean para expresar las fechas como valores que reflejen el calendario.In this case, Calendar methods are used to express dates as values that reflect the calendar.

Tenga en cuenta que seis clases de calendario (ChineseLunisolarCalendar, JapaneseLunisolarCalendar, JulianCalendar, KoreanLunisolarCalendar, PersianCalendar y TaiwanLunisolarCalendar) solo se pueden usar como calendarios independientes.Note that six calendar classes – ChineseLunisolarCalendar, JapaneseLunisolarCalendar, JulianCalendar, KoreanLunisolarCalendar, PersianCalendar, and TaiwanLunisolarCalendar – can be used only as standalone calendars. Ninguna referencia cultural los usa como calendario predeterminado ni como calendario opcional.They are not used by any culture as either the default calendar or as an optional calendar.

Calendarios y referencias culturalesCalendars and cultures

Cada referencia cultural tiene un calendario predeterminado, que está definido por la propiedad CultureInfo.Calendar.Each culture has a default calendar, which is defined by the CultureInfo.Calendar property. La propiedad CultureInfo.OptionalCalendars devuelve una matriz de objetos Calendar que especifica todos los calendarios admitidos por una referencia cultural determinada, incluido el calendario predeterminado de esa referencia cultural.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.

En el ejemplo siguiente se muestra cómo usar las propiedades CultureInfo.Calendar y CultureInfo.OptionalCalendars.The following example illustrates the CultureInfo.Calendar and CultureInfo.OptionalCalendars properties. Crea objetos CultureInfo para las referencias culturales de tailandés (Tailandia) y japonés (Japón), y muestra sus calendarios predeterminados y opcionales.It creates CultureInfo objects for the Thai (Thailand) and Japanese (Japan) cultures and displays their default and optional calendars. Tenga en cuenta que, en ambos casos, el calendario predeterminado de la referencia cultural también se incluye en la colección 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)

El calendario en uso actualmente por un objeto CultureInfo determinado está definido por la propiedad DateTimeFormatInfo.Calendar de la referencia cultural.The calendar currently in use by a particular CultureInfo object is defined by the culture's DateTimeFormatInfo.Calendar property. La propiedad DateTimeFormatInfo devuelve el objeto CultureInfo.DateTimeFormat de la referencia cultural.A culture's DateTimeFormatInfo object is returned by the CultureInfo.DateTimeFormat property. Cuando se crea una referencia cultural, su valor predeterminado es igual que el valor de la propiedad CultureInfo.Calendar.When a culture is created, its default value is the same as the value of the CultureInfo.Calendar property. Sin embargo, puede cambiar el calendario actual de la referencia cultural a cualquier calendario contenido en la matriz devuelta por la propiedad CultureInfo.OptionalCalendars.However, you can change the culture's current calendar to any calendar contained in the array returned by the CultureInfo.OptionalCalendars property. Si intenta establecer el calendario actual en un calendario que no está incluido en el valor de propiedad CultureInfo.OptionalCalendars, se produce ArgumentException.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.

En el ejemplo siguiente se cambia el calendario usado por la referencia cultural Árabe (Arabia Saudí).The following example changes the calendar used by the Arabic (Saudi Arabia) culture. Primero, se crean instancias de un valor DateTime y se muestra usando la referencia cultural actual que, en este caso, es inglés (Estados Unidos), y el calendario de la referencia cultural actual (que en este caso es el calendario 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). A continuación, cambia la referencia cultural actual a Árabe (Arabia Saudí) y muestra la fecha usando su calendario predeterminado Um-Al-Qura.Next, it changes the current culture to Arabic (Saudi Arabia) and displays the date using its default Um Al-Qura calendar. Después, llama al método CalendarExists para determinar si la referencia cultural Árabe (Arabia Saudí) admite el calendario Hijri.It then calls the CalendarExists method to determine whether the Hijri calendar is supported by the Arabic (Saudi Arabia) culture. Puesto que se admite el calendario, cambia el calendario actual a Hijri y vuelve a mostrar la fecha.Because the calendar is supported, it changes the current calendar to Hijri and again displays the date. Tenga en cuenta que en cada caso la fecha se muestra usando el calendario actual de la referencia cultural actual.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

Fechas y calendariosDates and calendars

Salvo los constructores que incluyen un parámetro de tipo Calendar y permiten que los elementos de una fecha (es decir, el mes, el día y el año) reflejen los valores de un calendario designado, los valores DateTime y DateTimeOffset siempre se basan en el calendario 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. Esto significa, por ejemplo, que la propiedad DateTime.Year devuelve el año en el calendario gregoriano y la propiedad DateTime.Day devuelve el día del mes en el calendario 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

Es importante recordar que existe una diferencia entre un valor de fecha y su representación de cadena.It is important to remember that there is a difference between a date value and its string representation. El primero se basa en el calendario gregoriano, mientras que la última se basa en el calendario actual de una referencia cultural concreta.The former is based on the Gregorian calendar; the latter is based on the current calendar of a specific culture.

En el ejemplo siguiente se muestra esta diferencia entre las propiedades de DateTime y sus métodos Calendar correspondientes.The following example illustrates this difference between DateTime properties and their corresponding Calendar methods. En el ejemplo, la referencia cultural actual es Árabe (Egipto) y el calendario actual es Um-Al-Qura.In the example, the current culture is Arabic (Egypt), and the current calendar is Um Al Qura. Un valor DateTime se establece en el decimoquinto día del séptimo mes de 2011.A DateTime value is set to the fifteenth day of the seventh month of 2011. Está claro que esto se interpreta como una fecha gregoriana, ya que el método DateTime.ToString(String, IFormatProvider) devuelve estos mismos valores cuando se usan las convenciones de la referencia cultural para todos los idiomas.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. La representación de cadena de la fecha a la que se aplica formato con las convenciones de la referencia cultural actual es 14/08/32, que es la fecha equivalente en el calendario 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. Después, se usan miembros de DateTime y Calendar para devolver el día, el mes y el año del valor DateTime.Next, members of DateTime and Calendar are used to return the day, the month, and the year of the DateTime value. En cada caso, los valores devueltos por los miembros de DateTime reflejan los valores en el calendario gregoriano, mientras que los valores devueltos por los miembros de UmAlQuraCalendar reflejan los valores en el calendario Uum-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

Crear instancias de fechas basadas en un calendarioInstantiating dates based on a calendar

Puesto que los valores DateTime y DateTimeOffset se basan en el calendario gregoriano, debe llamar a un constructor sobrecargado que incluya un parámetro de tipo Calendar para crear instancias de un valor de fecha si desea usar los valores de día, mes o año de otro calendario.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. También puede llamar a una de las sobrecargas del método Calendar.ToDateTime de un calendario específico para crear instancias de un objeto DateTime basándose en los valores de un calendario determinado.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.

En el ejemplo siguiente se crean instancias de un valor DateTime pasando un objeto HebrewCalendar a un constructor DateTime y se crean instancias de un segundo valor DateTime llamando al 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 los dos valores se crean con valores idénticos del calendario hebreo, la llamada al método DateTime.Equals muestra que los dos valores DateTime son iguales.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

Que representa las fechas del calendario actualRepresenting dates in the current calendar

Los métodos de formato de fecha y hora siempre usan el calendario actual al convertir fechas en cadenas.Date and time formatting methods always use the current calendar when converting dates to strings. Esto significa que la representación de cadena del año, el mes y el día del mes refleja el calendario actual, y no refleja necesariamente el calendario 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.

En el ejemplo siguiente se muestra cómo afecta el calendario actual a la representación de cadena de una fecha.The following example shows how the current calendar affects the string representation of a date. Cambia la referencia cultural actual a Chino (tradicional, Taiwán) y crea instancias de un valor de fecha.It changes the current culture to Chinese (Traditional, Taiwan), and instantiates a date value. Después muestra el calendario actual y la fecha, cambia el calendario actual a TaiwanCalendar y vuelve a mostrar la fecha y el calendario actual.It then displays the current calendar and the date, changes the current calendar to TaiwanCalendar, and displays the current calendar and date once again. La primera vez que se muestra la fecha, se representa como una fecha del calendario gregoriano.The first time the date is displayed, it is represented as a date in the Gregorian calendar. La segunda vez que se muestra, se representa como una fecha del calendario taiwanés.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

Representar fechas en un calendario distinto del actualRepresenting dates in a non-current calendar

Para representar una fecha mediante un calendario que no es el calendario actual de una referencia cultural determinada, debe llamar a métodos de ese 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 ejemplo, los métodos Calendar.GetYear, Calendar.GetMonth y Calendar.GetDayOfMonth convierten el año, el mes y el día a los valores que reflejan un calendario determinado.For example, the Calendar.GetYear, Calendar.GetMonth, and Calendar.GetDayOfMonth methods convert the year, month, and day to values that reflect a particular calendar.

Advertencia

Puesto que algunos calendarios no son calendarios opcionales de ninguna referencia cultural, para representar fechas en estos calendarios siempre es necesario llamar a métodos de calendario.Because some calendars are not optional calendars of any culture, representing dates in these calendars always requires that you call calendar methods. Esto es cierto para todos los calendarios que se derivan de las clases EastAsianLunisolarCalendar, JulianCalendar y PersianCalendar.This is true of all calendars that derive from the EastAsianLunisolarCalendar, JulianCalendar, and PersianCalendar classes.

En el ejemplo siguiente se usa un objeto JulianCalendar para crear instancias de una fecha, el 9 de enero de 1905, en el calendario juliano.The following example uses a JulianCalendar object to instantiate a date, January 9, 1905, in the Julian calendar. Cuando esta fecha se muestra usando el calendario predeterminado (gregoriano), se representa como el 22 de enero de 1905.When this date is displayed using the default (Gregorian) calendar, it is represented as January 22, 1905. Las llamadas a métodos individuales de JulianCalendar permiten representar la fecha en el calendario 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

Calendarios e intervalos de fechasCalendars and date ranges

La fecha más temprana admitida por un calendario se indica mediante la propiedad Calendar.MinSupportedDateTime de dicho calendario.The earliest date supported by a calendar is indicated by that calendar's Calendar.MinSupportedDateTime property. Para la clase GregorianCalendar, esa fecha es el 1 de enero del año 1 de la era cristiana.For the GregorianCalendar class, that date is January 1, 0001 C.E. La mayoría del resto de calendarios de .NET admiten una fecha posterior.Most of the other calendars in .NET support a later date. Al intentar trabajar con un valor de fecha y hora anterior a la fecha compatible más temprana de un calendario, se produce una excepción ArgumentOutOfRangeException.Trying to work with a date and time value that precedes a calendar's earliest supported date throws an ArgumentOutOfRangeException exception.

Sin embargo, hay una excepción importante.However, there is one important exception. El valor (sin inicializar) predeterminado de un objeto DateTime y un objeto DateTimeOffset es igual al valor GregorianCalendar.MinSupportedDateTime.The default (uninitialized) value of a DateTime object and a DateTimeOffset object is equal to the GregorianCalendar.MinSupportedDateTime value. Si se intenta dar formato a esta fecha en un calendario que no se admite el 1 de enero de 0001 d. de c.If you try to format this date in a calendar that does not support January 1, 0001 C.E. y no proporciona un especificador de formato, el método de formato utiliza el especificador de formato "s" (patrón de fecha y hora que se puede ordenar) en lugar del especificador de formato "G" (patrón de fecha y hora general).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, la operación de formato no produce una excepción ArgumentOutOfRangeException.As a result, the formatting operation does not throw an ArgumentOutOfRangeException exception. En su lugar, devuelve la fecha no compatible.Instead, it returns the unsupported date. Esto se ilustra en el ejemplo siguiente, que muestra el valor de DateTime.MinValue cuando la referencia cultural actual se establece en japonés (Japón) con el calendario japonés y en árabe (Egipto) con el calendario 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. También establece la referencia cultural actual en inglés (Estados Unidos) y llama al método DateTime.ToString(IFormatProvider) con cada uno de estos 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. En cada caso, la fecha se muestra mediante el patrón de fecha y hora que se puede ordenar.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

Trabajar con erasWorking with eras

Los calendarios suelen dividir las fechas en eras.Calendars typically divide dates into eras. Sin embargo, el Calendar las clases de .NET no admiten todas las eras definidas por un calendario y la mayoría de los Calendar clases admiten solo una era.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. Únicamente las clases JapaneseCalendar y JapaneseLunisolarCalendar admiten varias eras.Only the JapaneseCalendar and JapaneseLunisolarCalendar classes support multiple eras.

Importante

La era Reiwa, una nueva era en el JapaneseCalendar y JapaneseLunisolarCalendar, comienza el 1 de mayo de 2019.The Reiwa era, a new era in the JapaneseCalendar and JapaneseLunisolarCalendar, begins on May 1, 2019. Este cambio afecta a todas las aplicaciones que usan estos calendarios.This change affects all applications that use these calendars. Consulte los siguientes artículos para obtener más información:See the following articles for more information:

Una era en la mayoría de los calendarios denota un período de tiempo extremadamente largo.An era in most calendars denotes an extremely long time period. En el calendario gregoriano, por ejemplo, la era actual abarca más de dos siglos.In the Gregorian calendar, for example, the current era spans more than two millennia. Para el JapaneseCalendar y JapaneseLunisolarCalendar, los dos calendarios que admiten varias eras, esto no es así.For the JapaneseCalendar and the JapaneseLunisolarCalendar, the two calendars that support multiple eras, this is not the case. Una era se corresponde con el período de un imperial del.An era corresponds to the period of an emperor's reign. Compatibilidad con varias eras, especialmente cuando el límite superior de la era actual es desconocido, plantea desafíos especiales.Support for multiple eras, particularly when the upper limit of the current era is unknown, poses special challenges.

Eras y nombres de eraEras and era names

En. NET, los enteros que representan las eras admitidas por una implementación de calendario determinada se almacenan en orden inverso en el Calendar.Eras matriz.In .NET, integers that represent the eras supported by a particular calendar implementation are stored in reverse order in the Calendar.Eras array. La era actual (que es la era con el intervalo de tiempo más reciente) está en el índice cero y para Calendar clases que admiten varias eras, cada índice sucesivo refleja la 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. La propiedad estática Calendar.CurrentEra define el índice de la era actual en la matriz de Calendar.Eras; es una constante cuyo valor es siempre cero.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. Las clases individuales de Calendar también incluyen campos estáticos que devuelven el valor de la era actual.Individual Calendar classes also include static fields that return the value of the current era. Se muestran en la tabla siguiente.They are listed in the following table.

Clase de calendarioCalendar class Campo de era actualCurrent era field
ChineseLunisolarCalendar ChineseEra
GregorianCalendar ADEra
HebrewCalendar HebrewEra
HijriCalendar HijriEra
JapaneseLunisolarCalendar JapaneseEra
JulianCalendar JulianEra
KoreanCalendar KoreanEra
KoreanLunisolarCalendar GregorianEra
PersianCalendar PersianEra
ThaiBuddhistCalendar ThaiBuddhistEra
UmAlQuraCalendar UmAlQuraEra

El nombre correspondiente a un número de era determinado se puede recuperar pasando el número de era al método DateTimeFormatInfo.GetEraName o 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. En el ejemplo siguiente se llama a estos métodos para recuperar información sobre la compatibilidad de eras de la clase GregorianCalendar.The following example calls these methods to retrieve information about era support in the GregorianCalendar class. Muestra la fecha del calendario gregoriano que corresponde al 1 de enero del segundo año de la era actual, así como la fecha del calendario gregoriano que corresponde al 1 de enero del segundo año de cada era compatible calendario japonés.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

Además, la cadena de formato de fecha y hora personalizado "g" incluye el nombre de era de un calendario en la representación de cadena de una fecha y 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 obtener más información, consulte cadenas con formato de fecha y hora personalizado.For more information, see Custom date and time format strings.

Crear una instancia de una fecha con una eraInstantiating a date with an era

Para las dos Calendar las clases que admiten varias eras, una fecha que consta de un determinado año, mes y día del valor de mes puede ser ambigua.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 ejemplo, todas las eras admitidas por el JapaneseCalendar años cuyo número es 1.For example, all eras supported by the JapaneseCalendar have years whose number is 1. Normalmente, si no se especifica ninguna era, los métodos de fecha y hora y de calendario suponen que los valores pertenecen a la era actual.Ordinarily, if an era is not specified, both date and time and calendar methods assume that values belong to the current era. Esto es así el DateTime y DateTimeOffset constructores que incluyen los parámetros de tipo Calendar, así como el JapaneseCalendar.ToDateTime y JapaneseLunisolarCalendar.ToDateTime métodos.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. El ejemplo siguiente se crea una instancia de una fecha que representa el 1 de enero del segundo año de una era no especificado.The following example instantiates a date that represents January 1 of the second year of an unspecified era. Si ejecuta el ejemplo cuando la era Reiwa es la era actual, la fecha se interpreta como el segundo año de la 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. La era, 令和, precede al año en la cadena devuelta por la DateTime.ToString(String, IFormatProvider) método y corresponde al 1 de enero de 2020, en el calendario 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. (La era Reiwa comienza en el año de 2019 del calendario 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

Sin embargo, si cambia la era, el propósito de este código pasa a ser ambiguo.However, if the era changes, the intent of this code becomes ambiguous. ¿Sirve la fecha para representar el segundo año de la era actual o está diseñado para representar el segundo año de la era 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? Hay dos formas de evitar esta ambigüedad:There are two ways to avoid this ambiguity:

  • Crear una instancia de valor de fecha y hora con el valor predeterminado GregorianCalendar clase.Instantiate the date and time value using the default GregorianCalendar class. A continuación, puede usar el calendario japonés o el calendario Lunisolar japonés para la representación de cadena de fechas, como se muestra en el ejemplo siguiente.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
    
    
    
  • Llamar a un método de fecha y hora que especifique explícitamente una era.Call a date and time method that explicitly specifies an era. Esto incluye los siguientes métodos:This includes the following methods:

    El ejemplo siguiente utiliza tres de estos métodos para crear instancias de una fecha y hora de la era Meiji, que comenzó en 8 de septiembre de 1868 y finalizó el 29 de julio 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
    

Sugerencia

Al trabajar con calendarios que admiten varias eras, siempre usar la fecha gregoriana para crear instancias de una fecha, o especificar la era al crear una instancia una fecha y hora en función de dicho calendario.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.

Especificar una era en la ToDateTime(Int32, Int32, Int32, Int32, Int32, Int32, Int32, Int32) método, proporciona el índice de la era en el calendario Eras propiedad.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. Para los calendarios cuyos eras están sujetos a cambios, sin embargo, estos índices no son valores constantes; es la era actual en el índice 0 y la era más antigua está en el í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. Cuando se agrega una nueva era en un calendario, los índices de las eras anteriores se incrementará en uno.When a new era is added to a calendar, the indexes of the previous eras increase by one. Puede proporcionar el índice era adecuada como sigue:You can supply the appropriate era index as follows:

Calendarios, eras e intervalos de fechas: Comprobaciones de intervalo moderadaCalendars, eras, and date ranges: Relaxed range checks

Mucho, como calendarios individuales han admitido los intervalos de fechas, eras de la JapaneseCalendar y JapaneseLunisolarCalendar clases también han admitido los intervalos.Very much like individual calendars have supported date ranges, eras in the JapaneseCalendar and JapaneseLunisolarCalendar classes also have supported ranges. Anteriormente, era strict range comprueba para asegurarse de que era una fecha específica de la era en el intervalo de aquella era utilizar .NET.Previously, .NET used strict era range checks to ensure that an era-specific date was within the range of that era. Es decir, si una fecha está fuera del intervalo de la era especificada, el método produce una ArgumentOutOfRangeException.That is, if a date is outside of the range of the specified era, the method throws an ArgumentOutOfRangeException. Actualmente, .NET usa la comprobación de intervalo moderada de forma predeterminada.Currently, .NET uses relaxed ranged checking by default. Las actualizaciones a todas las versiones de .NET introdujeron era moderada intervalo comprobaciones; el intento de crear instancias de una fecha específica era que está fuera del intervalo de la era especificada "desborda" en la siguiente era, y se produce ninguna excepción.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.

El ejemplo siguiente se intenta crear una instancia de una fecha del año de la era Showa, que comenzó en el 25 de diciembre de 1926 y finalizó el 7 de enero de 1989 65.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. Esta fecha corresponde al 9 de enero de 1990, que está fuera del intervalo de la era Showa el JapaneseCalendar.This date corresponds to January 9, 1990, which is outside the range of the Showa era in the JapaneseCalendar. Como se muestra el resultado del ejemplo siguiente, la fecha mostrada en el ejemplo es el 9 de enero de 1990, en el segundo año de la era 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

Si las comprobaciones de intervalo moderada son no deseadas, puede restaurar las comprobaciones de intervalo estricta de varias maneras, dependiendo de la versión de .NET en el que se está ejecutando la aplicación: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: Puede agregar lo siguiente a la . netcore.runtime.json archivo de configuración:.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 o posterior: Puede establecer el modificador de AppContext siguiente:.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 o versiones anteriores: Puede establecer el valor del registro siguiente:.NET Framework 4.5.2 or earlier: You can set the following registry value:

    KeyKey HKEY_LOCAL_MACHINE\Software\Microsoft.NETFramework\AppContextHKEY_LOCAL_MACHINE\Software\Microsoft.NETFramework\AppContext
    NameName Switch.System.Globalization.EnforceJapaneseEraYearRangesSwitch.System.Globalization.EnforceJapaneseEraYearRanges
    TipoType REG_SZREG_SZ
    ValorValue 11

Con las comprobaciones de intervalo strict habilitadas, el ejemplo anterior produce una ArgumentOutOfRangeException y muestra el siguiente resultado: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()

Representar fechas en calendarios con eras múltiplesRepresenting dates in calendars with multiple eras

Si un objeto Calendar admite eras y es el calendario actual de un objeto CultureInfo, la era se incluye en la representación de cadena de un valor de fecha y hora para los modelos de fecha y hora completa, fecha larga y fecha corta.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. En el ejemplo siguiente se muestran estos modelos de fecha cuando la referencia cultural actual es Japonés (Japón) y el calendario actual es el calendario 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 

Advertencia

El JapaneseCalendar clase es la única clase de calendario en .NET que admite fechas en más de una era y que puede ser el calendario actual de un CultureInfo objeto: en concreto, de un CultureInfo objeto que representa la referencia cultural japonés (Japón).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 los demás calendarios, el especificador de formato personalizado "g" incluye la era en la cadena de resultado.For all calendars, the "g" custom format specifier includes the era in the result string. En el ejemplo siguiente se usa la cadena de formato personalizada "MM-dd-yyyy g" para incluir la era en la cadena de resultado cuando el calendario actual es el calendario 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.      

En aquellos casos donde la representación de cadena de una fecha se expresa en un calendario que no es el actual, la clase Calendar incluye un método Calendar.GetEra que se puede usar junto con los métodos Calendar.GetYear, Calendar.GetMonth y Calendar.GetDayOfMonth para indicar de forma inequívoca una fecha y la era a la que pertenece.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. En el ejemplo siguiente se usa la clase JapaneseLunisolarCalendar para proporcionar una ilustración.The following example uses the JapaneseLunisolarCalendar class to provide an illustration. Sin embargo, tenga en cuenta que para incluir un nombre descriptivo o una abreviatura en lugar de un entero para la era en la cadena de resultado hay que crear una instancia de un objeto DateTimeFormatInfo y convertir JapaneseCalendar en su calendario actual.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. (El calendario JapaneseLunisolarCalendar no puede ser el calendario actual de ninguna referencia cultural, pero en este caso los dos calendarios comparten las mismas 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

En el calendario japonés, el primer año de una era se denomina Gannen (元年).In the Japanese calendars, the first year of an era is called Gannen (元年). Por ejemplo, en lugar de Heisei 1, el primer año de la era Heisei puede describirse como Heisei Gannen.For example, instead of Heisei 1, the first year of the Heisei era can be described as Heisei Gannen. .NET adopta esta convención para dar formato a las operaciones para las fechas y horas cadenas con formato con la siguiente fecha estándar o personalizado y el formato de hora cuando se usan con un CultureInfo objeto que representa la referencia cultural de japonés de Japón ("ja-JP") con el JapaneseCalendar clase:.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 ejemplo, en el ejemplo siguiente se muestra una fecha en el primer año de la era Heisei el 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)

Si este comportamiento no es deseable en operaciones de formato, puede restaurar el comportamiento anterior, que siempre representa el primer año de una era como "1" en lugar de "Gannen", mediante las acciones siguientes, dependiendo de la versión de. 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: Puede agregar lo siguiente a la . netcore.runtime.json archivo de configuración:.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 o posterior: Puede establecer el modificador de AppContext siguiente:.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 o versiones anteriores: Puede establecer el valor del registro siguiente:.NET Framework 4.5.2 or earlier: You can set the following registry value:

    KeyKey HKEY_LOCAL_MACHINE\Software\Microsoft.NETFramework\AppContextHKEY_LOCAL_MACHINE\Software\Microsoft.NETFramework\AppContext
    NameName Switch.System.Globalization.FormatJapaneseFirstYearAsANumberSwitch.System.Globalization.FormatJapaneseFirstYearAsANumber
    TipoType REG_SZREG_SZ
    ValorValue 11

Con compatibilidad gannen para dar formato a las operaciones deshabilitadas, el ejemplo anterior muestra el siguiente resultado: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)

.NET también se actualizó para que la fecha y hora en las operaciones de análisis admiten las cadenas que contienen el año que se representa como "1" o 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. Aunque no es necesario hacer esto, puede restaurar el comportamiento anterior a reconoce solo "1" como el primer año de una 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. Puede hacerlo como sigue, según la versión de. NET:You can do this as follows, depending on the version of .NET:

  • .NET Core: Puede agregar lo siguiente a la . netcore.runtime.json archivo de configuración:.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 o posterior: Puede establecer el modificador de AppContext siguiente:.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 o versiones anteriores: Puede establecer el valor del registro siguiente:.NET Framework 4.5.2 or earlier: You can set the following registry value:

    KeyKey HKEY_LOCAL_MACHINE\Software\Microsoft.NETFramework\AppContextHKEY_LOCAL_MACHINE\Software\Microsoft.NETFramework\AppContext
    NameName Switch.System.Globalization.EnforceLegacyJapaneseDateParsingSwitch.System.Globalization.EnforceLegacyJapaneseDateParsing
    TipoType REG_SZREG_SZ
    ValorValue 11

Vea tambiénSee also