달력 작업

날짜 및 시간 값은 시간에서 변하지 않는 어느 한 시점을 나타내지만 이에 대한 문자열 표현은 문화권에 따라 달라지며 특정 문화권에서 날짜 및 시간 값을 표시하는 데 사용되는 규칙과 해당 문화권에서 사용하는 달력에 따라 달라집니다. 이 항목에서는 .NET에서 지원되는 달력을 알아보고 날짜 값을 사용할 때 달력 클래스를 사용하는 방법에 대해 설명합니다.

.NET의 달력

NET의 모든 달력은 기본 달력 구현을 제공하는 System.Globalization.Calendar 클래스에서 파생됩니다. Calendar 클래스로부터 상속되는 클래스 중 하나는 모든 음력 달력의 기본 클래스인 EastAsianLunisolarCalendar 클래스입니다. .NET에는 다음과 같은 달력 구현이 포함되어 있습니다.

• ChineseLunisolarCalendar는 중국식 음력 달력을 나타냅니다.

• GregorianCalendar는 그레고리오력을 나타냅니다. 이 달력은 다시 System.Globalization.GregorianCalendarTypes 열거형으로 정의되는 하위 유형으로 세분화됩니다(예: 아랍어 및 중동 프랑스어). GregorianCalendar.CalendarType 속성은 그레고리오력 달력의 하위 유형을 지정합니다.

• HebrewCalendar는 히브리어 달력을 나타냅니다.

• HijriCalendar는 회교식 달력을 나타냅니다.

• JapaneseCalendar는 일본식 달력을 나타냅니다.

• JapaneseLunisolarCalendar는 일본식 음력 달력을 나타냅니다.

• JulianCalendar는 율리우스력을 나타냅니다.

• KoreanCalendar는 한국식 달력을 나타냅니다.

• KoreanLunisolarCalendar는 한국식 음력 달력을 나타냅니다.

• PersianCalendar는 페르시아력을 나타냅니다.

• TaiwanCalendar는 대만식 달력을 나타냅니다.

• TaiwanLunisolarCalendar는 대만식 음력 달력을 나타냅니다.

• ThaiBuddhistCalendar는 태국 불교식 달력을 나타냅니다.

• UmAlQuraCalendar는 사우디아라비아 회교식(Um Al Qura) 달력을 나타냅니다.

달력은 다음 두 가지 방법 중 하나로 사용할 수 있습니다.

• 특정 문화권에서 사용되는 달력. 각 CultureInfo 개체에는 해당 개체가 현재 사용 중인 달력인 현재 달력이 포함됩니다. 모든 날짜 및 시간 값에 대한 문자열 표현에는 자동으로 현재 문화권과 현재 달력이 반영됩니다. 일반적으로 현재 달력은 해당 문화권의 기본 달력입니다. CultureInfo 개체에는 문화권에서 사용할 수 있는 추가 달력을 포함하는 달력(선택 사항)도 있습니다.

• 특정 문화권과 관계가 없는 독립 실행형 달력. 이 경우에는 달력을 반영한 값으로 날짜를 표시하기 위해 Calendar 메서드가 사용됩니다.

6개의 달력 클래스 ChineseLunisolarCalendar, JapaneseLunisolarCalendar, JulianCalendar, KoreanLunisolarCalendar, PersianCalendar 및 TaiwanLunisolarCalendar는 독립 실행형 달력으로만 사용할 수 있습니다. 이러한 달력은 어떤 문화권에서도 기본 달력이나 선택적인 달력으로 사용되지 않습니다.

달력 및 문화권

각 문화권에는 CultureInfo.Calendar 속성으로 정의되는 기본 달력이 포함됩니다. CultureInfo.OptionalCalendars 속성은 특정 문화권의 기본 달력을 포함하여 해당 문화권에서 지원되는 모든 달력을 지정하는 Calendar 개체의 배열을 반환합니다.

다음 예제에서는 CultureInfo.Calendar 및 CultureInfo.OptionalCalendars 속성에 대해 설명합니다. 이 예제에서는 태국어(태국) 및 일본어(일본) 문화권에 대해 CultureInfo 개체를 만들고 기본 달력과 선택적인 달력을 표시합니다. 두 경우 모두 해당 문화권의 기본 달력이 CultureInfo.OptionalCalendars 컬렉션에도 포함됩니다.

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)

특정 CultureInfo 개체에서 현재 사용되는 달력은 해당 문화권의 DateTimeFormatInfo.Calendar 속성에 의해 정의됩니다. 문화권의 DateTimeFormatInfo 개체는 CultureInfo.DateTimeFormat 속성에 의해 반환됩니다. 문화권을 만들 때 기본값은 CultureInfo.Calendar 속성의 값과 동일합니다. 하지만 문화권의 현재 달력을 CultureInfo.OptionalCalendars 속성으로 반환된 배열에 포함된 임의의 달력으로 변경할 수 있습니다. 현재 달력을 CultureInfo.OptionalCalendars 속성 값에 포함되지 않은 달력으로 설정하려고 하면 ArgumentException이 throw됩니다.

다음 예제에서는 아랍어(사우디아라비아) 문화권에서 사용되는 달력을 변경합니다. 먼저 DateTime 값을 인스턴스화하고 현재 문화권(이 경우에는 영어(미국))과 현재 문화권의 달력(그레고리오력)을 사용하여 표시합니다. 그런 다음 현재 문화권을 아랍어(사우디아라비아)로 변경하고 기본값인 우말쿠라 달력을 사용하여 날짜를 표시합니다. 그런 다음 CalendarExists 메서드를 호출하여 회교식 달력이 아랍어(사우디아라비아) 문화권에서 지원되는지 확인합니다. 이 달력이 지원되므로 현재 달력을 회교식 달력으로 변경하고 다시 날짜를 표시합니다. 각각의 경우에 날짜는 현재 문화권의 현재 달력을 사용하여 표시됩니다.

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

날짜 및 달력

Calendar 형식의 매개 변수를 포함하고 날짜 요소(즉, 월, 일 및 연도)가 지정된 달력의 값을 반영하도록 허용하는 생성자를 제외하면 DateTime 및 DateTimeOffset 값 모두 항상 그레고리오력을 기반으로 합니다. 예를 들어 DateTime.Year 속성은 그레고리오력으로 연도를 반환하고 DateTime.Day 속성은 그레고리오력에서 특정 월의 일을 반환합니다.

Important

날짜 값과 날짜 값의 문자열 표현은 서로 다르다는 점에 주의해야 합니다. 날짜 값은 그레고리오력을 기반으로 하지만 날짜 값의 표현은 특정 문화권의 현재 달력을 기반으로 합니다.

다음 예제에서는 DateTime 속성과 이러한 속성의 해당 Calendar 메서드 간의 차이점을 보여 줍니다. 이 예제에서 문화권은 아랍어(이집트)이고 현재 달력은 우말쿠라입니다. DateTime 값은 2011년의 7번째 월에서 15번째 일로 설정되어 있습니다. 변하지 않는 문화권의 규칙을 사용할 경우 동일한 값이 DateTime.ToString(String, IFormatProvider) 메서드로 반환되기 때문에 이 값은 그레고리오력 날짜로 해석되는 것이 분명합니다. 현재 문화권의 규칙을 사용하여 서식이 지정된 날짜의 문자열 표현은 우말쿠라 달력의 날짜와 동일한 14/08/32입니다. 그런 다음 DateTime 및 Calendar의 멤버를 사용하여 DateTime 값의 일, 월 및 연도를 반환합니다. 각각의 경우에 DateTime 멤버로 반환되는 값에는 그레고리오력의 값이 반영되지만 UmAlQuraCalendar 멤버로 반환되는 값에는 우말쿠라 달력의 값이 반영됩니다.

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

달력을 기반으로 날짜 인스턴스화

DateTime 및 DateTimeOffset 값은 그레고리오력을 기반으로 하기 때문에 다른 달력에서 일, 월 또는 연도 값을 사용하려면 Calendar 형식의 매개 변수를 포함하는 오버로드된 생성자를 호출하여 날짜 값을 인스턴스화해야 합니다. 특정 달력의 Calendar.ToDateTime 메서드의 오버로드 중 하나를 호출하여 특정 달력의 값을 기반으로 DateTime 개체를 인스턴스화할 수도 있습니다.

다음 예제에서는 DateTime 개체를 HebrewCalendar 생성자에 전달하여 하나의 DateTime 값을 인스턴스화하고 DateTime 메서드를 호출하여 두 번째 HebrewCalendar.ToDateTime(Int32, Int32, Int32, Int32, Int32, Int32, Int32, Int32) 값을 인스턴스화합니다. 두 값은 히브리식 달력에서 동일한 값을 사용하여 만들어졌기 때문에 DateTime.Equals 메서드를 호출하면 두 DateTime 값이 동일한 것으로 표시됩니다.

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

현재 달력의 날짜 표시

날짜 및 시간 서식을 지정하는 메서드는 날짜를 문자열로 변환할 때 항상 현재 달력을 사용합니다. 즉, 연도, 월 및 월의 일에 대한 문자열 표현에는 현재 달력이 반영되며, 그레고리오력이 반드시 반영되지는 않습니다.

다음 예제에서는 현재 달력이 날짜의 문자열 표현에 어떤 영향을 주는지 보여 줍니다. 여기에서는 현재 문화권을 중국어(번체, 대만)로 변경하고 날짜 값을 인스턴스화합니다. 그런 다음 현재 달력과 날짜를 표시하고, 현재 달력을 TaiwanCalendar로 변경한 후 현재 달력 및 날짜를 다시 한 번 표시합니다. 날짜가 처음 표시될 때는 그레고리오력의 날짜로 표시됩니다. 두 번째 표시될 때는 대만 달력의 날짜로 표시됩니다.

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

현재가 아닌 달력의 날짜 표시

특정 문화권의 현재 달력이 아닌 달력을 사용하여 날짜를 표시하려면 해당 Calendar 개체의 메서드를 호출해야 합니다. 예를 들어 Calendar.GetYear, Calendar.GetMonth 및 Calendar.GetDayOfMonth 메서드는 연도, 월 및 일을 특정 달력을 반영하는 값으로 변환합니다.

Warning

일부 달력은 특정 문화권에서 선택적인 달력이 아니기 때문에 이러한 달력으로 날짜를 표시하려면 항상 달력 메서드를 호출해야 합니다. 이러한 제한은 EastAsianLunisolarCalendar, JulianCalendar 및 PersianCalendar 클래스에서 파생되는 모든 달력에 적용됩니다.

다음 예제에서는 JulianCalendar 개체를 사용하여 율리우스력의 1905년 1월 9일 날짜를 인스턴스화합니다. 이 날짜를 기본(그레고리오력) 달력을 사용하여 표시하면 1905년 1월 22일로 표시됩니다. 개별 JulianCalendar 메서드를 호출하면 날짜를 율리우스력으로 표시할 수 있습니다.

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

달력 및 날짜 범위

달력에서 지원하는 가장 빠른 날짜는 그 달력의 Calendar.MinSupportedDateTime 속성에 의해 표시됩니다. GregorianCalendar 클래스의 경우 그 날짜는 서기 0001년 1월 1일입니다. .NET의 다른 대부분의 달력은 이후 날짜를 지원합니다. 달력에서 지원하는 가장 빠른 날짜에 앞서는 날짜 및 시간 값을 사용하려고 하면 ArgumentOutOfRangeException 예외가 발생합니다.

그러나 한 가지 중요한 예외가 있습니다. DateTime 개체와 DateTimeOffset 개체의 (초기화되지 않은) 기본값은 GregorianCalendar.MinSupportedDateTime 값과 같습니다. 서기 0001년 1월 1일을 지원하지 않는 달력에서 이 날짜의 형식을 지정하면서 형식 지정자를 제공하지 않으면 형식 지정 메서드가 “G”(일반 날짜/시간 패턴) 형식 지정자 대신 지정된 “s”(정렬 가능한 날짜/시간 패턴) 형식을 사용합니다. 따라서 형식 지정 작업에서 ArgumentOutOfRangeException 예외가 발생하지 않습니다. 대신, 지원되지 않는 날짜를 반환합니다. 이 점은 다음 예제에 설명되어 있습니다. 즉, 현재 문화권이 일본식 달력을 사용하는 일본어(일본)와 우말쿠라 달력을 사용하는 아랍어(이집트)로 설정되어 있을 때 DateTime.MinValue의 값을 표시합니다. 현재 문화권을 영어(미국)로도 설정하고 이런 각각의 DateTime.ToString(IFormatProvider) 개체와 함께 CultureInfo 메서드를 호출합니다. 각각의 경우, 날짜는 정렬 가능한 날짜/시간 패턴을 사용하여 표시됩니다.

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

시대 작업

달력에서 날짜는 일반적으로 연대로 구분됩니다. 그러나 .NET의 Calendar 클래스는 달력에 정의된 모든 시대를 지원하지 않으며, 대부분의 Calendar 클래스는 단일 시대만 지원합니다. JapaneseCalendar 및 JapaneseLunisolarCalendar 클래스에서만 여러 연대가 지원됩니다.

Important

JapaneseCalendar 및 JapaneseLunisolarCalendar의 새로운 시대인 레이와 시대는 2019년 5월 1일에 시작됩니다. 이번 변경 내용은 달력을 사용하는 모든 애플리케이션에 영향을 줍니다. 자세한 내용은 다음 아티클을 참조하세요.

• .NET에서 일본 달력의 새 시대 처리는 여러 시대가 포함된 달력을 지원하기 위해 .NET에 추가된 기능을 문서화하고 여러 시대 달력을 처리할 때 사용할 모범 사례를 논의합니다.
• 일본 시대 변화에 맞게 애플리케이션을 준비하세요. 시대 변화에 대한 준비 상태를 확인하기 위해 Windows에서 애플리케이션을 테스트하는 방법에 대한 정보를 제공합니다.
• 새로운 일본 달력 시대와 관련된 개별 Windows 버전에 대한 .NET Framework 업데이트를 나열하고, 여러 시대를 지원하는 새로운 .NET Framework 기능에 대해 설명하고, 애플리케이션을 테스트할 때 살펴볼 사항을 포함하는 .NET Framework의 새로운 일본 시대 업데이트 요약입니다.

대부분의 달력에서 시대는 매우 긴 기간을 나타냅니다. 예를 들어 그레고리오력에서는 현재 시대가 2천년 이상 지속됩니다. 여러 시대를 지원하는 두 달력인 JapaneseCalendar 및 JapaneseLunisolarCalendar의 경우 그렇지 않습니다. 시대는 황제의 통치 기간에 해당합니다. 특히 현재 시대의 상한선을 알 수 없는 경우 여러 시대를 지원하는 것은 특별한 도전 과제입니다.

시대 및 시대 이름

.NET에서 특정 달력 구현에서 지원하는 기간을 나타내는 정수는 Calendar.Eras 배열에 역순으로 저장됩니다. 현재 시대(최신 시간 범위의 시대)는 인덱스 0에 있으며, 여러 시대를 지원하는 Calendar 클래스의 경우 각 연속 인덱스는 이전 시대를 반영합니다. 정적 Calendar.CurrentEra 속성은 Calendar.Eras 배열에서 현재 연대의 인덱스를 정의하며 값이 항상 0인 상수입니다. 개별 Calendar 클래스에는 또한 현재 연대의 값을 반환하는 정적 필드가 포함됩니다. 이러한 필드는 다음 표에 나열되어 있습니다.

달력 클래스	현재 연대 필드
ChineseLunisolarCalendar	ChineseEra
GregorianCalendar	ADEra
HebrewCalendar	HebrewEra
HijriCalendar	HijriEra
JapaneseLunisolarCalendar	JapaneseEra
JulianCalendar	JulianEra
KoreanCalendar	KoreanEra
KoreanLunisolarCalendar	GregorianEra
PersianCalendar	PersianEra
ThaiBuddhistCalendar	ThaiBuddhistEra
UmAlQuraCalendar	UmAlQuraEra

특정 연대 번호에 해당하는 이름은 연대 번호를 DateTimeFormatInfo.GetEraName 또는 DateTimeFormatInfo.GetAbbreviatedEraName 메서드에 전달하여 검색할 수 있습니다. 다음 예제에서는 이러한 메서드를 호출하여 GregorianCalendar 클래스에서 연대 지원에 대한 정보를 검색합니다. 현재 시대의 두 번째 해 1월 1일에 해당하는 그레고리오력 날짜와 지원되는 각 일본 달력 시대의 두 번째 해 1월 1일에 해당하는 그레고리오력 날짜를 표시합니다.

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

또한 "g" 사용자 지정 날짜 및 시간 서식 문자열에는 날짜 및 시간의 문자열 표현으로 달력의 연대 이름이 포함됩니다. 자세한 내용은 사용자 지정 날짜 및 시간 형식 문자열을 참조하세요.

시대를 사용하여 날짜 인스턴스화

여러 시대를 지원하는 두 Calendar 클래스의 경우 특정 연도, 월, 일 값으로 구성된 날짜가 모호할 수 있습니다. 예를 들어 JapaneseCalendar에서 지원하는 모든 시대에는 숫자가 1인 연도가 있습니다. 일반적으로 연대가 지정되지 않으면 날짜 및 시간과 달력 메서드에서는 모두 값이 현재 연대에 속하는 것으로 가정합니다. 이는 Calendar 형식의 매개 변수를 포함하는 DateTime 및 DateTimeOffset 생성자뿐 아니라 JapaneseCalendar.ToDateTime 및 JapaneseLunisolarCalendar.ToDateTime 메서드에도 해당됩니다. 다음 예제에서는 지정되지 않은 시대의 두 번째 해 1월 1일을 나타내는 날짜를 인스턴스화합니다. 레이와 시대가 현재 시대일 때 예제를 실행하면 날짜는 레이와 시대 2년으로 해석됩니다. DateTime.ToString(String, IFormatProvider) 메서드가 반환한 문자열의 연도 앞에 시대인 令和가 있으며, 그레고리오력 기준 2020년 1월 1일에 해당합니다. (레이와 시대는 그레고리오력의 2019년에 시작됩니다.)

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

그러나 시대가 바뀌면 이 코드의 의도가 모호해집니다. 날짜가 현재 시대의 두 번째 해를 나타내기 위한 것인가요? 아니면 헤이세이 시대의 두 번째 해를 나타내기 위한 것인가요? 이러한 모호성을 방지하는 방법에는 두 가지가 있습니다.

• 기본 GregorianCalendar 클래스를 사용하여 날짜 및 시간 값을 인스턴스화합니다. 그런 다음 아래 예제와 같이 날짜의 문자열 표현에 일본 달력 또는 일본 태음력을 사용할 수 있습니다.

  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
  
  
  

• 시대를 명시적으로 지정하는 날짜 및 시간 메서드를 호출합니다. 여기에는 다음 메서드가 포함됩니다.

  • JapaneseCalendar 또는 JapaneseLunisolarCalendar 클래스의 ToDateTime(Int32, Int32, Int32, Int32, Int32, Int32, Int32, Int32) 메서드입니다.

  • 구문 분석할 문자열을 포함하는 DateTime 또는 DateTimeOffset 구문 분석 방법(예: Parse, TryParse, ParseExact 또는 TryParseExact), 현재 문화권이 일본어-일본(“ja-JP”)이고 해당 문화의 달력이 JapaneseCalendar인 경우 선택적으로 DateTimeStyles 인수를 포함할 수 있습니다. 구문 분석할 문자열에는 시대가 포함되어야 합니다.

  • 형식 IFormatProvider의 provider 매개 변수를 포함하는 DateTime 또는 DateTimeOffset 구문 분석 메서드입니다. provider은 현재 달력이 JapaneseCalendar인 일본어-일본(“ja-JP”) 문화를 나타내는 CultureInfo 개체이거나 Calendar 속성이 JapaneseCalendar인 DateTimeFormatInfo 개체여야 합니다. 구문 분석할 문자열에는 시대가 포함되어야 합니다.

  다음 예제에서는 이러한 메서드 중 세 가지를 사용하여 1868년 9월 8일에 시작되어 1912년 7월 29일에 끝난 메이지 시대의 날짜와 시간을 인스턴스화합니다.

  using System;
  using System.Globalization;
  
  public class Example
  {
      public static void Main()
      {
          var japaneseCal = new JapaneseCalendar();
          var jaJp = new CultureInfo("ja-JP");
          jaJp.DateTimeFormat.Calendar = japaneseCal;
  
          // We can get the era index by calling DateTimeFormatInfo.GetEraName.
          int eraIndex = 0;
  
          for (int ctr = 0; ctr < jaJp.DateTimeFormat.Calendar.Eras.Length; ctr++)
             if (jaJp.DateTimeFormat.GetEraName(ctr) == "明治")
                eraIndex = ctr;
          var date1 = japaneseCal.ToDateTime(23, 9, 8, 0, 0, 0, 0, eraIndex);
          Console.WriteLine($"{date1.ToString("d", jaJp)} (Gregorian {date1:d})");
  
          try {
              var date2 = DateTime.Parse("明治23/9/8", jaJp);
              Console.WriteLine($"{date2.ToString("d", jaJp)} (Gregorian {date2:d})");
          }
          catch (FormatException)
          {
              Console.WriteLine("The parsing operation failed.");
          }
  
          try {
              var date3 = DateTime.ParseExact("明治23/9/8", "gyy/M/d", jaJp);
              Console.WriteLine($"{date3.ToString("d", jaJp)} (Gregorian {date3:d})");
          }
          catch (FormatException)
          {
              Console.WriteLine("The parsing operation failed.");
          }
      }
  }
  // The example displays the following output:
  //   明治23/9/8 (Gregorian 9/8/1890)
  //   明治23/9/8 (Gregorian 9/8/1890)
  //   明治23/9/8 (Gregorian 9/8/1890)
  

  Imports System.Globalization
  
  Public Module Example
      Public Sub Main()
          Dim japaneseCal = New JapaneseCalendar()
          Dim jaJp = New CultureInfo("ja-JP")
          jaJp.DateTimeFormat.Calendar = japaneseCal
  
          ' We can get the era index by calling DateTimeFormatInfo.GetEraName.
          Dim eraIndex As Integer = 0
  
          For ctr As Integer = 0 To jaJp.DateTimeFormat.Calendar.Eras.Length - 1
              If jaJp.DateTimeFormat.GetEraName(ctr) = "明治" Then eraIndex = ctr
          Next
          Dim date1 = japaneseCal.ToDateTime(23, 9, 8, 0, 0, 0, 0, eraIndex)
          Console.WriteLine($"{date1.ToString("d", jaJp)} (Gregorian {date1:d})")
  
          Try
              Dim date2 = DateTime.Parse("明治23/9/8", jaJp)
              Console.WriteLine($"{date2.ToString("d", jaJp)} (Gregorian {date2:d})")
          Catch e As FormatException
              Console.WriteLine("The parsing operation failed.")
          End Try
  
          Try
              Dim date3 = DateTime.ParseExact("明治23/9/8", "gyy/M/d", jaJp)
              Console.WriteLine($"{date3.ToString("d", jaJp)} (Gregorian {date3:d})")
          Catch e As FormatException
              Console.WriteLine("The parsing operation failed.")
          End Try
      End Sub
  End Module
  ' The example displays the following output:
  '   明治23/9/8 (Gregorian 9/8/1890)
  '   明治23/9/8 (Gregorian 9/8/1890)
  '   明治23/9/8 (Gregorian 9/8/1890)
  

팁

여러 시대를 지원하는 달력으로 작업하는 경우 항상 그레고리오력을 사용하여 날짜를 인스턴스화하거나 해당 달력을 기준으로 날짜와 시간을 인스턴스화할 시대를 지정합니다.

ToDateTime(Int32, Int32, Int32, Int32, Int32, Int32, Int32, Int32) 메서드에 시대를 지정할 때 달력의 Eras 속성에서 시대의 인덱스를 지정합니다. 그러나 시대가 변경될 수 있는 달력의 경우 이러한 인덱스는 일정한 값이 아니며 현재 시대는 인덱스 0, 가장 오래된 시대는 인덱스 Eras.Length - 1에 있습니다. 달력에 새 시대가 추가되면 이전 시대의 인덱스가 하나씩 증가합니다. 다음과 같이 적절한 시대 인덱스를 제공할 수 있습니다.

• 현재 시대의 날짜의 경우 항상 달력의 CurrentEra 속성을 사용합니다.

• 지정된 시대의 날짜의 경우 DateTimeFormatInfo.GetEraName 메서드를 사용하여 지정된 연도 이름에 해당하는 인덱스를 검색합니다. 이를 위해서는 JapaneseCalendar이 ja-JP 문화권을 나타내는 CultureInfo 개체의 현재 달력이어야 합니다. (이 기술은 JapaneseCalendar와 동일한 시대를 지원하므로 JapaneseLunisolarCalendar에서도 작동합니다.) 이전 예제에서는 이 접근 방식을 보여 줍니다.

달력, 시대, 날짜 범위: 완화된 범위 검사

개별 달력에서 지원되는 날짜 범위와 마찬가지로 JapaneseCalendar 및 JapaneseLunisolarCalendar 클래스의 시대에도 지원되는 범위가 있습니다. 이전에는 .NET에서 엄격한 시대 범위 검사를 사용하여 시대별 날짜가 해당 시대 범위 내에 있는지 확인했습니다. 즉, 날짜가 지정된 시대 범위를 벗어나는 경우 메서드가 ArgumentOutOfRangeException을 throw합니다. 현재 .NET은 기본적으로 완화된 범위 검사를 사용합니다. 모든 버전의 .NET 업데이트에는 완화된 시대 범위 검사가 도입되어 지정된 시대 범위를 벗어나는 시대별 날짜를 인스턴스화하려는 시도는 다음 시대로 ‘오버플로’되며 예외가 throw되지 않습니다.

다음 예제에서는 1926년 12월 25일에 시작하여 1989년 1월 7일에 끝난 쇼와 시대 65주년의 날짜를 인스턴스화하려고 합니다. 이 날짜는 JapaneseCalendar의 쇼와 시대 범위를 벗어난 1990년 1월 9일에 해당합니다. 예제의 출력에서 알 수 있듯이 예제에 표시된 날짜는 헤이세이 시대 2년인 1990년 1월 9일입니다.

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

완화된 범위 검사가 바람직하지 않은 경우 애플리케이션이 실행 중인 .NET 버전에 따라 여러 가지 방법으로 엄격한 범위 검사를 복원할 수 있습니다.

• .NET Core:.netcore.runtime.json 구성 파일에 다음을 추가합니다.

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

• .NET Framework 4.6 이상:app.config 파일에서 다음 AppContext 스위치를 설정합니다.

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

• .NET Framework 4.5.2 이하: 다음 레지스트리 값을 설정합니다.

  	값
  Key	HKEY_LOCAL_MACHINE\Software\Microsoft\.NETFramework\AppContext
  항목	Switch.System.Globalization.EnforceJapaneseEraYearRanges
  Type	REG_SZ
  값	true

엄격한 범위 검사를 활성화하면 이전 예제에서는 ArgumentOutOfRangeException을 throw하고 다음과 같은 출력을 표시합니다.

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

여러 시대가 있는 달력에서 날짜 표시

Calendar 개체가 연대를 지원하고 CultureInfo 개체의 현재 달력인 경우 전체 날짜 및 시간, 긴 날짜 및 간단한 날짜 패턴에 대한 날짜 및 시간 값의 문자열 표현에 연대가 포함됩니다. 다음 예제에서는 현재 문화권이 일본(일본어)이고 현재 달력이 일본식 달력일 때 이러한 날짜를 표시합니다.

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 

Warning

JapaneseCalendar 클래스는 둘 이상의 시대의 날짜를 지원하며 CultureInfo 개체, 특히 일본어(일본) 문화권을 나타내는 CultureInfo 개체의 현재 달력이 될 수 있는 .NET의 유일한 달력 클래스입니다.

모든 달력에서 "g" 사용자 지정 서식 지정자는 결과 문자열에 연대를 포함합니다. 다음 예제에서는 현재 달력이 그레고리오력일 때 "MM-dd-yyyy g" 사용자 지정 서식 문자열을 사용하여 결과 문자열에 연대를 포함합니다.

   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.      

날짜의 문자열 표현이 현재 달력이 아닌 달력으로 표현될 경우 Calendar 클래스에는 Calendar.GetEra, Calendar.GetYear 및 Calendar.GetMonth 메서드와 함께 사용할 수 있는 Calendar.GetDayOfMonth 메서드가 포함되어 날짜가 속하는 연대뿐만 아니라 날짜 자체를 모호하게 표시합니다. 다음 예제에서는 JapaneseLunisolarCalendar 클래스를 사용하여 설명을 제공합니다. 하지만 결과 문자열에 연대에 대해 정수 대신 의미 있는 이름이나 약어를 포함하기 위해서는 DateTimeFormatInfo 개체를 인스턴스화하고 JapaneseCalendar를 현재 달력으로 지정해야 합니다. JapaneseLunisolarCalendar 달력은 특정 문화권의 현재 달력이 될 수 없지만 이 경우 두 달력이 동일한 연대를 공유합니다.

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

일본 달력에서는 한 시대의 첫 해를 간넨(元年)이라고 합니다. 예를 들어 헤이세이 1세 대신 헤이세이 시대의 첫 해를 헤이세이 간넨으로 표현할 수 있습니다. .NET은 JapaneseCalendar 클래스가 있는 일본어-일본(“ja-JP”) 문화권을 나타내는 CultureInfo 개체와 함께 사용할 때 다음 표준 또는 사용자 지정 날짜 및 시간 서식 문자열로 형식이 지정된 날짜 및 시간에 대한 서식 지정 작업에서 이 규칙을 채택합니다.

• “D” 표준 날짜 및 시간 형식 문자열로 표시되는 긴 날짜 패턴입니다.
• “F” 표준 날짜 및 시간 형식 문자열로 표시되는 전체 날짜 긴 시간 패턴입니다.
• “f” 표준 날짜 및 시간 형식 문자열로 표시되는 전체 날짜의 짧은 시간 패턴입니다.
• “Y” 또는 “y” 표준 날짜 및 시간 형식 문자열로 표시되는 연도/월 패턴입니다.
• “ggy‘年’” 또는 “ggy年” 사용자 지정 날짜 및 시간 형식 문자열입니다.

예를 들어 다음 예제에서는 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)

서식 지정 작업에서 이 동작이 바람직하지 않은 경우 .NET 버전에 따라 다음을 수행하여 항상 시대의 첫 번째 연도를 “간넨”이 아닌 “1”로 나타내는 이전 동작을 복원할 수 있습니다.

• .NET Core:.netcore.runtime.json 구성 파일에 다음을 추가합니다.

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

• .NET Framework 4.6 이상:app.config 파일에서 다음 AppContext 스위치를 설정합니다.

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

• .NET Framework 4.5.2 이하: 다음 레지스트리 값을 설정합니다.

  	값
  Key	HKEY_LOCAL_MACHINE\Software\Microsoft\.NETFramework\AppContext
  항목	Switch.System.Globalization.FormatJapaneseFirstYearAsANumber
  Type	REG_SZ
  값	true

서식 지정 작업에서 간넨 지원을 비활성화하면 이전 예제에서는 다음과 같은 출력이 표시됩니다.

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

.NET도 업데이트되어 날짜 및 시간 구문 분석 작업이 “1” 또는 간넨으로 표시되는 연도가 포함된 문자열을 지원합니다. 이 작업을 수행할 필요는 없지만 “1”만 시대의 첫 번째 연도로 인식하도록 이전 동작을 복원할 수 있습니다. .NET 버전에 따라 다음과 같이 해당 작업을 수행할 수 있습니다.

• .NET Core:.netcore.runtime.json 구성 파일에 다음을 추가합니다.

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

• .NET Framework 4.6 이상:app.config 파일에서 다음 AppContext 스위치를 설정합니다.

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

• .NET Framework 4.5.2 이하: 다음 레지스트리 값을 설정합니다.

  	값
  Key	HKEY_LOCAL_MACHINE\Software\Microsoft\.NETFramework\AppContext
  항목	Switch.System.Globalization.EnforceLegacyJapaneseDateParsing
  Type	REG_SZ
  값	true

참고 항목

• 방법: 그레고리오력이 아닌 달력의 날짜 표시
• 달력 클래스