Trabalhar com calendários

Artigo
08/01/2011

Embora um valor de data e hora representa um momento, sua representação de seqüência de caracteres é a cultura e depende tanto as convenções usadas para exibir os valores de data e hora por uma cultura específica e o calendário usado por essa cultura. Este tópico explora o suporte para calendários na.NET Framework e discute o uso das classes de calendário, ao trabalhar com valores de data.

Calendários na.NET Framework

Todos os calendários do.NET Framework derivam de System.Globalization.Calendar classe, que fornece a implementação do calendário base. Uma das classes que herda de Calendar classe é o EastAsianLunisolarCalendar classe, que é a classe base para todos os calendários lunisolar. A.NET Framework inclui as seguintes implementações de calendário:

ChineseLunisolarCalendar, que representa o calendário lunisolar chinês.
GregorianCalendar, que representa o calendário gregoriano. Este calendário é dividido em subtipos (como, por exemplo, árabe e francês do Oriente) que são definidos pelo System.Globalization.GregorianCalendarTypes enumeração. O GregorianCalendar.CalendarType propriedade especifica o subtipo do calendário gregoriano.
HebrewCalendar, que representa o calendário hebraico.
HijriCalendar, que representa o calendário islâmico.
JapaneseCalendar, que representa o calendário japonês.
JapaneseLunisolarCalendar, que representa o calendário lunisolar japonês.
JulianCalendar, que representa o calendário juliano.
KoreanCalendar, que representa o calendário coreano.
KoreanLunisolarCalendar, que representa o calendário lunisolar coreano.
PersianCalendar, que representa o calendário persa.
TaiwanCalendar, que representa o calendário de Taiwan.
TaiwanLunisolarCalendar, que representa o calendário de Taiwan lunisolar.
ThaiBuddhistCalendar, que representa o calendário budista tailandês.
UmAlQuraCalendar, que representa o calendário de Um Qura de Al.

Um calendário pode ser usado em uma das duas maneiras:

Como o calendário usado por uma cultura específica. Cada CultureInfo o objeto tem um calendário atual, que é o calendário que está usando o objeto. As representações de seqüência de caracteres de todos os valores de data e hora automaticamente refletem a cultura atual e o seu calendário atual. Normalmente, o calendário atual é o calendário do padrão da cultura. CultureInfoobjetos também possuem calendários opcionais, que incluem calendários adicionais que essa cultura pode usar.
Como um calendário de autônomos independente de uma cultura específica. Nesse caso, Calendar métodos são usados para expressar as datas como valores que refletem o calendário.

Observe que seis classes – de calendário ChineseLunisolarCalendar, JapaneseLunisolarCalendar, JulianCalendar, KoreanLunisolarCalendar, PersianCalendar, e TaiwanLunisolarCalendar – que podem ser usados apenas como autônomo calendários. Eles não são usados por qualquer cultura, como o calendário padrão ou como um calendário opcional.

Calendários e culturas

Cada cultura tem um calendário padrão, que é definido pelo CultureInfo.Calendar propriedade. O CultureInfo.OptionalCalendars propriedade retorna uma matriz de Calendar que especifica todos os calendários de objetos suportados por uma determinada cultura, incluindo o calendário padrão. da cultura

O exemplo a seguir ilustra o CultureInfo.Calendar e CultureInfo.OptionalCalendars Propriedades. Ele cria CultureInfo objetos para o tailandês (Tailândia) e as culturas do japonês (Japão) e exibe seu padrão e opcionais de calendários. Observe que em ambos os casos, calendário de padrão da cultura também está incluído no CultureInfo.OptionalCalendars coleção.

Imports System.Globalization

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

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

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

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

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

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

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

using System;
using System.Globalization;

public class Example
{
   public static void Main()
   {
      // Create a CultureInfo for Thai in Thailand.
      CultureInfo th = CultureInfo.CreateSpecificCulture("th-TH");
      DisplayCalendars(th);

      // Create a CultureInfo for Japanese in Japan.
      CultureInfo ja = CultureInfo.CreateSpecificCulture("ja-JP");
      DisplayCalendars(ja);
   }

   static void DisplayCalendars(CultureInfo ci)
   {
      Console.WriteLine("Calendars for the {0} culture:", ci.Name);

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

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

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

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

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

O calendário atualmente em uso por um determinado CultureInfo objeto é definido pela cultura DateTimeFormatInfo.Calendar propriedade. Uma cultura DateTimeFormatInfo retornado pelo objeto de CultureInfo.DateTimeFormat propriedade. Quando uma cultura é criada, seu valor padrão é o mesmo que o valor de CultureInfo.Calendar propriedade. No entanto, você pode alterar o calendário atual da cultura para qualquer calendário contido na matriz retornada pela CultureInfo.OptionalCalendars propriedade. Se você tentar definir o calendário atual para um calendário que não está incluído na CultureInfo.OptionalCalendars o valor de propriedade, um ArgumentException é lançada.

O exemplo a seguir altera o calendário usado pela cultura árabe (Arábia Saudita). Ele primeiro instancia um DateTime valor e exibe-o usando a cultura atual - o que, nesse caso, é o inglês (Estados Unidos) - e calendário a cultura atual (, nesse caso, é o calendário gregoriano). Em seguida, altera a cultura atual para árabe (Arábia Saudita) e exibe a data usando o seu calendário de Um Al-Qura padrão. Em seguida, chama o CalendarExists método para determinar se o calendário islâmico é suportado pela cultura árabe (Arábia Saudita). Como o calendário é suportado, ele altera o calendário islâmico e novamente exibe a data. Observe que em cada caso, a data é exibida usando o calendário atual da cultura atual.

Imports System.Globalization
Imports System.Threading

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Datas e calendários

Com exceção dos construtores de incluem um parâmetro do tipo Calendar e permitir que os elementos de uma data (isto é, o mês, dia e ano) que refletem os valores em um calendário designado, ambos DateTime e DateTimeOffset valores sempre são baseados no calendário gregoriano. Isso significa, por exemplo, que o DateTime.Year propriedade retorna o ano no calendário gregoriano e o DateTime.Day propriedade retorna o dia do mês no calendário gregoriano.

Importante
É importante lembrar que há uma diferença entre um valor de data e a sua representação de seqüência de caracteres.O primeiro é baseado no calendário gregoriano; Este último é baseado no calendário atual de uma cultura específica.

O exemplo a seguir ilustra essa diferença entre DateTime Propriedades e seus correspondentes Calendar métodos. No exemplo, a cultura atual é árabe (Egito) e o calendário atual for Um Qura de Al. A DateTime valor é definido como o décimo-quinto dia do sétimo mês do 2011. É claro que isso é interpretado como uma data do calendário gregoriano, porque esses mesmos valores são retornados pelo DateTime.ToString(String, IFormatProvider) método quando ele usa as convenções da cultura invariável. A representação de seqüência de caracteres da data que é formatada usando as convenções da cultura atual é 14/08/32, que é a data no calendário de Um Qura de Al equivalente. Avançar, membros da DateTime e Calendar são usadas para retornar o dia, mês e ano da DateTime valor. Em cada caso, os valores retornados por DateTime membros refletem os valores no calendário gregoriano, enquanto os valores retornados por UmAlQuraCalendar membros refletem os valores no calendário al-Qura Uum.

Imports System.Globalization
Imports System.Threading

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

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

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

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

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

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

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

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

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

public class Example
{
   public static void Main()
   {
      // Make Arabic (Egypt) the current culture 
      // and Umm al-Qura calendar the current calendar. 
      CultureInfo arEG = CultureInfo.CreateSpecificCulture("ar-EG");
      Calendar cal = new UmAlQuraCalendar();
      arEG.DateTimeFormat.Calendar = cal;
      Thread.CurrentThread.CurrentCulture = arEG;

      // Display information on current culture and calendar.
      DisplayCurrentInfo();      

      // Instantiate a date object.
      DateTime date1 = new DateTime(2011, 7, 15);

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

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

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

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

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

A instanciação de datas com base em um calendário

Porque DateTime e DateTimeOffset valores baseiam-se no calendário gregoriano, você deve chamar um construtor sobrecarregado que inclui um parâmetro do tipo Calendar para instanciar um valor de data, se você quiser usar o dia, mês ou valores de ano a partir de um calendário diferente. Você também pode chamar uma das sobrecargas de um calendário específico Calendar.ToDateTime método para instanciar um DateTime objeto com base nos valores de um calendário particular.

O exemplo a seguir instancia um DateTime valor passando um HebrewCalendar o objeto para um DateTime construtor e instancia uma segunda DateTime valor chamando o HebrewCalendar.ToDateTime(Int32, Int32, Int32, Int32, Int32, Int32, Int32, Int32) método. Porque os dois valores são criados com valores idênticos do hebraico calendário, a chamada para o DateTime.Equals método mostra que os dois DateTime os valores são iguais.

Imports System.Globalization

Module Example
   Public Sub Main()
      Dim hc As New HebrewCalendar()

      Dim date1 As New Date(5771, 6, 1, hc)
      Dim date2 As Date = hc.ToDateTime(5771, 6, 1, 0, 0, 0, 0)

      Console.WriteLine("{0:d} (Gregorian) = {1:d2}/{2:d2}/{3:d4} ({4}): {5}",
                        date1, 
                        hc.GetMonth(date2),
                        hc.GetDayOfMonth(date2),
                        hc.GetYear(date2), 
                        GetCalendarName(hc),
                        date1.Equals(date2))
   End Sub

   Private Function GetCalendarName(cal As Calendar) As String
      Return cal.ToString().Replace("System.Globalization.", ""). 
                            Replace("Calendar", "")
   End Function
End Module
' The example displays the following output:
'   2/5/2011 (Gregorian) = 06/01/5771 (Hebrew): True

using System;
using System.Globalization;

public class Example
{
   public static void Main()
   {
      HebrewCalendar hc = new HebrewCalendar();

      DateTime date1 = new DateTime(5771, 6, 1, hc);
      DateTime date2 = hc.ToDateTime(5771, 6, 1, 0, 0, 0, 0);

      Console.WriteLine("{0:d} (Gregorian) = {1:d2}/{2:d2}/{3:d4} ({4}): {5}",
                        date1, 
                        hc.GetMonth(date2),
                        hc.GetDayOfMonth(date2),
                        hc.GetYear(date2), 
                        GetCalendarName(hc),
                        date1.Equals(date2));
   }

   private static string GetCalendarName(Calendar cal)
   {
      return cal.ToString().Replace("System.Globalization.", ""). 
                            Replace("Calendar", "");
   }
}
// The example displays the following output:
//    2/5/2011 (Gregorian) = 06/01/5771 (Hebrew): True

Que representam datas no calendário atual

Data e hora formatação métodos sempre usam o calendário atual ao converter datas em seqüências de caracteres. Isso significa que a representação de seqüência de caracteres do ano, mês e dia do mês reflete o calendário atual e não necessariamente reflete o calendário gregoriano.

O exemplo a seguir mostra como o calendário atual afeta a representação de seqüência de caracteres de uma data. Altera a cultura atual para o chinês (tradicional, Taiwan) e instancia um valor de data. Em seguida, exibe a data e o calendário atual, altera o calendário atual para TaiwanCalendare exibe a data e o calendário atual novamente. Na primeira vez que a data é exibida, ela é representada como uma data no calendário gregoriano. Na segunda vez que for exibida, ela é representada como uma data no calendário de Taiwan.

Imports System.Globalization
Imports System.Threading

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

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

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

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

public class Example
{
   public static void Main()
   {
      // Change the current culture to zh-TW.
      CultureInfo zhTW = CultureInfo.CreateSpecificCulture("zh-TW");
      Thread.CurrentThread.CurrentCulture = zhTW;
      // Define a date.
      DateTime date1 = new DateTime(2011, 1, 16);

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

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

Que representam datas em um calendário não atual

Para representar uma data usando um calendário que não é o calendário atual de uma cultura específica, você deve chamar os métodos do que Calendar objeto. Por exemplo, o Calendar.GetYear, Calendar.GetMonth, e Calendar.GetDayOfMonth métodos convertem o ano, mês e o dia para valores que refletem um calendário particular.

Cuidado
Como alguns calendários não são os calendários opcionais de qualquer cultura, que representam datas desses calendários sempre requer que você chamar os métodos de calendário.Isso é verdadeiro para todos os calendários que derivam de EastAsianLunisolarCalendar, JulianCalendar, e PersianCalendar classes.

O exemplo a seguir utiliza um JulianCalendar o objeto para instanciar uma data de 9 de janeiro, 1905, no calendário juliano. Quando essa data é exibida usando o calendário padrão (Gregoriano), ela é representada como 22 de janeiro de 1905. Chamadas individuais para JulianCalendar métodos permitem a data a ser representada no calendário juliano.

Imports System.Globalization

Module Example
   Public Sub Main()
      Dim julian As New JulianCalendar()
      Dim date1 As New Date(1905, 1, 9, julian)

      Console.WriteLine("Date ({0}): {1:d}", 
                        CultureInfo.CurrentCulture.Calendar,
                        date1)
      Console.WriteLine("Date in Julian calendar: {0:d2}/{1:d2}/{2:d4}",
                        julian.GetMonth(date1),
                        julian.GetDayOfMonth(date1),
                        julian.GetYear(date1))
   End Sub
End Module
' The example displays the following output:
'    Date (System.Globalization.GregorianCalendar): 1/22/1905
'    Date in Julian calendar: 01/09/1905

using System;
using System.Globalization;

public class Example
{
   public static void Main()
   {
      JulianCalendar julian = new JulianCalendar();
      DateTime date1 = new DateTime(1905, 1, 9, julian);

      Console.WriteLine("Date ({0}): {1:d}", 
                        CultureInfo.CurrentCulture.Calendar,
                        date1);
      Console.WriteLine("Date in Julian calendar: {0:d2}/{1:d2}/{2:d4}",
                        julian.GetMonth(date1),
                        julian.GetDayOfMonth(date1),
                        julian.GetYear(date1));
   }
}
// The example displays the following output:
//    Date (System.Globalization.GregorianCalendar): 1/22/1905
//    Date in Julian calendar: 01/09/1905

Trabalhando com Eras

Normalmente, a calendários dividem as datas em eras. No entanto, o Calendar de classes do.NET Framework não oferecem suporte a cada era definido por um calendário e a maior parte do Calendar classes suportam apenas um único era. Somente o JapaneseCalendar e JapaneseLunisolarCalendar classes dão suporte a vários eras.

Eras e Era nomes

No.NET Framework, números inteiros que representam as eras suportadas por uma implementação específica do calendário são armazenados na ordem inversa na Calendar.Eras matriz. A era atual está no índice zero e para Calendar classes que oferecem suporte a vários eras, cada índice sucessiva reflete era anterior. Estática Calendar.CurrentEra propriedade define o índice da era atual na Calendar.Eras array; é uma constante cujo valor é sempre zero. Individual Calendar classes também incluem campos estáticos que retornam o valor da era atual. Eles são listados na tabela a seguir.

Classe Calendar	Campo de era atual
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 era específico pode ser recuperado, passando o número era para a DateTimeFormatInfo.GetEraName ou DateTimeFormatInfo.GetAbbreviatedEraName método. O exemplo a seguir chama esses métodos para recuperar informações sobre o suporte era a GregorianCalendar classe.

Imports System.Globalization

Module Example
   Public Sub Main()
      Dim year As Integer = 2
      Dim month As Integer = 1
      Dim day As Integer = 1
      Dim cal As New JapaneseCalendar()

      Console.WriteLine("Date instantiated without an era:")
      Dim date1 As New Date(year, month, day, 0, 0, 0, 0, cal)
      Console.WriteLine("{0}/{1}/{2} in Japanese Calendar -> {3:d} in Gregorian", 
                        cal.GetMonth(date1), cal.GetDayOfMonth(date1),
                        cal.GetYear(date1), date1)
      Console.WriteLine()

      Console.WriteLine("Dates instantiated with eras:")
      For Each era As Integer In cal.Eras
         Dim date2 As Date = cal.ToDateTime(year, month, day, 0, 0, 0, 0, era)
         Console.WriteLine("{0}/{1}/{2} era {3} in Japanese Calendar -> {4:d} in Gregorian", 
                           cal.GetMonth(date2), cal.GetDayOfMonth(date2),
                           cal.GetYear(date2), cal.GetEra(date2), date2)
      Next                        
   End Sub
End Module
' The example displays the following output:
'    Date instantiated without an era:
'    1/1/2 in Japanese Calendar -> 1/1/1990 in Gregorian
'    
'    Dates instantiated with eras:
'    1/1/2 era 4 in Japanese Calendar -> 1/1/1990 in Gregorian
'    1/1/2 era 3 in Japanese Calendar -> 1/1/1927 in Gregorian
'    1/1/2 era 2 in Japanese Calendar -> 1/1/1913 in Gregorian
'    1/1/2 era 1 in Japanese Calendar -> 1/1/1869 in Gregorian

using System;
using System.Globalization;

public class Example
{
   public static void Main()
   {
      int year = 2;
      int month = 1;
      int day = 1;
      Calendar cal = new JapaneseCalendar();

      Console.WriteLine("\nDate instantiated without an era:");
      DateTime date1 = new DateTime(year, month, day, 0, 0, 0, 0, cal);
      Console.WriteLine("{0}/{1}/{2} in Japanese Calendar -> {3:d} in Gregorian", 
                        cal.GetMonth(date1), cal.GetDayOfMonth(date1),
                        cal.GetYear(date1), date1);

      Console.WriteLine("\nDates instantiated with eras:");
      foreach (int era in cal.Eras) {
         DateTime date2 = cal.ToDateTime(year, month, day, 0, 0, 0, 0, era);
         Console.WriteLine("{0}/{1}/{2} era {3} in Japanese Calendar -> {4:d} in Gregorian", 
                           cal.GetMonth(date2), cal.GetDayOfMonth(date2),
                           cal.GetYear(date2), cal.GetEra(date2), date2);
      }                        
   }
}
// The example displays the following output:
//    Date instantiated without an era:
//    1/1/2 in Japanese Calendar -> 1/1/1990 in Gregorian
//    
//    Dates instantiated with eras:
//    1/1/2 era 4 in Japanese Calendar -> 1/1/1990 in Gregorian
//    1/1/2 era 3 in Japanese Calendar -> 1/1/1927 in Gregorian
//    1/1/2 era 2 in Japanese Calendar -> 1/1/1913 in Gregorian
//    1/1/2 era 1 in Japanese Calendar -> 1/1/1869 in Gregorian

Além disso, "g" Data e hora de formatar personalizadas string inclui nome do calendário de era a representação de seqüência de caracteres de uma data e hora. Para obter mais informações, consulte Sequências de Caracteres de Formato Personalizado de Data e Hora.

Criar uma instância de uma data com uma época

Para as duas Calendar classes que oferecem suporte a vários eras, uma data que consiste em um determinado ano, mês e dia do mês em que o valor pode ser ambíguo, por exemplo, todas as quatro eras da JapaneseCalendar têm anos numerados de 1 a 15. Normalmente, se uma época não for especificada, os métodos de data e hora e calendário pressupõem que os valores pertencem a era atual. Especificar explicitamente a era ao instanciar uma data para uma Calendar classe oferece suporte a vários eras, você pode chamar o Calendar.ToDateTime(Int32, Int32, Int32, Int32, Int32, Int32, Int32, Int32) método. Esse método permite que você especificar explicitamente uma época junto com o calendário ano, mês, dia, hora, minuto, segundo e milissegundos.

O exemplo a seguir usa a Calendar.ToDateTime(Int32, Int32, Int32, Int32, Int32, Int32, Int32, Int32) método para instanciar a mesma data, o primeiro mês do primeiro dia do segundo ano, cada era suportado pelo JapaneseCalendar classe. Ele exibe a data em calendários o japonês e o calendário gregoriano. Ele também chama um DateTime construtor para ilustrar que métodos que criar valores de data sem especificar uma era criar datas na era atual.

Imports System.Globalization

Module Example
   Public Sub Main()
      Dim year As Integer = 2
      Dim month As Integer = 1
      Dim day As Integer = 1
      Dim cal As New JapaneseCalendar()

      Console.WriteLine("Date instantiated without an era:")
      Dim date1 As New Date(year, month, day, 0, 0, 0, 0, cal)
      Console.WriteLine("{0}/{1}/{2} in Japanese Calendar -> {3:d} in Gregorian", 
                        cal.GetMonth(date1), cal.GetDayOfMonth(date1),
                        cal.GetYear(date1), date1)
      Console.WriteLine()

      Console.WriteLine("Dates instantiated with eras:")
      For Each era As Integer In cal.Eras
         Dim date2 As Date = cal.ToDateTime(year, month, day, 0, 0, 0, 0, era)
         Console.WriteLine("{0}/{1}/{2} era {3} in Japanese Calendar -> {4:d} in Gregorian", 
                           cal.GetMonth(date2), cal.GetDayOfMonth(date2),
                           cal.GetYear(date2), cal.GetEra(date2), date2)
      Next                        
   End Sub
End Module
' The example displays the following output:
'    Date instantiated without an era:
'    1/1/2 in Japanese Calendar -> 1/1/1990 in Gregorian
'    
'    Dates instantiated with eras:
'    1/1/2 era 4 in Japanese Calendar -> 1/1/1990 in Gregorian
'    1/1/2 era 3 in Japanese Calendar -> 1/1/1927 in Gregorian
'    1/1/2 era 2 in Japanese Calendar -> 1/1/1913 in Gregorian
'    1/1/2 era 1 in Japanese Calendar -> 1/1/1869 in Gregorian

using System;
using System.Globalization;

public class Example
{
   public static void Main()
   {
      int year = 2;
      int month = 1;
      int day = 1;
      Calendar cal = new JapaneseCalendar();

      Console.WriteLine("\nDate instantiated without an era:");
      DateTime date1 = new DateTime(year, month, day, 0, 0, 0, 0, cal);
      Console.WriteLine("{0}/{1}/{2} in Japanese Calendar -> {3:d} in Gregorian", 
                        cal.GetMonth(date1), cal.GetDayOfMonth(date1),
                        cal.GetYear(date1), date1);

      Console.WriteLine("\nDates instantiated with eras:");
      foreach (int era in cal.Eras) {
         DateTime date2 = cal.ToDateTime(year, month, day, 0, 0, 0, 0, era);
         Console.WriteLine("{0}/{1}/{2} era {3} in Japanese Calendar -> {4:d} in Gregorian", 
                           cal.GetMonth(date2), cal.GetDayOfMonth(date2),
                           cal.GetYear(date2), cal.GetEra(date2), date2);
      }                        
   }
}
// The example displays the following output:
//    Date instantiated without an era:
//    1/1/2 in Japanese Calendar -> 1/1/1990 in Gregorian
//    
//    Dates instantiated with eras:
//    1/1/2 era 4 in Japanese Calendar -> 1/1/1990 in Gregorian
//    1/1/2 era 3 in Japanese Calendar -> 1/1/1927 in Gregorian
//    1/1/2 era 2 in Japanese Calendar -> 1/1/1913 in Gregorian
//    1/1/2 era 1 in Japanese Calendar -> 1/1/1869 in Gregorian

Que representam datas em calendários com Eras

Se um Calendar objeto oferece suporte a eras e o calendário atual de um CultureInfo o objeto, era está incluída na representação de seqüência de caracteres de um valor de data e hora para o total data e hora, data por extenso e padrões de data abreviada. O exemplo a seguir exibe esses padrões de data quando a cultura atual é Japão (japonês) e o calendário atual for o calendário japonês.

Imports System.Globalization
Imports System.IO
Imports System.Threading

Module Example
   Public Sub Main()
      Dim sw As New StreamWriter(".\eras.txt")
      Dim dt As Date = #05/01/2012#

      Dim culture As CultureInfo = CultureInfo.CreateSpecificCulture("ja-JP")
      Dim dtfi As DateTimeFormatInfo = culture.DateTimeFormat
      dtfi.Calendar = New JapaneseCalendar()
      Thread.CurrentThread.CurrentCulture = culture

      sw.WriteLine("{0,-43} {1}", "Full Date and Time Pattern:", dtfi.FullDateTimePattern)
      sw.WriteLine(dt.ToString("F"))
      sw.WriteLine()

      sw.WriteLine("{0,-43} {1}", "Long Date Pattern:", dtfi.LongDatePattern)
      sw.WriteLine(dt.ToString("D"))
      sw.WriteLine()

      sw.WriteLine("{0,-43} {1}", "Short Date Pattern:", dtfi.ShortDatePattern)
      sw.WriteLine(dt.ToString("d"))
      sw.WriteLine()
      sw.Close()
   End Sub
End Module
' The example writes the following output to a file:
'    Full Date and Time Pattern:                 gg y'年'M'月'd'日' H:mm:ss
'    平成 24年5月1日 0:00:00
'    
'    Long Date Pattern:                          gg y'年'M'月'd'日'
'    平成 24年5月1日
'    
'    Short Date Pattern:                         gg y/M/d
'    平成 24/5/1

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

public class Example
{
   public static void Main()
   {
      StreamWriter sw = new StreamWriter(@".\eras.txt");
      DateTime dt = new DateTime(2012, 5, 1);

      CultureInfo culture = CultureInfo.CreateSpecificCulture("ja-JP");
      DateTimeFormatInfo dtfi = culture.DateTimeFormat;
      dtfi.Calendar = new JapaneseCalendar();
      Thread.CurrentThread.CurrentCulture = culture;

      sw.WriteLine("\n{0,-43} {1}", "Full Date and Time Pattern:", dtfi.FullDateTimePattern);
      sw.WriteLine(dt.ToString("F"));
      sw.WriteLine();

      sw.WriteLine("\n{0,-43} {1}", "Long Date Pattern:", dtfi.LongDatePattern);
      sw.WriteLine(dt.ToString("D"));

      sw.WriteLine("\n{0,-43} {1}", "Short Date Pattern:", dtfi.ShortDatePattern);
      sw.WriteLine(dt.ToString("d"));
      sw.Close();
    }
}
// The example writes the following output to a file:
//    Full Date and Time Pattern:                 gg y'年'M'月'd'日' H:mm:ss
//    平成 24年5月1日 0:00:00
//    
//    Long Date Pattern:                          gg y'年'M'月'd'日'
//    平成 24年5月1日
//    
//    Short Date Pattern:                         gg y/M/d
//    平成 24/5/1

Cuidado
O JapaneseCalendar classe é a única classe de calendário na.NET Framework que oferece suporte a ambas as datas em mais de uma época e que pode ser o calendário atual de um CultureInfo objeto - especificamente, de um CultureInfo objeto que representa a cultura do japonês (Japão).

Para todos os calendários, "g" o especificador de formato personalizado inclui era na seqüência de resultado. O exemplo a seguir usa o g"dd-mm-aaaa" seqüência de caracteres de formato personalizado para incluir a era na seqüência de resultado quando o calendário atual é o calendário gregoriano.

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

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

Em casos onde a representação de seqüência de caracteres de uma data é expresso em um calendário que não é o calendário atual, o Calendar classe inclui uma Calendar.GetEra método pode ser usado juntamente com o Calendar.GetYear, Calendar.GetMonth, e Calendar.GetDayOfMonth métodos de forma não ambígua indicar uma data, bem como a era ao qual ele pertence. O exemplo a seguir usa a JapaneseLunisolarCalendar classe para fornecer uma ilustração. No entanto, observe que incluindo um nome significativo ou abreviação ao invés de um número inteiro para a era na seqüência de resultado requer que você instancia um DateTimeFormatInfo de objeto e fazer JapaneseCalendar seu calendário atual. (O JapaneseLunisolarCalendar calendário não pode ser o calendário atual de qualquer cultura, mas nesse caso, os dois calendários compartilham o mesmo eras.)

Imports System.Globalization

Module Example
   Public Sub Main()
      Dim date1 As Date = #8/28/2011#
      Dim cal As New JapaneseLunisolarCalendar()
      Console.WriteLine("{0} {1:d4}/{2:d2}/{3:d2}", 
                        cal.GetEra(date1),
                        cal.GetYear(date1),
                        cal.GetMonth(date1),
                        cal.GetDayOfMonth(date1)) 

      ' Display eras
      Dim culture As CultureInfo = CultureInfo.CreateSpecificCulture("ja-JP")
      Dim dtfi As DateTimeFormatInfo = culture.DateTimeFormat
      dtfi.Calendar = New JapaneseCalendar()

      Console.WriteLine("{0} {1:d4}/{2:d2}/{3:d2}", 
                        dtfi.GetAbbreviatedEraName(cal.GetEra(date1)),
                        cal.GetYear(date1),
                        cal.GetMonth(date1),
                        cal.GetDayOfMonth(date1)) 
   End Sub
End Module
' The example displays the following output:
'       4 0023/07/29
'       平 0023/07/29

using System;
using System.Globalization;

public class Example
{
   public static void Main()
   {
      DateTime date1 = new DateTime(2011, 8, 28);
      Calendar cal = new JapaneseLunisolarCalendar();

      Console.WriteLine("{0} {1:d4}/{2:d2}/{3:d2}", 
                        cal.GetEra(date1),
                        cal.GetYear(date1),
                        cal.GetMonth(date1),
                        cal.GetDayOfMonth(date1)); 

      // Display eras
      CultureInfo culture = CultureInfo.CreateSpecificCulture("ja-JP");
      DateTimeFormatInfo dtfi = culture.DateTimeFormat;
      dtfi.Calendar = new JapaneseCalendar();

      Console.WriteLine("{0} {1:d4}/{2:d2}/{3:d2}", 
                        dtfi.GetAbbreviatedEraName(cal.GetEra(date1)),
                        cal.GetYear(date1),
                        cal.GetMonth(date1),
                        cal.GetDayOfMonth(date1)); 
   }
}
// The example displays the following output:
//       4 0023/07/29
//       平 0023/07/29

Consulte também

Tarefas

Como: Exibir datas em calendários não gregorianos

Histórico de alterações

Date	History	Motivo
Setembro de 2010	Revisado exaustivamente.	Aprimoramento de informações.

Setembro de 2010

Revisado exaustivamente.

Aprimoramento de informações.

Partilhar via