Teilen über


Calendar Klasse

Definition

Stellt Zeit in Abschnitten (also etwa in Wochen, Monaten oder Jahren) dar.

public ref class Calendar abstract
public ref class Calendar abstract : ICloneable
public abstract class Calendar
public abstract class Calendar : ICloneable
[System.Serializable]
public abstract class Calendar
[System.Serializable]
[System.Runtime.InteropServices.ComVisible(true)]
public abstract class Calendar : ICloneable
type Calendar = class
type Calendar = class
    interface ICloneable
[<System.Serializable>]
type Calendar = class
[<System.Serializable>]
[<System.Runtime.InteropServices.ComVisible(true)>]
type Calendar = class
    interface ICloneable
Public MustInherit Class Calendar
Public MustInherit Class Calendar
Implements ICloneable
Vererbung
Calendar
Abgeleitet
Attribute
Implementiert

Beispiele

Im folgenden Codebeispiel werden die Member der Calendar -Klasse veranschaulicht.

using namespace System;
using namespace System::Globalization;
void DisplayValues( Calendar^ myCal, DateTime myDT )
{
   Console::WriteLine( "   Era: {0}", myCal->GetEra( myDT ) );
   Console::WriteLine( "   Year: {0}", myCal->GetYear( myDT ) );
   Console::WriteLine( "   Month: {0}", myCal->GetMonth( myDT ) );
   Console::WriteLine( "   DayOfYear: {0}", myCal->GetDayOfYear( myDT ) );
   Console::WriteLine( "   DayOfMonth: {0}", myCal->GetDayOfMonth( myDT ) );
   Console::WriteLine( "   DayOfWeek: {0}", myCal->GetDayOfWeek( myDT ) );
   Console::WriteLine( "   Hour: {0}", myCal->GetHour( myDT ) );
   Console::WriteLine( "   Minute: {0}", myCal->GetMinute( myDT ) );
   Console::WriteLine( "   Second: {0}", myCal->GetSecond( myDT ) );
   Console::WriteLine( "   Milliseconds: {0}", myCal->GetMilliseconds( myDT ) );
   Console::WriteLine();
}

int main()
{
   
   // Sets a DateTime to April 3, 2002 of the Gregorian calendar.
   DateTime myDT = DateTime(2002,4,3,gcnew GregorianCalendar);
   
   // Uses the default calendar of the InvariantCulture.
   Calendar^ myCal = CultureInfo::InvariantCulture->Calendar;
   
   // Displays the values of the DateTime.
   Console::WriteLine( "April 3, 2002 of the Gregorian calendar:" );
   DisplayValues( myCal, myDT );
   
   // Adds 5 to every component of the DateTime.
   myDT = myCal->AddYears( myDT, 5 );
   myDT = myCal->AddMonths( myDT, 5 );
   myDT = myCal->AddWeeks( myDT, 5 );
   myDT = myCal->AddDays( myDT, 5 );
   myDT = myCal->AddHours( myDT, 5 );
   myDT = myCal->AddMinutes( myDT, 5 );
   myDT = myCal->AddSeconds( myDT, 5 );
   myDT = myCal->AddMilliseconds( myDT, 5 );
   
   // Displays the values of the DateTime.
   Console::WriteLine( "After adding 5 to each component of the DateTime:" );
   DisplayValues( myCal, myDT );
}

/*
This code produces the following output.

April 3, 2002 of the Gregorian calendar:
Era:          1
Year:         2002
Month:        4
DayOfYear:    93
DayOfMonth:   3
DayOfWeek:    Wednesday
Hour:         0
Minute:       0
Second:       0
Milliseconds: 0

After adding 5 to each component of the DateTime:
Era:          1
Year:         2007
Month:        10
DayOfYear:    286
DayOfMonth:   13
DayOfWeek:    Saturday
Hour:         5
Minute:       5
Second:       5
Milliseconds: 5

*/
using System;
using System.Globalization;

public class SamplesCalendar  {

   public static void Main()  {

      // Sets a DateTime to April 3, 2002 of the Gregorian calendar.
      DateTime myDT = new DateTime( 2002, 4, 3, new GregorianCalendar() );

      // Uses the default calendar of the InvariantCulture.
      Calendar myCal = CultureInfo.InvariantCulture.Calendar;

      // Displays the values of the DateTime.
      Console.WriteLine( "April 3, 2002 of the Gregorian calendar:" );
      DisplayValues( myCal, myDT );

      // Adds 5 to every component of the DateTime.
      myDT = myCal.AddYears( myDT, 5 );
      myDT = myCal.AddMonths( myDT, 5 );
      myDT = myCal.AddWeeks( myDT, 5 );
      myDT = myCal.AddDays( myDT, 5 );
      myDT = myCal.AddHours( myDT, 5 );
      myDT = myCal.AddMinutes( myDT, 5 );
      myDT = myCal.AddSeconds( myDT, 5 );
      myDT = myCal.AddMilliseconds( myDT, 5 );

      // Displays the values of the DateTime.
      Console.WriteLine( "After adding 5 to each component of the DateTime:" );
      DisplayValues( myCal, myDT );
   }

   public static void DisplayValues( Calendar myCal, DateTime myDT )  {
      Console.WriteLine( "   Era:          {0}", myCal.GetEra( myDT ) );
      Console.WriteLine( "   Year:         {0}", myCal.GetYear( myDT ) );
      Console.WriteLine( "   Month:        {0}", myCal.GetMonth( myDT ) );
      Console.WriteLine( "   DayOfYear:    {0}", myCal.GetDayOfYear( myDT ) );
      Console.WriteLine( "   DayOfMonth:   {0}", myCal.GetDayOfMonth( myDT ) );
      Console.WriteLine( "   DayOfWeek:    {0}", myCal.GetDayOfWeek( myDT ) );
      Console.WriteLine( "   Hour:         {0}", myCal.GetHour( myDT ) );
      Console.WriteLine( "   Minute:       {0}", myCal.GetMinute( myDT ) );
      Console.WriteLine( "   Second:       {0}", myCal.GetSecond( myDT ) );
      Console.WriteLine( "   Milliseconds: {0}", myCal.GetMilliseconds( myDT ) );
      Console.WriteLine();
   }
}


/*
This code produces the following output.

April 3, 2002 of the Gregorian calendar:
   Era:          1
   Year:         2002
   Month:        4
   DayOfYear:    93
   DayOfMonth:   3
   DayOfWeek:    Wednesday
   Hour:         0
   Minute:       0
   Second:       0
   Milliseconds: 0

After adding 5 to each component of the DateTime:
   Era:          1
   Year:         2007
   Month:        10
   DayOfYear:    286
   DayOfMonth:   13
   DayOfWeek:    Saturday
   Hour:         5
   Minute:       5
   Second:       5
   Milliseconds: 5

*/
Imports System.Globalization


Public Class SamplesCalendar   

   Public Shared Sub Main()

      ' Sets a DateTime to April 3, 2002 of the Gregorian calendar.
      Dim myDT As New DateTime(2002, 4, 3, New GregorianCalendar())

      ' Uses the default calendar of the InvariantCulture.
      Dim myCal As Calendar = CultureInfo.InvariantCulture.Calendar

      ' Displays the values of the DateTime.
      Console.WriteLine("April 3, 2002 of the Gregorian calendar:")
      DisplayValues(myCal, myDT)

      ' Adds 5 to every component of the DateTime.
      myDT = myCal.AddYears(myDT, 5)
      myDT = myCal.AddMonths(myDT, 5)
      myDT = myCal.AddWeeks(myDT, 5)
      myDT = myCal.AddDays(myDT, 5)
      myDT = myCal.AddHours(myDT, 5)
      myDT = myCal.AddMinutes(myDT, 5)
      myDT = myCal.AddSeconds(myDT, 5)
      myDT = myCal.AddMilliseconds(myDT, 5)

      ' Displays the values of the DateTime.
      Console.WriteLine("After adding 5 to each component of the DateTime:")
      DisplayValues(myCal, myDT)

   End Sub

   Public Shared Sub DisplayValues(myCal As Calendar, myDT As DateTime)
      Console.WriteLine("   Era:          {0}", myCal.GetEra(myDT))
      Console.WriteLine("   Year:         {0}", myCal.GetYear(myDT))
      Console.WriteLine("   Month:        {0}", myCal.GetMonth(myDT))
      Console.WriteLine("   DayOfYear:    {0}", myCal.GetDayOfYear(myDT))
      Console.WriteLine("   DayOfMonth:   {0}", myCal.GetDayOfMonth(myDT))
      Console.WriteLine("   DayOfWeek:    {0}", myCal.GetDayOfWeek(myDT))
      Console.WriteLine("   Hour:         {0}", myCal.GetHour(myDT))
      Console.WriteLine("   Minute:       {0}", myCal.GetMinute(myDT))
      Console.WriteLine("   Second:       {0}", myCal.GetSecond(myDT))
      Console.WriteLine("   Milliseconds: {0}", myCal.GetMilliseconds(myDT))
      Console.WriteLine()
   End Sub

End Class


'This code produces the following output.
'
'April 3, 2002 of the Gregorian calendar:
'   Era:          1
'   Year:         2002
'   Month:        4
'   DayOfYear:    93
'   DayOfMonth:   3
'   DayOfWeek:    Wednesday
'   Hour:         0
'   Minute:       0
'   Second:       0
'   Milliseconds: 0
'
'After adding 5 to each component of the DateTime:
'   Era:          1
'   Year:         2007
'   Month:        10
'   DayOfYear:    286
'   DayOfMonth:   13
'   DayOfWeek:    Saturday
'   Hour:         5
'   Minute:       5
'   Second:       5
'   Milliseconds: 5

Hinweise

Ein Kalender unterteilt die Zeit in Einheiten, z. B. Wochen, Monate und Jahre. Anzahl, Länge und Anfang der Divisionen variieren in jedem Kalender.

Hinweis

Informationen zur Verwendung der Kalenderklassen in .NET finden Sie unter Arbeiten mit Kalendern.

Jeder Zeitpunkt kann mithilfe eines bestimmten Kalenders als Satz numerischer Werte dargestellt werden. Beispielsweise trat eine vernale Tagundnachtgleiche (1999, 3, 20, 8, 46, 0, 0,0) im gregorianischen Kalender auf, d. h. 20. März 1999 C.E. um 8:46:00:0.0. Eine Implementierung von Calendar kann beliebige Datumsangaben im Bereich eines bestimmten Kalenders einem ähnlichen Satz numerischer Werte zuordnen und DateTime solche Mengen numerischer Werte einer Textdarstellung mithilfe von Informationen von Calendar und DateTimeFormatInfozuordnen. Die Textdarstellung kann kultursensitiv sein, z. B. "8:46 AM 20. März 1999 AD" für die en-US-Kultur oder kulturunempfindlich, z. B. "1999-03-20T08:46:00" im ISO 8601-Format.

Eine Calendar Implementierung kann eine oder mehrere Epochen definieren. Die Calendar -Klasse identifiziert die Epochen als aufgezählte ganze Zahlen, wobei die aktuelle Ära (CurrentEra) den Wert 0 aufweist.

Wichtig

Die Zeitrechnung in japanischen Kalendern basiert auf den Regierungsperioden der Kaiser und wird sich daher erwartungsgemäß ändern. Beispiel: Der 1. Mai 2019 markiert den Beginn des Reiwa-Zeitabschnitts in den Kalendern des Typs JapaneseCalendar und JapaneseLunisolarCalendar. Eine derartige Änderung der Zeitabschnitte betrifft alle Anwendungen, die diese Kalender verwenden. Weitere Informationen und informationen zum Ermitteln, ob Ihre Anwendungen betroffen sind, finden Sie unter Behandeln einer neuen Ära im japanischen Kalender in .NET. Informationen zum Testen Ihrer Anwendungen auf Windows-Systemen, um ihre Bereitschaft für die Änderung der Ära sicherzustellen, finden Sie unter Vorbereiten der Anwendung für die Änderung der japanischen Ära. Features in .NET, die Kalender mit mehreren Epochen unterstützen, und bewährte Methoden für die Arbeit mit Kalendern, die mehrere Epochen unterstützen, finden Sie unter Arbeiten mit Epochen.

Um den Unterschied zwischen dem Kalenderjahr und der tatsächlichen Zeit, zu der sich die Erde um die Sonne dreht, oder der tatsächlichen Zeit, zu der sich der Mond um die Erde dreht, auszugleichen, hat ein Schaltjahr eine andere Anzahl von Tagen als ein Normales Kalenderjahr. Jede Calendar Implementierung definiert Schaltjahre unterschiedlich.

Für die Konsistenz wird der ersten Einheit in jedem Intervall (z. B. dem ersten Monat) der Wert 1 zugewiesen.

Der System.Globalization Namespace umfasst die folgenden Calendar Implementierungen:

Konstruktoren

Calendar()

Initialisiert eine neue Instanz der Calendar-Klasse.

Felder

CurrentEra

Stellt den aktuellen Zeitraum des aktuellen Kalenders dar. Der Wert dieses Felds beträgt 0.

Eigenschaften

AlgorithmType

Ruft einen Wert ab, der angibt, ob der aktuelle Kalender ein Sonnen- oder ein Mondkalender oder eine Kombination beider Kalenderarten ist.

DaysInYearBeforeMinSupportedYear

Ruft die Anzahl der Tage im Jahr ab, das dem Jahr vorausgeht, das von der MinSupportedDateTime-Eigenschaft angegeben wird.

Eras

Ruft beim Überschreiben in einer abgeleiteten Klasse die Liste der Zeiträume im aktuellen Kalender ab.

IsReadOnly

Ruft einen Wert ab, der angibt, ob dieses Calendar-Objekt schreibgeschützt ist.

MaxSupportedDateTime

Ruft das späteste von diesem Calendar-Objekt unterstützte Datum und die späteste Uhrzeit ab.

MinSupportedDateTime

Ruft das früheste von diesem Calendar-Objekt unterstützte Datum und die früheste Uhrzeit ab.

TwoDigitYearMax

Ruft das letzte Jahr eines Bereichs von 100 Jahren ab, das durch eine Jahresangabe mit 2 Stellen dargestellt werden kann, oder legt dieses fest.

Methoden

AddDays(DateTime, Int32)

Gibt eine DateTime zurück, die dem angegebenen Zeitintervall zur angegebenen DateTime in Tagen entspricht.

AddHours(DateTime, Int32)

Gibt eine DateTime zurück, die dem angegebenen Zeitintervall zur angegebenen DateTime in Stunden entspricht.

AddMilliseconds(DateTime, Double)

Gibt eine DateTime zurück, die dem angegebenen Zeitintervall zur angegebenen DateTime in Millisekunden entspricht.

AddMinutes(DateTime, Int32)

Gibt eine DateTime zurück, die dem angegebenen Zeitintervall zur angegebenen DateTime in Minuten entspricht.

AddMonths(DateTime, Int32)

Gibt beim Überschreiben in einer abgeleiteten Klasse eine DateTime zurück, die dem angegebenen Zeitintervall zur angegebenen DateTime in Monaten entspricht.

AddSeconds(DateTime, Int32)

Gibt eine DateTime zurück, die dem angegebenen Zeitintervall zur angegebenen DateTime in Sekunden entspricht.

AddWeeks(DateTime, Int32)

Gibt eine DateTime zurück, die dem angegebenen Zeitintervall zur angegebenen DateTime in Wochen entspricht.

AddYears(DateTime, Int32)

Gibt beim Überschreiben in einer abgeleiteten Klasse eine DateTime zurück, die dem angegebenen Zeitintervall zur angegebenen DateTime in Jahren entspricht.

Clone()

Erstellt ein neues Objekt, das eine Kopie des aktuellen Calendar-Objekts darstellt.

Equals(Object)

Bestimmt, ob das angegebene Objekt gleich dem aktuellen Objekt ist.

(Geerbt von Object)
GetDayOfMonth(DateTime)

Gibt beim Überschreiben in einer abgeleiteten Klasse den Tag des Monats in der angegebenen DateTime zurück.

GetDayOfWeek(DateTime)

Gibt beim Überschreiben in einer abgeleiteten Klasse den Wochentag in der angegebenen DateTime zurück.

GetDayOfYear(DateTime)

Gibt beim Überschreiben in einer abgeleiteten Klasse den Tag des Jahres in der angegebenen DateTime zurück.

GetDaysInMonth(Int32, Int32)

Gibt die Anzahl der Tage im angegebenen Monat und Jahr im aktuellen Zeitraum zurück.

GetDaysInMonth(Int32, Int32, Int32)

Gibt beim Überschreiben in einer abgeleiteten Klasse die Anzahl der Tage im angegebenen Monat, Jahr und Zeitraum zurück.

GetDaysInYear(Int32)

Gibt die Anzahl der Tage im angegebenen Jahr des aktuellen Zeitraums zurück.

GetDaysInYear(Int32, Int32)

Gibt beim Überschreiben in einer abgeleiteten Klasse die Anzahl der Tage im angegebenen Jahr und Zeitraum zurück.

GetEra(DateTime)

Gibt beim Überschreiben in einer abgeleiteten Klasse den Zeitraum der angegebenen DateTime-Methode zurück.

GetHashCode()

Fungiert als Standardhashfunktion.

(Geerbt von Object)
GetHour(DateTime)

Gibt den Stundenwert in der angegebenen DateTime zurück.

GetLeapMonth(Int32)

Berechnet den Schaltmonat für ein angegebenes Jahr.

GetLeapMonth(Int32, Int32)

Berechnet den Schaltmonat für ein angegebenes Jahr und einen angegebenen Zeitraum.

GetMilliseconds(DateTime)

Gibt den Millisekundenwert in der angegebenen DateTime zurück.

GetMinute(DateTime)

Gibt den Minutenwert in der angegebenen DateTime zurück.

GetMonth(DateTime)

Gibt beim Überschreiben in einer abgeleiteten Klasse den Monat in der angegebenen DateTime zurück.

GetMonthsInYear(Int32)

Gibt die Anzahl der Monate des angegebenen Jahres im aktuellen Zeitraum zurück.

GetMonthsInYear(Int32, Int32)

Gibt beim Überschreiben in einer abgeleiteten Klasse die Anzahl der Monate des angegebenen Jahres im angegebenen Zeitraum zurück.

GetSecond(DateTime)

Gibt den Sekundenwert in der angegebenen DateTime zurück.

GetType()

Ruft den Type der aktuellen Instanz ab.

(Geerbt von Object)
GetWeekOfYear(DateTime, CalendarWeekRule, DayOfWeek)

Gibt die Woche des Jahrs zurück, in die das Datum im angegebenen DateTime-Wert fällt.

GetYear(DateTime)

Gibt beim Überschreiben in einer abgeleiteten Klasse das Jahr in der angegebenen DateTime zurück.

IsLeapDay(Int32, Int32, Int32)

Bestimmt, ob das angegebene Datum im aktuellen Zeitraum ein Schalttag ist.

IsLeapDay(Int32, Int32, Int32, Int32)

Bestimmt beim Überschreiben in einer abgeleiteten Klasse, ob das angegebene Datum im angegebenen Zeitraum ein Schalttag ist.

IsLeapMonth(Int32, Int32)

Bestimmt, ob der angegebene Monat des angegebenen Jahres im aktuellen Zeitraum ein Schaltmonat ist.

IsLeapMonth(Int32, Int32, Int32)

Bestimmt beim Überschreiben in einer abgeleiteten Klasse, ob der angegebene Monat des angegebenen Jahres im aktuellen Zeitraum ein Schaltmonat ist.

IsLeapYear(Int32)

Bestimmt, ob das angegebene Jahr im aktuellen Zeitraum ein Schaltjahr ist.

IsLeapYear(Int32, Int32)

Bestimmt beim Überschreiben in einer abgeleiteten Klasse, ob das angegebene Jahr im angegebenen Zeitraum ein Schaltjahr ist.

MemberwiseClone()

Erstellt eine flache Kopie des aktuellen Object.

(Geerbt von Object)
ReadOnly(Calendar)

Gibt eine schreibgeschützte Version des angegebenen Calendar-Objekts zurück.

ToDateTime(Int32, Int32, Int32, Int32, Int32, Int32, Int32)

Gibt eine DateTime zurück, die auf das angegebene Datum und die angegebene Uhrzeit im aktuellen Zeitraum festgelegt ist.

ToDateTime(Int32, Int32, Int32, Int32, Int32, Int32, Int32, Int32)

Gibt beim Überschreiben in einer abgeleiteten Klasse eine DateTime zurück, die auf das angegebene Datum und die angegebene Uhrzeit im aktuellen Zeitraum festgelegt ist.

ToFourDigitYear(Int32)

Konvertiert das angegebene Jahr in eine vierstellige Jahresangabe, indem anhand der TwoDigitYearMax-Eigenschaft das entsprechende Jahrhundert bestimmt wird.

ToString()

Gibt eine Zeichenfolge zurück, die das aktuelle Objekt darstellt.

(Geerbt von Object)

Gilt für:

Weitere Informationen