Werken met agenda's
Hoewel een datum- en tijdwaarde een moment in de tijd vertegenwoordigt, is de tekenreeksweergave gevoelig voor cultuur en is afhankelijk van de conventies die worden gebruikt voor het weergeven van datum- en tijdwaarden door een specifieke cultuur en de kalender die door die cultuur wordt gebruikt. In dit onderwerp wordt de ondersteuning voor agenda's in .NET besproken en wordt het gebruik van de agendaklassen besproken bij het werken met datumwaarden.
Agenda's in .NET
Alle agenda's in .NET zijn afgeleid van de System.Globalization.Calendar klasse, die de basiskalender-implementatie biedt. Een van de klassen die overnemen van de Calendar klasse is de EastAsianLunisolarCalendar klasse, de basisklasse voor alle lunisolar-kalenders. .NET bevat de volgende agenda-implementaties:
ChineseLunisolarCalendar, dat de Chinese lunisolar kalender vertegenwoordigt.
GregorianCalendar, dat de Gregoriaanse kalender vertegenwoordigt. Deze kalender is verder onderverdeeld in subtypen (zoals Arabisch en Het Midden-Oosten Frans) die worden gedefinieerd door de System.Globalization.GregorianCalendarTypes opsomming. De GregorianCalendar.CalendarType eigenschap geeft het subtype van de Gregoriaanse kalender op.
HebrewCalendar, die de Hebreeuwse kalender vertegenwoordigt.
HijriCalendar, die de Hijri-kalender vertegenwoordigt.
JapaneseCalendar, die de Japanse kalender vertegenwoordigt.
JapaneseLunisolarCalendar, die de Japanse lunisolar kalender vertegenwoordigt.
JulianCalendar, die de Juliaanse kalender vertegenwoordigt.
KoreanCalendar, dat de Koreaanse kalender vertegenwoordigt.
KoreanLunisolarCalendar, dat de Koreaanse lunisolar kalender vertegenwoordigt.
PersianCalendar, die de Perzische kalender vertegenwoordigt.
TaiwanCalendar, dat de Taiwan-kalender vertegenwoordigt.
TaiwanLunisolarCalendar, dat de Taiwan lunisolar kalender vertegenwoordigt.
ThaiBuddhistCalendar, die de Thaise boeddhistische kalender vertegenwoordigt.
UmAlQuraCalendar, dat de Um Al Qura kalender vertegenwoordigt.
Een agenda kan op twee manieren worden gebruikt:
Als de kalender die wordt gebruikt door een specifieke cultuur. Elk CultureInfo object heeft een huidige agenda, de agenda die het object momenteel gebruikt. De tekenreeksweergaven van alle datum- en tijdwaarden weerspiegelen automatisch de huidige cultuur en de huidige kalender. Normaal gesproken is de huidige agenda de standaardagenda van de cultuur. CultureInfo objecten hebben ook optionele agenda's, waaronder extra agenda's die door de cultuur kunnen worden gebruikt.
Als zelfstandige agenda onafhankelijk van een specifieke cultuur. In dit geval Calendar worden methoden gebruikt om datums uit te drukken als waarden die de kalender weerspiegelen.
Houd er rekening mee dat zes agendaklassen – – , ChineseLunisolarCalendarJapaneseLunisolarCalendarJulianCalendar, , KoreanLunisolarCalendaren PersianCalendarTaiwanLunisolarCalendar – alleen kunnen worden gebruikt als zelfstandige agenda's. Ze worden niet gebruikt door een cultuur als de standaardagenda of als een optionele agenda.
Kalenders en culturen
Elke cultuur heeft een standaardkalender, die wordt gedefinieerd door de CultureInfo.Calendar eigenschap. De CultureInfo.OptionalCalendars eigenschap retourneert een matrix met Calendar objecten die alle agenda's aangeeft die worden ondersteund door een bepaalde cultuur, inclusief de standaardkalender van die cultuur.
In het volgende voorbeeld ziet u de CultureInfo.Calendar en CultureInfo.OptionalCalendars eigenschappen. Het maakt CultureInfo objecten voor de Thaise (Thailand) en Japanse (Japan) culturen en geeft hun standaard en optionele kalenders weer. In beide gevallen is de standaardagenda van de cultuur ook opgenomen in de CultureInfo.OptionalCalendars verzameling.
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)
De kalender die momenteel wordt gebruikt door een bepaald CultureInfo object, wordt gedefinieerd door de eigenschap van DateTimeFormatInfo.Calendar de cultuur. Het object van DateTimeFormatInfo een cultuur wordt geretourneerd door de CultureInfo.DateTimeFormat eigenschap. Wanneer een cultuur wordt gemaakt, is de standaardwaarde gelijk aan de waarde van de CultureInfo.Calendar eigenschap. U kunt de huidige agenda van de cultuur echter wijzigen in elke agenda in de matrix die door de CultureInfo.OptionalCalendars eigenschap wordt geretourneerd. Als u de huidige agenda probeert in te stellen op een agenda die niet is opgenomen in de CultureInfo.OptionalCalendars eigenschapswaarde, wordt er een ArgumentException gegenereerd.
In het volgende voorbeeld wordt de kalender gewijzigd die wordt gebruikt door de Arabische cultuur (Saoedi-Arabië). Eerst wordt een DateTime waarde geïnstitueert en weergegeven met behulp van de huidige cultuur , die in dit geval Engels (Verenigde Staten) is - en de huidige kalender van de cultuur (in dit geval de Gregoriaanse kalender). Vervolgens wordt de huidige cultuur gewijzigd in Arabisch (Saoedi-Arabië) en wordt de datum weergegeven met de standaardkalender Um Al-Qura. Vervolgens wordt de CalendarExists methode aangeroepen om te bepalen of de Hijri-kalender wordt ondersteund door de Arabische cultuur (Saoedi-Arabië). Omdat de agenda wordt ondersteund, wordt de huidige agenda gewijzigd in Hijri en wordt de datum opnieuw weergegeven. In elk geval wordt de datum weergegeven met de huidige agenda van de huidige cultuur.
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
Datums en agenda's
Met uitzondering van de constructors die een parameter van het type Calendar bevatten en de elementen van een datum (de maand, de dag en het jaar) mogen weergeven in een aangewezen kalender, zijn beide DateTimeDateTimeOffset waarden altijd gebaseerd op de Gregoriaanse kalender. Dit betekent bijvoorbeeld dat de DateTime.Year eigenschap het jaar in de Gregoriaanse kalender retourneert en de DateTime.Day eigenschap de dag van de maand in de Gregoriaanse kalender retourneert.
Belangrijk
Het is belangrijk te onthouden dat er een verschil is tussen een datumwaarde en de tekenreeksweergave. De vroegere is gebaseerd op de Gregoriaanse kalender; de laatste is gebaseerd op de huidige kalender van een specifieke cultuur.
In het volgende voorbeeld ziet u dit verschil tussen DateTime eigenschappen en de bijbehorende Calendar methoden. In het voorbeeld is de huidige cultuur Arabisch (Egypte) en de huidige kalender is Um Al Qura. Een DateTime waarde wordt ingesteld op de vijftiende dag van de zevende maand van 2011. Het is duidelijk dat dit wordt geïnterpreteerd als een Gregoriaanse datum, omdat dezelfde waarden worden geretourneerd door de DateTime.ToString(String, IFormatProvider) methode wanneer de conventies van de invariante cultuur worden gebruikt. De tekenreeksweergave van de datum die is opgemaakt met behulp van de conventies van de huidige cultuur is 14/08/32, wat de equivalente datum is in de Um Al Qura kalender. Vervolgens worden leden van DateTime en Calendar gebruikt om de dag, de maand en het jaar van de DateTime waarde te retourneren. In elk geval weerspiegelen de waarden die door DateTime leden worden geretourneerd waarden in de Gregoriaanse kalender, terwijl waarden die door UmAlQuraCalendar leden worden geretourneerd, waarden weerspiegelen in de Uum al-Qura-kalender.
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
Datums instantiëren op basis van een agenda
Omdat DateTime waarden DateTimeOffset zijn gebaseerd op de Gregoriaanse kalender, moet u een overbelaste constructor aanroepen die een parameter van het type Calendar bevat om een datumwaarde te instantiëren als u de dag-, maand- of jaarwaarden uit een andere kalender wilt gebruiken. U kunt ook een van de overbelastingen van een specifieke kalendermethode Calendar.ToDateTime aanroepen om een DateTime object te instantiëren op basis van de waarden van een bepaalde kalender.
In het volgende voorbeeld wordt één DateTime waarde geïnstitueerd door een HebrewCalendar object door te geven aan een DateTime constructor en wordt een tweede DateTime waarde geïnstitueerd door de methode aan te HebrewCalendar.ToDateTime(Int32, Int32, Int32, Int32, Int32, Int32, Int32, Int32) roepen. Omdat de twee waarden worden gemaakt met identieke waarden uit de Hebreeuwse kalender, geeft de aanroep van de DateTime.Equals methode aan dat de twee DateTime waarden gelijk zijn.
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
Datums weergeven in de huidige agenda
Datum- en tijdnotatiemethoden gebruiken altijd de huidige kalender bij het converteren van datums naar tekenreeksen. Dit betekent dat de tekenreeksweergave van het jaar, de maand en de dag van de maand de huidige kalender weergeeft en niet noodzakelijkerwijs de Gregoriaanse kalender weergeeft.
In het volgende voorbeeld ziet u hoe de huidige kalender van invloed is op de tekenreeksweergave van een datum. De huidige cultuur wordt gewijzigd in Chinees (traditioneel, Taiwan) en er wordt een datumwaarde geïnstitueert. Vervolgens worden de huidige agenda en de datum weergegeven, wordt de huidige agenda TaiwanCalendargewijzigd in en wordt de huidige agenda en datum opnieuw weergegeven. De eerste keer dat de datum wordt weergegeven, wordt deze weergegeven als een datum in de Gregoriaanse kalender. De tweede keer dat het wordt weergegeven, wordt deze weergegeven als een datum in de Taiwan-kalender.
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
Datums weergeven in een niet-huidige agenda
Als u een datum wilt weergeven met een kalender die niet de huidige kalender van een bepaalde cultuur is, moet u methoden van dat Calendar object aanroepen. De methoden , Calendar.GetMonthen Calendar.GetDayOfMonth methoden converteren bijvoorbeeld Calendar.GetYearhet jaar, de maand en de dag naar waarden die een bepaalde kalender weerspiegelen.
Waarschuwing
Omdat sommige agenda's geen optionele agenda's van een cultuur zijn, moet u altijd kalendermethoden aanroepen om datums in deze agenda's weer te geven. Dit geldt voor alle agenda's die zijn afgeleid van de EastAsianLunisolarCalendar, JulianCalendaren PersianCalendar klassen.
In het volgende voorbeeld wordt een object gebruikt om een JulianCalendar datum te instantiëren, 9 januari 1905, in de Juliaanse kalender. Wanneer deze datum wordt weergegeven met de standaardkalender (Gregoriaanse kalender), wordt deze weergegeven als 22 januari 1905. Met aanroepen naar afzonderlijke JulianCalendar methoden kan de datum worden weergegeven in de Juliaanse kalender.
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
Agenda's en datumbereiken
De vroegste datum die wordt ondersteund door een agenda, wordt aangegeven door de eigenschap van Calendar.MinSupportedDateTime die agenda. Voor de GregorianCalendar klas is die datum 1 januari 0001 C.E. De meeste andere agenda's in .NET ondersteunen een latere datum. Als u wilt werken met een datum- en tijdwaarde die voorafgaat aan de vroegste ondersteunde datum van een kalender, wordt er een ArgumentOutOfRangeException uitzondering gegenereerd.
Er is echter één belangrijke uitzondering. De standaardwaarde (niet-geïnitialiseerd) van een DateTime object en een DateTimeOffset object is gelijk aan de GregorianCalendar.MinSupportedDateTime waarde. Als u deze datum probeert op te maken in een kalender die geen ondersteuning biedt voor 1 januari 0001 C.E. en u geen notatieaanduiding opgeeft, gebruikt de opmaakmethode de notatieaanduiding 's' (sorteerbaar datum-/tijdpatroon) in plaats van de notatieaanduiding G (algemeen datum/tijd-patroon). Als gevolg hiervan genereert ArgumentOutOfRangeException de opmaakbewerking geen uitzondering. In plaats daarvan wordt de niet-ondersteunde datum geretourneerd. Dit wordt geïllustreerd in het volgende voorbeeld, waarin de waarde wordt weergegeven van DateTime.MinValue wanneer de huidige cultuur is ingesteld op Japans (Japan) met de Japanse kalender en op Arabisch (Egypte) met de kalender Um Al Qura. Ook wordt de huidige cultuur ingesteld op Engels (Verenigde Staten) en wordt de DateTime.ToString(IFormatProvider) methode aangeroepen met elk van deze CultureInfo objecten. In elk geval wordt de datum weergegeven met behulp van het sorteerbare datum-/tijdpatroon.
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
Werken met tijdperken
Agenda's verdelen datums meestal in tijdperken. De Calendar klassen in .NET ondersteunen echter niet elk tijdperk dat is gedefinieerd door een kalender, en de meeste klassen Calendar ondersteunen slechts één tijdperk. Alleen de JapaneseCalendar en JapaneseLunisolarCalendar klassen ondersteunen meerdere tijdperken.
Belangrijk
Het Reiwa-tijdperk, een nieuw tijdperk in de JapaneseCalendar en JapaneseLunisolarCalendar, begint op 1 mei 2019. Deze wijziging is van invloed op alle toepassingen die gebruikmaken van deze agenda's. Zie de volgende artikelen voor meer informatie:
- Het verwerken van een nieuw tijdperk in de Japanse agenda in .NET, die documentenfuncties die aan .NET zijn toegevoegd, ter ondersteuning van agenda's met meerdere tijdperken en bespreekt aanbevolen procedures voor het verwerken van agenda's met meerdere tijdperken.
- Bereid uw toepassing voor op de wijziging in het Japanse tijdperk, die informatie biedt over het testen van uw toepassingen in Windows om ervoor te zorgen dat ze gereed zijn voor de wijziging van het tijdperk.
- Samenvatting van nieuwe Japanse tijdperkupdates voor .NET Framework, waarin .NET Framework-updates worden vermeld voor afzonderlijke Windows-versies die zijn gerelateerd aan het nieuwe Japanse kalendertijdperk, worden nieuwe .NET Framework-functies voor ondersteuning voor meerdere tijdperken vermeld en worden items opgenomen die u kunt zoeken bij het testen van uw toepassingen.
Een tijdperk in de meeste kalenders geeft een extreem lange periode aan. In de Gregoriaanse kalender, bijvoorbeeld, beslaat het huidige tijdperk meer dan twee eeuwen. Voor de JapaneseCalendar en JapaneseLunisolarCalendarde twee kalenders die meerdere tijdperken ondersteunen, is dit niet het geval. Een tijdperk komt overeen met de periode van het rijk van een keizer. Ondersteuning voor meerdere tijdperken, met name wanneer de bovengrens van het huidige tijdperk onbekend is, brengt speciale uitdagingen met zich mee.
Eras and era names
In .NET worden gehele getallen die de tijdperken vertegenwoordigen die door een bepaalde kalender-implementatie worden ondersteund, opgeslagen in omgekeerde volgorde in de Calendar.Eras matrix. Het huidige tijdperk (het tijdperk met het laatste tijdsbereik) bevindt zich op index nul en voor Calendar klassen die meerdere tijdperken ondersteunen, weerspiegelt elke opeenvolgende index het vorige tijdperk. De statische Calendar.CurrentEra eigenschap definieert de index van het huidige tijdperk in de Calendar.Eras matrix. Het is een constante waarvan de waarde altijd nul is. Afzonderlijke Calendar klassen bevatten ook statische velden die de waarde van het huidige tijdperk retourneren. Deze worden weergegeven in de volgende tabel.
De naam die overeenkomt met een bepaald eranummer kan worden opgehaald door het eranummer door te geven aan de DateTimeFormatInfo.GetEraName of DateTimeFormatInfo.GetAbbreviatedEraName methode. In het volgende voorbeeld worden deze methoden aangeroepen voor het ophalen van informatie over era-ondersteuning in de GregorianCalendar klasse. Hiermee wordt de Gregoriaanse kalenderdatum weergegeven die overeenkomt met 1 januari van het tweede jaar van het huidige tijdperk, evenals de Gregoriaanse kalenderdatum die overeenkomt met 1 januari van het tweede jaar van elk ondersteund Japans kalendertijdperk.
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
Daarnaast bevat de tekenreeks 'g' aangepaste datum- en tijdnotatie een kalendernaam in de tekenreeksweergave van een datum en tijd. Zie Tekenreeksen voor aangepaste datum- en tijdnotatie voor meer informatie.
Een datum instantiëren met een tijdperk
Voor de twee Calendar klassen die meerdere tijdperken ondersteunen, kan een datum die uit een bepaald jaar, maand en dag van de maandwaarde bestaat dubbelzinnig zijn. Bijvoorbeeld alle tijdperken die worden ondersteund door de JapaneseCalendar jaren waarvan het getal 1 is. Normaal gesproken gaan zowel datum- als tijd- en kalendermethoden ervan uit dat waarden deel uitmaken van het huidige tijdperk als een tijdperk dat niet is opgegeven. Dit geldt voor de DateTime en DateTimeOffset constructors die parameters van het type Calendarbevatten, evenals de methoden JapaneseCalendar.ToDateTime en JapaneseLunisolarCalendar.ToDateTime . In het volgende voorbeeld wordt een datum geïnstitueerd die 1 januari van het tweede jaar van een niet-gespecificeerd tijdperk aangeeft. Als u het voorbeeld uitvoert wanneer het Reiwa-tijdperk het huidige tijdperk is, wordt de datum geïnterpreteerd als het tweede jaar van het Reiwa-tijdperk. Het tijdperk, 令和, gaat vooraf aan het jaar in de tekenreeks die door de DateTime.ToString(String, IFormatProvider) methode wordt geretourneerd en komt overeen met 1 januari 2020, in de Gregoriaanse kalender. (Het Reiwa-tijdperk begint in het jaar 2019 van de Gregoriaanse kalender.)
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
Als het tijdperk echter verandert, wordt de intentie van deze code dubbelzinnig. Is de datum bedoeld om het tweede jaar van het huidige tijdperk aan te geven of is het bedoeld om het tweede jaar van het Heisei-tijdperk aan te geven? Er zijn twee manieren om deze dubbelzinnigheid te voorkomen:
Instantieer de datum- en tijdwaarde met behulp van de standaardklasse GregorianCalendar . U kunt vervolgens de Japanse kalender of de Japanse Lunisolar-kalender gebruiken voor de tekenreeksweergave van datums, zoals in het volgende voorbeeld wordt weergegeven.
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/12Imports 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/12Roep een datum- en tijdmethode aan waarmee expliciet een tijdperk wordt opgegeven. Dit omvat de volgende methoden:
De ToDateTime(Int32, Int32, Int32, Int32, Int32, Int32, Int32, Int32) methode van de JapaneseCalendar of JapaneseLunisolarCalendar klasse.
Een DateTime of DateTimeOffset parseringsmethode, zoals Parse, TryParse, ParseExactof TryParseExact, die de tekenreeks bevat die moet worden geparseerd en optioneel een DateTimeStyles argument als de huidige cultuur Japans-Japan ('ja-JP') is en de kalender van die cultuur de JapaneseCalendarkalender is. De tekenreeks die moet worden geparseerd, moet het tijdperk bevatten.
Een DateTime of DateTimeOffset parseringsmethode die een parameter van het
providertype IFormatProviderbevat.providermoet een CultureInfo object zijn dat de Japans-Japan -cultuur ("ja-JP") vertegenwoordigt waarvan de huidige kalender is JapaneseCalendar of een DateTimeFormatInfo object waarvan Calendar de eigenschap is JapaneseCalendar. De tekenreeks die moet worden geparseerd, moet het tijdperk bevatten.
In het volgende voorbeeld worden drie van deze methoden gebruikt om een datum en tijd te instantiëren in het Meiji-tijdperk, dat begon op 8 september 1868 en eindigde op 29 juli 1912.
using System; using System.Globalization; public class Example { public static void Main() { var japaneseCal = new JapaneseCalendar(); var jaJp = new CultureInfo("ja-JP"); jaJp.DateTimeFormat.Calendar = japaneseCal; // We can get the era index by calling DateTimeFormatInfo.GetEraName. int eraIndex = 0; for (int ctr = 0; ctr < jaJp.DateTimeFormat.Calendar.Eras.Length; ctr++) if (jaJp.DateTimeFormat.GetEraName(ctr) == "明治") eraIndex = ctr; var date1 = japaneseCal.ToDateTime(23, 9, 8, 0, 0, 0, 0, eraIndex); Console.WriteLine($"{date1.ToString("d", jaJp)} (Gregorian {date1:d})"); try { var date2 = DateTime.Parse("明治23/9/8", jaJp); Console.WriteLine($"{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)
Tip
Wanneer u werkt met kalenders die meerdere tijdperken ondersteunen, gebruikt u altijd de Gregoriaanse datum om een datum te instantiëren of geeft u het tijdperk op wanneer u een datum en tijd instantiëren op basis van die kalender.
Bij het opgeven van een tijdperk voor de ToDateTime(Int32, Int32, Int32, Int32, Int32, Int32, Int32, Int32) methode geeft u de index van het tijdperk in de eigenschap van Eras de kalender op. Voor kalenders waarvan de tijdperken moeten worden gewijzigd, zijn deze indexen echter geen constante waarden; het huidige tijdperk zich op index 0 bevindt en het oudste tijdperk zich op index Eras.Length - 1bevindt. Wanneer een nieuw tijdperk wordt toegevoegd aan een kalender, nemen de indexen van de vorige tijdperken met één toe. U kunt de juiste era-index als volgt opgeven:
Voor datums in het huidige tijdperk gebruikt u altijd de eigenschap van CurrentEra de agenda.
Voor datums in een opgegeven tijdperk gebruikt u de DateTimeFormatInfo.GetEraName methode om de index op te halen die overeenkomt met een opgegeven eranaam. Hiervoor moet de JapaneseCalendar huidige kalender van het CultureInfo object zijn dat de ja-JP-cultuur vertegenwoordigt. (Deze techniek werkt ook voor de JapaneseLunisolarCalendar techniek, omdat het dezelfde tijdperken ondersteunt als de JapaneseCalendar.) In het vorige voorbeeld ziet u deze benadering.
Kalenders, tijdperken en datumbereiken: Ontspannen bereikcontroles
Net als bij afzonderlijke agenda's worden datumbereiken ondersteund, eras in de JapaneseCalendar en JapaneseLunisolarCalendar klassen worden ook ondersteunde bereiken ondersteund. Voorheen gebruikte .NET strikte tijdperkbereikcontroles om ervoor te zorgen dat een tijdperkspecifieke datum binnen het bereik van dat tijdperk lag. Dat wil gezegd dat als een datum buiten het bereik van het opgegeven tijdperk valt, de methode een ArgumentOutOfRangeException. Op dit moment maakt .NET standaard gebruik van ontspannen bereikcontrole. Updates voor alle versies van .NET hebben ontspannen tijdperkbereikcontroles geïntroduceerd; de poging om een tijdperkspecifieke datum te instantiëren die zich buiten het bereik van het opgegeven tijdperk "overloopt" in het volgende tijdperk, en er wordt geen uitzondering gegenereerd.
In het volgende voorbeeld wordt geprobeerd een datum te instantiëren in het 65e jaar van het Showa-tijdperk, dat begon op 25 december 1926 en eindigde op 7 januari 1989. Deze datum komt overeen met 9 januari 1990, die buiten het bereik van het Showa-tijdperk in de JapaneseCalendar. Zoals de uitvoer uit het voorbeeld illustreert, is de datum die in het voorbeeld wordt weergegeven 9 januari 1990, in het tweede jaar van het Heisei-tijdperk.
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
Als ontspannen bereikcontroles ongewenst zijn, kunt u strikte bereikcontroles op verschillende manieren herstellen, afhankelijk van de versie van .NET waarop uw toepassing wordt uitgevoerd:
.NET Core: Voeg het volgende toe aan het configuratiebestand .netcore.runtime.json :
"runtimeOptions": { "configProperties": { "Switch.System.Globalization.EnforceJapaneseEraYearRanges": true } }.NET Framework 4.6 of hoger: Stel de volgende AppContext-switch in het bestand app.config in:
<?xml version="1.0" encoding="utf-8"?> <configuration> <runtime> <AppContextSwitchOverrides value="Switch.System.Globalization.EnforceJapaneseEraYearRanges=true" /> </runtime> </configuration>.NET Framework 4.5.2 of eerder: Stel de volgende registerwaarde in:
Weergegeven als Code HKEY_LOCAL_MACHINE\Software\Microsoft\. NETFramework\AppContext Invoer Switch.System.Globalization.EnforceJapaneseEraYearRanges Type REG_SZ Value true
Als strikte bereikcontroles zijn ingeschakeld, genereert het vorige voorbeeld een ArgumentOutOfRangeException en geeft de volgende uitvoer weer:
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()
Datums weergeven in kalenders met meerdere tijdperken
Als een Calendar object eras ondersteunt en de huidige kalender van een CultureInfo object is, wordt het tijdperk opgenomen in de tekenreeksweergave van een datum- en tijdwaarde voor de volledige datum en tijd, lange datum en korte datumpatronen. In het volgende voorbeeld worden deze datumpatronen weergegeven wanneer de huidige cultuur Japan (Japans) is en de huidige kalender de Japanse kalender is.
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
Waarschuwing
De JapaneseCalendar klasse is de enige kalenderklasse in .NET die zowel datums in meer dan één tijdperk ondersteunt als de huidige kalender van een CultureInfo object, met name van een CultureInfo object dat de Japanse cultuur (Japan) vertegenwoordigt.
Voor alle agenda's bevat de aangepaste notatieaanduiding g het tijdperk in de resultaattekenreeks. In het volgende voorbeeld wordt de aangepaste notatietekenreeks MM-dd-jjjj g gebruikt om het tijdperk in de resultaattekenreeks op te nemen wanneer de huidige kalender de Gregoriaanse kalender is.
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.
In gevallen waarin de tekenreeksweergave van een datum wordt uitgedrukt in een kalender die niet de huidige kalender is, bevat de Calendar klasse een Calendar.GetEra methode die samen met de Calendar.GetYear, Calendar.GetMonthen Calendar.GetDayOfMonth methoden kan worden gebruikt om een datum en het tijdperk waartoe het behoort ondubbelzinnig aan te geven. In het volgende voorbeeld wordt de JapaneseLunisolarCalendar klasse gebruikt om een afbeelding te bieden. Houd er echter rekening mee dat als u een betekenisvolle naam of afkorting opneemt in plaats van een geheel getal voor het tijdperk in de resultaattekenreeks, u een DateTimeFormatInfo object moet instantiëren en de huidige kalender moet maken JapaneseCalendar . (De JapaneseLunisolarCalendar agenda kan niet de huidige kalender van een cultuur zijn, maar in dit geval delen de twee kalenders dezelfde tijdperken.)
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
In de Japanse kalenders wordt het eerste jaar van een tijdperk Gannen genoemd (元年). In plaats van Heisei 1 kan het eerste jaar van het Heisei-tijdperk bijvoorbeeld worden beschreven als Heisei Gannen. .NET gebruikt deze conventie bij het opmaken van bewerkingen voor datums en tijden die zijn opgemaakt met de volgende standaard- of aangepaste tekenreeksen voor datum- en tijdnotatie wanneer ze worden gebruikt met een CultureInfo object dat de Japans-Japan -cultuur (ja-JP) vertegenwoordigt met de JapaneseCalendar klasse:
- Het lange datumpatroon, aangegeven door de standaardtekenreeks voor datum- en tijdnotatie D.
- Het lange tijdpatroon voor de volledige datum, aangegeven door de standaardtekenreeks voor datum- en tijdnotatie 'F'.
- Het volledige datumnotatiepatroon voor korte tijd, aangegeven door de standaardtekenreeks voor datum- en tijdnotatie 'f'.
- Het jaar-/maandpatroon, aangegeven door de standaardtekenreeks voor datum- en tijdnotatie Y of y.
- De aangepaste tekenreeks 'ggy'年' of 'ggy年'.
In het volgende voorbeeld wordt bijvoorbeeld een datum weergegeven in het eerste jaar van het Heisei-tijdperk in de 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)
Als dit gedrag ongewenst is in opmaakbewerkingen, kunt u het vorige gedrag herstellen, dat altijd het eerste jaar van een tijdperk vertegenwoordigt als '1' in plaats van 'Gannen', door het volgende te doen, afhankelijk van de versie van .NET:
.NET Core: Voeg het volgende toe aan het configuratiebestand .netcore.runtime.json :
"runtimeOptions": { "configProperties": { "Switch.System.Globalization.FormatJapaneseFirstYearAsANumber": true } }.NET Framework 4.6 of hoger: Stel de volgende AppContext-switch in het bestand app.config in:
<?xml version="1.0" encoding="utf-8"?> <configuration> <runtime> <AppContextSwitchOverrides value="Switch.System.Globalization.FormatJapaneseFirstYearAsANumber=true" /> </runtime> </configuration>.NET Framework 4.5.2 of eerder: Stel de volgende registerwaarde in:
Weergegeven als Code HKEY_LOCAL_MACHINE\Software\Microsoft\. NETFramework\AppContext Invoer Switch.System.Globalization.FormatJapaneseFirstYearAsANumber Type REG_SZ Value true
Als gannen-ondersteuning voor opmaakbewerkingen is uitgeschakeld, wordt in het vorige voorbeeld de volgende uitvoer weergegeven:
Japanese calendar date: 平成1年8月18日 (Gregorian: Friday, August 18, 1989)
.NET is ook bijgewerkt, zodat bewerkingen voor datum- en tijdparsering tekenreeksen ondersteunen die het jaar bevatten dat wordt weergegeven als '1' of Gannen. Hoewel u dit niet hoeft te doen, kunt u het vorige gedrag herstellen om alleen '1' te herkennen als het eerste jaar van een tijdperk. U kunt dit als volgt doen, afhankelijk van de versie van .NET:
.NET Core: Voeg het volgende toe aan het configuratiebestand .netcore.runtime.json :
"runtimeOptions": { "configProperties": { "Switch.System.Globalization.EnforceLegacyJapaneseDateParsing": true } }.NET Framework 4.6 of hoger: Stel de volgende AppContext-switch in het bestand app.config in:
<?xml version="1.0" encoding="utf-8"?> <configuration> <runtime> <AppContextSwitchOverrides value="Switch.System.Globalization.EnforceLegacyJapaneseDateParsing=true" /> </runtime> </configuration>.NET Framework 4.5.2 of eerder: Stel de volgende registerwaarde in:
Weergegeven als Code HKEY_LOCAL_MACHINE\Software\Microsoft\. NETFramework\AppContext Invoer Switch.System.Globalization.EnforceLegacyJapaneseDateParsing Type REG_SZ Value true
Zie ook
Feedback
Binnenkort beschikbaar: In de loop van 2024 zullen we GitHub-problemen geleidelijk uitfaseren als het feedbackmechanisme voor inhoud en deze vervangen door een nieuw feedbacksysteem. Zie voor meer informatie: https://aka.ms/ContentUserFeedback.
Feedback verzenden en weergeven voor