DateTime Struktur

Definition

Stellt einen Zeitpunkt dar, der normalerweise durch Datum und Uhrzeit dargestellt wird.

public value class DateTime : IComparable, IComparable<DateTime>, IConvertible, IEquatable<DateTime>, IFormattable
public value class DateTime : IComparable, IComparable<DateTime>, IConvertible, IEquatable<DateTime>, IFormattable, System::Runtime::Serialization::ISerializable
public value class DateTime : IComparable, IComparable<DateTime>, IConvertible, IEquatable<DateTime>, ISpanFormattable, System::Runtime::Serialization::ISerializable
public value class DateTime : IComparable, IConvertible, IFormattable
public value class DateTime : IComparable, IComparable<DateTime>, IEquatable<DateTime>, IFormattable
public struct DateTime : IComparable, IComparable<DateTime>, IConvertible, IEquatable<DateTime>, IFormattable
public struct DateTime : IComparable, IComparable<DateTime>, IConvertible, IEquatable<DateTime>, IFormattable, System.Runtime.Serialization.ISerializable
public struct DateTime : IComparable, IComparable<DateTime>, IConvertible, IEquatable<DateTime>, ISpanFormattable, System.Runtime.Serialization.ISerializable
[System.Serializable]
public struct DateTime : IComparable, IConvertible, IFormattable
[System.Serializable]
public struct DateTime : IComparable, IComparable<DateTime>, IConvertible, IEquatable<DateTime>, IFormattable, System.Runtime.Serialization.ISerializable
public struct DateTime : IComparable, IComparable<DateTime>, IEquatable<DateTime>, IFormattable
type DateTime = struct
    interface IConvertible
    interface IFormattable
type DateTime = struct
    interface IConvertible
    interface IFormattable
    interface ISerializable
type DateTime = struct
    interface IConvertible
    interface ISpanFormattable
    interface IFormattable
    interface ISerializable
[<System.Serializable>]
type DateTime = struct
    interface IFormattable
    interface IConvertible
[<System.Serializable>]
type DateTime = struct
    interface IFormattable
    interface IConvertible
    interface ISerializable
type DateTime = struct
    interface IFormattable
Public Structure DateTime
Implements IComparable, IComparable(Of DateTime), IConvertible, IEquatable(Of DateTime), IFormattable
Public Structure DateTime
Implements IComparable, IComparable(Of DateTime), IConvertible, IEquatable(Of DateTime), IFormattable, ISerializable
Public Structure DateTime
Implements IComparable, IComparable(Of DateTime), IConvertible, IEquatable(Of DateTime), ISerializable, ISpanFormattable
Public Structure DateTime
Implements IComparable, IConvertible, IFormattable
Public Structure DateTime
Implements IComparable, IComparable(Of DateTime), IEquatable(Of DateTime), IFormattable
Vererbung
DateTime
Attribute
Implementiert

Hinweise

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 dazu, ob Ihre Anwendungen betroffen sind, finden Sie unter Handling a new era in the Japanese calendar in .NET (Behandeln eines neuen Zeitraumes im japanischen Kalender in .NET). Informationen zum Testen Ihrer Anwendungen auf Windows Systemen, um deren Bereitschaft für den Zeitraumwechsel sicherzustellen, finden Sie unter Vorbereiten Ihrer Anwendung auf die Änderung des japanischen Zeitraumes. Informationen zu 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.

Hinweis

Einige C#-Beispiele in diesem Artikel werden in der Inlinecodeausführung und dem Playground von Try.NET ausgeführt. Klicken Sie auf die Schaltfläche Ausführen, um ein Beispiel in einem interaktiven Fenster auszuführen. Nachdem Sie den Code ausgeführt haben, können Sie ihn ändern und den geänderten Code durch erneutes Anklicken der Schaltfläche Ausführen ausführen. Der geänderte Code wird entweder im interaktiven Fenster ausgeführt, oder das interaktive Fenster zeigt alle C#-Compilerfehlermeldungen an, wenn die Kompilierung fehlschlägt.

Die lokale Zeitzone der Inlinecodeausführung und dem Playground von Try.NET wird ist die Koordinierte Weltzeit (UTC). Dies kann sich auf das Verhalten und die Ausgabe von Beispielen auswirken, die die Typen DateTime, DateTimeOffset und TimeZoneInfo sowie deren Member veranschaulichen.

Dieser Artikel enthält mehrere Beispiele, die den -Typ DateTime verwenden:

Initialisierungsbeispiele

Formatieren von DateTime Objekten als Zeichenfolgen

Analyse von Zeichenfolgen als DateTime Objekte

DateTime Auflösung

Kultur und Kalender

Persistenz

Dieser Abschnitt enthält Themen für viele gängige Verwendungsmöglichkeiten DateTime der Struktur:

Der Werttyp stellt Datumsangaben und Zeiten mit Werten im Bereich von DateTime 00:00:00 (Mitternacht), 1. Januar 0001 Anno Domini (Common Era) bis 23:59:59 Uhr, 31. Dezember 9999 n. D. dar. im gregorianischen Kalender.

Zeitwerte werden in Einheiten von 100 Nanosekunden gemessen, die als Ticks bezeichnet werden. Ein bestimmtes Datum ist die Anzahl der Ticks seit Mitternacht um 12:00 Uhr, 1. Januar 0001 n. D. (C.E.) im GregorianCalendar Kalender. Die Zahl schließt Ticks aus, die nach Schaltsekunden hinzugefügt würden. Beispielsweise stellt der Tickwert 312413760000000000L das Datum Friday, January 01, 0100 12:00:00 midnight dar. Ein DateTime Wert wird immer im Kontext eines expliziten oder Standardkalenders ausgedrückt.

Hinweis

Wenn Sie mit einem Teilstrichwert arbeiten, den Sie in ein anderes Zeitintervall konvertieren möchten, z. B. Minuten oder Sekunden, sollten Sie die Konvertierung mithilfe der Konstanten TimeSpan.TicksPerDay , , , oder TimeSpan.TicksPerHour TimeSpan.TicksPerMinute TimeSpan.TicksPerSecond TimeSpan.TicksPerMillisecond durchführen. Wenn Sie z. B. die Anzahl von Sekunden hinzufügen möchten, die durch eine angegebene Anzahl von Ticks zur Komponente eines Werts dargestellt wird, können Sie Second DateTime den Ausdruck dateValue.Second + nTicks/Timespan.TicksPerSecond verwenden.

Sie können die Quelle für den gesamten Satz von Beispielen aus diesem Artikel in Visual Basic oder C# im Repository docs auf GitHub.

Hinweis

Eine Alternative zur DateTime -Struktur für die Arbeit mit Datums- und Uhrzeitwerten in bestimmten Zeitzonen ist die DateTimeOffset -Struktur. Die -Struktur speichert Datums- und Uhrzeitinformationen in einem privaten Feld und die Anzahl der Minuten, um die sich datum und uhrzeit von DateTimeOffset der UTC in einem privaten Feld DateTime Int16 unterscheiden. Dies ermöglicht es einer DateTimeOffset Wert entsprechend der die Zeit in einer bestimmten Zeitzone, während eine DateTime Wert kann nur UTC und der lokalen Zeitzone eindeutig darstellen. Eine Diskussion darüber, wann die -Struktur oder die -Struktur beim Arbeiten mit Datums- und Uhrzeitwerten verwendet werden soll, finden Sie unter DateTime DateTimeOffset Choosing Between DateTime, DateTimeOffset, TimeSpan, and TimeZoneInfo.

Initialisieren eines DateTime-Objekts

Sie können einem neuen Wert auf viele verschiedene DateTime Arten einen Anfangswert zuweisen:

  • Aufrufen eines Konstruktors, entweder eines, in dem Sie Argumente für -Werte angeben, oder Verwenden des impliziten parameterlosen Konstruktors.
  • Zuweisen eines DateTime zum Rückgabewert einer Eigenschaft oder Methode.
  • Analyse eines Werts DateTime aus seiner Zeichenfolgendarstellung.
  • Verwenden Visual Basic spezifischen Sprachfeatures zum Instanziieren eines DateTime .

Die folgenden Codeausschnitte zeigen Jeweils Beispiele:

Aufrufen von Konstruktoren

Sie rufen eine der Überladungen des Konstruktors auf, die Elemente des Datums- und Uhrzeitwerts angeben (z. B. Jahr, Monat und Tag oder die Anzahl DateTime von Ticks). Der folgende Code erstellt ein bestimmtes Datum mithilfe des Konstruktors, der das DateTime Jahr, den Monat, den Tag, die Stunde, die Minute und die Sekunde an gibt.

Dim date1 As New Date(2008, 5, 1, 8, 30, 52)
var date1 = new DateTime(2008, 5, 1, 8, 30, 52);
Console.WriteLine(date1);

Sie rufen den impliziten parameterlosen Konstruktor der Struktur auf, wenn DateTime ein auf seinen Standardwert DateTime initialisiert werden soll. (Weitere Informationen zum impliziten parameterlosen Konstruktor eines Werttyps finden Sie unter Werttypen.) Einige Compiler unterstützen auch das Deklarieren eines Werts, ohne ihm DateTime explizit einen Wert zu zuweisen. Das Erstellen eines Werts ohne explizite Initialisierung führt ebenfalls zum Standardwert. Das folgende Beispiel veranschaulicht den impliziten parameterlosen Konstruktor in C# und Visual Basic sowie eine Deklaration DateTime DateTime ohne Zuweisung in Visual Basic.

Dim dat1 As DateTime
' The following method call displays 1/1/0001 12:00:00 AM.
Console.WriteLine(dat1.ToString(System.Globalization.CultureInfo.InvariantCulture))
' The following method call displays True.
Console.WriteLine(dat1.Equals(Date.MinValue))

Dim dat2 As New DateTime()
' The following method call displays 1/1/0001 12:00:00 AM.
Console.WriteLine(dat2.ToString(System.Globalization.CultureInfo.InvariantCulture))
' The following method call displays True.
Console.WriteLine(dat2.Equals(Date.MinValue))
var dat1 = new DateTime();
// The following method call displays 1/1/0001 12:00:00 AM.
Console.WriteLine(dat1.ToString(System.Globalization.CultureInfo.InvariantCulture));
// The following method call displays True.
Console.WriteLine(dat1.Equals(DateTime.MinValue));
Zuweisen eines berechneten Werts

Sie können dem Objekt DateTime einen Datums- und Uhrzeitwert zuweisen, der von einer Eigenschaft oder Methode zurückgegeben wird. Im folgenden Beispiel werden das aktuelle Datum und die aktuelle Uhrzeit, das aktuelle datum koordinierte Weltzeit (UTC) und das aktuelle Datum drei neuen DateTime Variablen zugewiesen.

Dim date1 As Date = Date.Now
Dim date2 As Date = Date.UtcNow
Dim date3 As Date = Date.Today
DateTime date1 = DateTime.Now;
DateTime date2 = DateTime.UtcNow;
DateTime date3 = DateTime.Today;
Analyse einer Zeichenfolge, die einen DateTime-Wert darstellt

Die Parse Methoden , , und konvertieren alle eine ParseExact TryParse TryParseExact Zeichenfolge in den entsprechenden Datums- und Uhrzeitwert. In den folgenden Beispielen werden die Parse Methoden und ParseExact verwendet, um eine Zeichenfolge zu analysieren und in einen Wert zu DateTime konvertieren. Das zweite Format verwendet ein Formular, das vom ISO 8601-Standard unterstützt wird, um Datum und Uhrzeit im Zeichenfolgenformat zu darstellen. Diese Standarddarstellung wird häufig verwendet, um Datumsinformationen in Webdiensten zu übertragen.

Dim dateString As String = "5/1/2008 8:30:52 AM"
Dim date1 As Date = Date.Parse(dateString,
                       System.Globalization.CultureInfo.InvariantCulture)
Dim iso8601String As String = "20080501T08:30:52Z"
Dim dateISO8602 As Date = DateTime.ParseExact(iso8601String, "yyyyMMddTHH:mm:ssZ",
                              System.Globalization.CultureInfo.InvariantCulture)
Console.WriteLine(dateISO8602)
var dateString = "5/1/2008 8:30:52 AM";
DateTime date1 = DateTime.Parse(dateString,
                          System.Globalization.CultureInfo.InvariantCulture);
var iso8601String = "20080501T08:30:52Z";
DateTime dateISO8602 = DateTime.ParseExact(iso8601String, "yyyyMMddTHH:mm:ssZ",
                                System.Globalization.CultureInfo.InvariantCulture);

Die TryParse Methoden und geben an, ob eine Zeichenfolge eine gültige Darstellung eines Werts ist, und führt, falls dies der Wert TryParseExact DateTime ist, die Konvertierung aus.

Sprachspezifische Syntax für Visual Basic

Die folgende Visual Basic initialisiert einen neuen DateTime Wert.

Dim date1 As Date = #5/1/2008 8:30:52AM#

DateTime-Werte und ihre Zeichenfolgendarstellungen

Intern werden alle Werte als die Anzahl der Ticks (die Anzahl von 100-Nanosekunden-Intervallen) dargestellt, die seit Mitternacht, dem DateTime 1. Januar 0001, 12:00:00 Verstrichen sind. Der tatsächliche DateTime Wert ist unabhängig davon, wie dieser Wert angezeigt wird, wenn er angezeigt wird. Die Darstellung eines Werts ist das Ergebnis eines Formatierungsvorgang, der einen DateTime Wert in seine Zeichenfolgendarstellung konvertiert.

Die Darstellung von Datums- und Uhrzeitwerten hängt von kulturabhängigen, internationalen Standards, Anwendungsanforderungen und persönlichen Vorlieben ab. Die DateTime -Struktur bietet Flexibilität beim Formatieren von Datums- und Uhrzeitwerten durch Überladungen von ToString . Die DateTime.ToString() Standardmethode gibt die Zeichenfolgendarstellung eines Datums- und Uhrzeitwerts unter Verwendung des kurzen Datums- und Zeitmusters der aktuellen Kultur zurück. Im folgenden Beispiel wird die Standardmethode DateTime.ToString() verwendet. Das Datum und die Uhrzeit werden unter Verwendung des kurzen Datums- und Zeitmusters für die aktuelle Kultur angezeigt. Die Kultur en-US ist die aktuelle Kultur auf dem Computer, auf dem das Beispiel ausgeführt wurde.

var date1 = new DateTime(2008, 3, 1, 7, 0, 0);
Console.WriteLine(date1.ToString());
// For en-US culture, displays 3/1/2008 7:00:00 AM
Dim date1 As Date = #3/1/2008 7:00AM#
Console.WriteLine(date1.ToString())
' For en-US culture, displays 3/1/2008 7:00:00 AM

Möglicherweise müssen Sie Datumsangaben in einer bestimmten Kultur formatieren, um Webszenarios zu unterstützen, in denen sich der Server möglicherweise in einer anderen Kultur als der Client befing. Sie geben die Kultur mithilfe der -Methode an, um die Darstellung des kurzen Datums und der langen DateTime.ToString(IFormatProvider) Zeit in einer bestimmten Kultur zu erstellen. Im folgenden Beispiel wird die -Methode verwendet, um das Datum und die Uhrzeit unter Verwendung des Kurzen Datums- und Zeitmusters für die DateTime.ToString(IFormatProvider) Fr-FR-Kultur anzuzeigen.

var date1 = new DateTime(2008, 3, 1, 7, 0, 0);
Console.WriteLine(date1.ToString(System.Globalization.CultureInfo.CreateSpecificCulture("fr-FR")));
// Displays 01/03/2008 07:00:00
Dim date1 As Date = #3/1/2008 7:00AM#
Console.WriteLine(date1.ToString(System.Globalization.CultureInfo.CreateSpecificCulture("fr-FR")))
' Displays 01/03/2008 07:00:00

Andere Anwendungen erfordern möglicherweise unterschiedliche Zeichenfolgendarstellungen eines Datums. Die DateTime.ToString(String) -Methode gibt die Zeichenfolgendarstellung zurück, die von einem Standardformatbezeichner oder benutzerdefinierten Formatbezeichner mithilfe der Formatierungskonventionen der aktuellen Kultur definiert wird. Im folgenden Beispiel wird die -Methode verwendet, um das vollständige Datums- und Uhrzeitmuster für die Kultur en-US anzuzeigen, die aktuelle Kultur auf dem Computer, auf dem das DateTime.ToString(String) Beispiel ausgeführt wurde.

var date1 = new DateTime(2008, 3, 1, 7, 0, 0);
Console.WriteLine(date1.ToString("F"));
// Displays Saturday, March 01, 2008 7:00:00 AM
Dim date1 As Date = #3/1/2008 7:00AM#
Console.WriteLine(date1.ToString("F"))
' Displays Saturday, March 01, 2008 7:00:00 AM

Schließlich können Sie sowohl die Kultur als auch das Format mithilfe der -Methode DateTime.ToString(String, IFormatProvider) angeben. Im folgenden Beispiel wird die DateTime.ToString(String, IFormatProvider) -Methode verwendet, um das vollständige Datums- und Uhrzeitmuster für die kultur fr-FR anzuzeigen.

var date1 = new DateTime(2008, 3, 1, 7, 0, 0);
Console.WriteLine(date1.ToString("F", new System.Globalization.CultureInfo("fr-FR")));
// Displays samedi 1 mars 2008 07:00:00
Dim date1 As Date = #3/1/2008 7:00AM#
Console.WriteLine(date1.ToString("F", New System.Globalization.CultureInfo("fr-FR")))
' Displays samedi 1 mars 2008 07:00:00

Die DateTime.ToString(String) -Überladung kann auch mit einer benutzerdefinierten Formatzeichenfolge verwendet werden, um andere Formate anzugeben. Das folgende Beispiel zeigt, wie Sie eine Zeichenfolge mit dem ISO 8601-Standardformat formatieren, das häufig für Webdienste verwendet wird. Das Iso 8601-Format hat keine entsprechende Standardformatzeichenfolge.

var date1 = new DateTime(2008, 3, 1, 7, 0, 0);
Console.WriteLine(date1.ToString("yyyyMMddTHH:mm:ssZ"));
// Displays 20080301T07:00:00Z
Dim date1 As Date = #3/1/2008 7:00AM#
Console.WriteLine(date1.ToString("yyyyMMddTHH:mm:ssZ"))
' Displays 20080301T07:00:00Z

Weitere Informationen zum Formatieren von Werten finden Sie unter Standardformatzeichenfolgen für Datum und Uhrzeit DateTime und Benutzerdefinierte Formatzeichenfolgen für Datum und Uhrzeit.

Analyse von DateTime-Werten aus Zeichenfolgen

Bei der Analyse wird die Zeichenfolgendarstellung eines Datums und einer Uhrzeit in einen Wert DateTime konvertiert. In der Regel haben Datums- und Uhrzeitzeichenfolgen zwei unterschiedliche Verwendungsmöglichkeiten in Anwendungen:

  • Ein Datum und eine Uhrzeit haben eine Vielzahl von Formen und spiegeln die Konventionen der aktuellen Kultur oder einer bestimmten Kultur wider. Beispielsweise ermöglicht eine Anwendung einem Benutzer, dessen aktuelle Kultur en-US ist, die Eingabe eines Datumswerts als "15.12.2013" oder "15. Dezember 2013". Benutzer, deren aktuelle Kultur en-gb ist, können einen Datumswert als "15.12.2013" oder "15. Dezember 2013" eingeben.

  • Datum und Uhrzeit werden in einem vordefinierten Format dargestellt. Beispielsweise serialisiert eine Anwendung ein Datum als "20130103" unabhängig von der Kultur, in der die App ausgeführt wird. Eine Anwendung erfordert möglicherweise, dass Datumsangaben im kurzen Datumsformat der aktuellen Kultur eingegeben werden.

Sie verwenden die - oder -Methode, um eine Zeichenfolge aus einem der gängigen Datums- und Uhrzeitformate, die von einer Kultur verwendet werden, in Parse TryParse einen Wert zu DateTime konvertieren. Das folgende Beispiel zeigt, wie Sie verwenden können, TryParse um Datumszeichenfolgen in verschiedenen kulturspezifischen Formaten in einen -Wert zu DateTime konvertieren. Sie ändert die aktuelle Kultur in Englisch (Großbritannien) und ruft die -Methode auf, um ein Array von Datums- GetDateTimeFormats() und Uhrzeitzeichenfolgen zu generieren. Anschließend wird jedes Element im Array an die -Methode TryParse übergeben. Die Ausgabe des Beispiels zeigt, dass die Analysemethode jede kulturspezifische Datums- und Uhrzeitzeichenfolge erfolgreich konvertieren konnte.

System.Threading.Thread.CurrentThread.CurrentCulture =
    System.Globalization.CultureInfo.CreateSpecificCulture("en-GB");

var date1 = new DateTime(2013, 6, 1, 12, 32, 30);
var badFormats = new List<String>();

Console.WriteLine($"{"Date String",-37} {"Date",-19}\n");
foreach (var dateString in date1.GetDateTimeFormats())
{
    DateTime parsedDate;
    if (DateTime.TryParse(dateString, out parsedDate))
        Console.WriteLine($"{dateString,-37} {DateTime.Parse(dateString),-19}");
    else
        badFormats.Add(dateString);
}

// Display strings that could not be parsed.
if (badFormats.Count > 0)
{
    Console.WriteLine("\nStrings that could not be parsed: ");
    foreach (var badFormat in badFormats)
        Console.WriteLine($"   {badFormat}");
}
// Press "Run" to see the output.
Thread.CurrentThread.CurrentCulture = CultureInfo.CreateSpecificCulture("en-GB")

Dim date1 As New DateTime(2013, 6, 1, 12, 32, 30)
Dim badFormats As New List(Of String)

Console.WriteLine($"{"Date String",-37} {"Date",-19}")
Console.WriteLine()
For Each dateString As String In date1.GetDateTimeFormats()
    Dim parsedDate As DateTime
    If DateTime.TryParse(dateString, parsedDate) Then
        Console.WriteLine($"{dateString,-37} {DateTime.Parse(dateString),-19:g}")
    Else
        badFormats.Add(dateString)
    End If
Next

' Display strings that could not be parsed.
If badFormats.Count > 0 Then
    Console.WriteLine()
    Console.WriteLine("Strings that could not be parsed: ")
    For Each badFormat In badFormats
        Console.WriteLine($"   {badFormat}")
    Next
End If
' The example displays the following output:
'       Date String                           Date               
'       
'       01/06/2013                            01/06/2013 00:00:00
'       01/06/13                              01/06/2013 00:00:00
'       1/6/13                                01/06/2013 00:00:00
'       1.6.13                                01/06/2013 00:00:00
'       2013-06-01                            01/06/2013 00:00:00
'       01 June 2013                          01/06/2013 00:00:00
'       1 June 2013                           01/06/2013 00:00:00
'       01 June 2013 12:32                    01/06/2013 12:32:00
'       01 June 2013 12:32                    01/06/2013 12:32:00
'       01 June 2013 12:32 PM                 01/06/2013 12:32:00
'       01 June 2013 12:32 PM                 01/06/2013 12:32:00
'       1 June 2013 12:32                     01/06/2013 12:32:00
'       1 June 2013 12:32                     01/06/2013 12:32:00
'       1 June 2013 12:32 PM                  01/06/2013 12:32:00
'       1 June 2013 12:32 PM                  01/06/2013 12:32:00
'       01 June 2013 12:32:30                 01/06/2013 12:32:30
'       01 June 2013 12:32:30                 01/06/2013 12:32:30
'       01 June 2013 12:32:30 PM              01/06/2013 12:32:30
'       01 June 2013 12:32:30 PM              01/06/2013 12:32:30
'       1 June 2013 12:32:30                  01/06/2013 12:32:30
'       1 June 2013 12:32:30                  01/06/2013 12:32:30
'       1 June 2013 12:32:30 PM               01/06/2013 12:32:30
'       1 June 2013 12:32:30 PM               01/06/2013 12:32:30
'       01/06/2013 12:32                      01/06/2013 12:32:00
'       01/06/2013 12:32                      01/06/2013 12:32:00
'       01/06/2013 12:32 PM                   01/06/2013 12:32:00
'       01/06/2013 12:32 PM                   01/06/2013 12:32:00
'       01/06/13 12:32                        01/06/2013 12:32:00
'       01/06/13 12:32                        01/06/2013 12:32:00
'       01/06/13 12:32 PM                     01/06/2013 12:32:00
'       01/06/13 12:32 PM                     01/06/2013 12:32:00
'       1/6/13 12:32                          01/06/2013 12:32:00
'       1/6/13 12:32                          01/06/2013 12:32:00
'       1/6/13 12:32 PM                       01/06/2013 12:32:00
'       1/6/13 12:32 PM                       01/06/2013 12:32:00
'       1.6.13 12:32                          01/06/2013 12:32:00
'       1.6.13 12:32                          01/06/2013 12:32:00
'       1.6.13 12:32 PM                       01/06/2013 12:32:00
'       1.6.13 12:32 PM                       01/06/2013 12:32:00
'       2013-06-01 12:32                      01/06/2013 12:32:00
'       2013-06-01 12:32                      01/06/2013 12:32:00
'       2013-06-01 12:32 PM                   01/06/2013 12:32:00
'       2013-06-01 12:32 PM                   01/06/2013 12:32:00
'       01/06/2013 12:32:30                   01/06/2013 12:32:30
'       01/06/2013 12:32:30                   01/06/2013 12:32:30
'       01/06/2013 12:32:30 PM                01/06/2013 12:32:30
'       01/06/2013 12:32:30 PM                01/06/2013 12:32:30
'       01/06/13 12:32:30                     01/06/2013 12:32:30
'       01/06/13 12:32:30                     01/06/2013 12:32:30
'       01/06/13 12:32:30 PM                  01/06/2013 12:32:30
'       01/06/13 12:32:30 PM                  01/06/2013 12:32:30
'       1/6/13 12:32:30                       01/06/2013 12:32:30
'       1/6/13 12:32:30                       01/06/2013 12:32:30
'       1/6/13 12:32:30 PM                    01/06/2013 12:32:30
'       1/6/13 12:32:30 PM                    01/06/2013 12:32:30
'       1.6.13 12:32:30                       01/06/2013 12:32:30
'       1.6.13 12:32:30                       01/06/2013 12:32:30
'       1.6.13 12:32:30 PM                    01/06/2013 12:32:30
'       1.6.13 12:32:30 PM                    01/06/2013 12:32:30
'       2013-06-01 12:32:30                   01/06/2013 12:32:30
'       2013-06-01 12:32:30                   01/06/2013 12:32:30
'       2013-06-01 12:32:30 PM                01/06/2013 12:32:30
'       2013-06-01 12:32:30 PM                01/06/2013 12:32:30
'       01 June                               01/06/2013 00:00:00
'       01 June                               01/06/2013 00:00:00
'       2013-06-01T12:32:30.0000000           01/06/2013 12:32:30
'       2013-06-01T12:32:30.0000000           01/06/2013 12:32:30
'       Sat, 01 Jun 2013 12:32:30 GMT         01/06/2013 05:32:30
'       Sat, 01 Jun 2013 12:32:30 GMT         01/06/2013 05:32:30
'       2013-06-01T12:32:30                   01/06/2013 12:32:30
'       12:32                                 22/04/2013 12:32:00
'       12:32                                 22/04/2013 12:32:00
'       12:32 PM                              22/04/2013 12:32:00
'       12:32 PM                              22/04/2013 12:32:00
'       12:32:30                              22/04/2013 12:32:30
'       12:32:30                              22/04/2013 12:32:30
'       12:32:30 PM                           22/04/2013 12:32:30
'       12:32:30 PM                           22/04/2013 12:32:30
'       2013-06-01 12:32:30Z                  01/06/2013 05:32:30
'       01 June 2013 19:32:30                 01/06/2013 19:32:30
'       01 June 2013 19:32:30                 01/06/2013 19:32:30
'       01 June 2013 07:32:30 PM              01/06/2013 19:32:30
'       01 June 2013 7:32:30 PM               01/06/2013 19:32:30
'       1 June 2013 19:32:30                  01/06/2013 19:32:30
'       1 June 2013 19:32:30                  01/06/2013 19:32:30
'       1 June 2013 07:32:30 PM               01/06/2013 19:32:30
'       1 June 2013 7:32:30 PM                01/06/2013 19:32:30
'       June 2013                             01/06/2013 00:00:00
'       June 2013                             01/06/2013 00:00:00

Sie verwenden die Methoden und , um eine Zeichenfolge, die mit einem bestimmten Format oder Format übereinstimmen ParseExact TryParseExact muss, in einen Wert zu DateTime konvertieren. Sie geben mindestens eine Datums- und Uhrzeitformatzeichenfolge als Parameter für die Analysemethode an. Im folgenden Beispiel wird die -Methode verwendet, um Zeichenfolgen, die entweder im TryParseExact(String, String[], IFormatProvider, DateTimeStyles, DateTime) Format "yyyyMMdd" oder im Format "HHmmss" vorliegen müssen, in Werte zu DateTime konvertieren.

string[] formats = { "yyyyMMdd", "HHmmss" };
string[] dateStrings = { "20130816", "20131608", "  20130816   ",
                   "115216", "521116", "  115216  " };
DateTime parsedDate;

foreach (var dateString in dateStrings)
{
    if (DateTime.TryParseExact(dateString, formats, null,
                               System.Globalization.DateTimeStyles.AllowWhiteSpaces |
                               System.Globalization.DateTimeStyles.AdjustToUniversal,
                               out parsedDate))
        Console.WriteLine($"{dateString} --> {parsedDate:g}");
    else
        Console.WriteLine($"Cannot convert {dateString}");
}
// The example displays the following output:
//       20130816 --> 8/16/2013 12:00 AM
//       Cannot convert 20131608
//         20130816    --> 8/16/2013 12:00 AM
//       115216 --> 4/22/2013 11:52 AM
//       Cannot convert 521116
//         115216   --> 4/22/2013 11:52 AM
Dim formats() As String = {"yyyyMMdd", "HHmmss"}
Dim dateStrings() As String = {"20130816", "20131608",
                              "  20130816   ", "115216",
                              "521116", "  115216  "}
Dim parsedDate As DateTime

For Each dateString As String In dateStrings
    If DateTime.TryParseExact(dateString, formats, Nothing,
                           DateTimeStyles.AllowWhiteSpaces Or
                           DateTimeStyles.AdjustToUniversal,
                           parsedDate) Then
        Console.WriteLine($"{dateString} --> {parsedDate:g}")
    Else
        Console.WriteLine($"Cannot convert {dateString}")
    End If
Next
' The example displays the following output:
'       20130816 --> 8/16/2013 12:00 AM
'       Cannot convert 20131608
'         20130816    --> 8/16/2013 12:00 AM
'       115216 --> 4/22/2013 11:52 AM
'       Cannot convert 521116
'         115216   --> 4/22/2013 11:52 AM

Eine gängige Verwendung für ist das Konvertieren einer Zeichenfolgendarstellung aus einem Webdienst, in der Regel ParseExact im ISO 8601-Standardformat. Der folgende Code zeigt die richtige Zu verwendende Formatzeichenfolge:

var iso8601String = "20080501T08:30:52Z";
DateTime dateISO8602 = DateTime.ParseExact(iso8601String, "yyyyMMddTHH:mm:ssZ",
    System.Globalization.CultureInfo.InvariantCulture);
Console.WriteLine($"{iso8601String} --> {dateISO8602:g}");
Dim iso8601String As String = "20080501T08:30:52Z"
Dim dateISO8602 As DateTime = DateTime.ParseExact(iso8601String, "yyyyMMddTHH:mm:ssZ", CultureInfo.InvariantCulture)
Console.WriteLine($"{iso8601String} --> {dateISO8602:g}")

Wenn eine Zeichenfolge nicht analysiert werden kann, löst die Parse -Methode und ParseExact die -Methode eine Ausnahme aus. Die TryParse Methoden und geben einen Wert TryParseExact Boolean zurück, der angibt, ob die Konvertierung erfolgreich war oder fehlgeschlagen ist. Sie sollten die Methoden TryParse oder TryParseExact in Szenarien verwenden, in denen die Leistung wichtig ist. Der Analysevorgang für Datums- und Uhrzeitzeichenfolgen hat in der Regel eine hohe Fehlerrate, und die Ausnahmebehandlung ist teuer. Verwenden Sie diese Methoden, wenn Zeichenfolgen von Benutzern eingegeben werden oder aus einer unbekannten Quelle stammen.

Weitere Informationen zum Analyse von Datums- und Uhrzeitwerten finden Sie unter Analyse von Datums- und Uhrzeitzeichenfolgen.

DateTime-Werte

Beschreibungen von Zeitwerten im Typ werden häufig mithilfe DateTime des UTC-Koordinierte Weltzeit (Utc) ausgedrückt. koordinierte Weltzeit ist der international bekannte Name für Greenwich Mean Time (GMT). koordinierte Weltzeit ist die Zeit, gemessen bei einem Längengrad von null Grad, dem UTC-Ursprungspunkt. Die Sommerzeit gilt nicht für UTC.

Die Ortszeit ist relativ zu einer bestimmten Zeitzone. Eine Zeitzone ist einem Zeitzonenoffset zugeordnet. Ein Zeitzonenoffset ist die Verschiebung der Zeitzone, die in Stunden vom UTC-Ursprungspunkt gemessen wird. Darüber hinaus wird die Ortszeit optional von der Sommerzeit beeinflusst, die eine Anpassung des Zeitintervalls hinzufügt oder subtrahiert. Die Ortszeit wird berechnet, indem der Zeitzonenoffset zur UTC hinzugefügt und bei Bedarf die Sommerzeit angepasst wird. Der Zeitzonenoffset am UTC-Ursprungspunkt ist 0 (null).

Die UTC-Zeit eignet sich für Berechnungen, Vergleiche und das Speichern von Datums- und Uhrzeitangaben in Dateien. Die Ortszeit ist für die Anzeige in Benutzeroberflächen von Desktopanwendungen geeignet. Zeitzonenspezifische Anwendungen (z. B. viele Webanwendungen) müssen auch mit einer Reihe anderer Zeitzonen arbeiten.

Wenn die -Eigenschaft eines -Objekts ist, ist nicht angegeben, ob die dargestellte Zeit die Ortszeit, UTC-Zeit oder eine Uhrzeit Kind in einer anderen Zeitzone DateTime DateTimeKind.Unspecified ist.

DateTime-Auflösung

Hinweis

Als Alternative zum Ausführen einer Datums- und Uhrzeitarithmetik für Werte zum Messen der verstrichenen Zeit können DateTime Sie die -Klasse Stopwatch verwenden.

Die Ticks -Eigenschaft drückt Datums- und Uhrzeitwerte in Einheiten von einem Zehn-Millionstel einer Sekunde aus. Die Millisecond -Eigenschaft gibt die Tausendstel sekunde in einem Datums- und Uhrzeitwert zurück. Die Verwendung wiederholter Aufrufe DateTime.Now der -Eigenschaft zum Messen der verstrichenen Zeit hängt von der Systemuhr ab. Die Systemuhr auf Windows 7 und Windows 8 hat eine Auflösung von ca. 15 Millisekunden. Diese Auflösung wirkt sich auf kleine Zeitintervalle unter 100 Millisekunden aus.

Das folgende Beispiel veranschaulicht die Abhängigkeit der aktuellen Datums- und Uhrzeitwerte von der Auflösung der Systemuhr. Im Beispiel wiederholt sich eine äußere Schleife 20 Mal, und eine innere Schleife dient dazu, die äußere Schleife zu verzögern. Wenn der Wert des äußeren Schleifenzählers 10 ist, führt ein Aufruf der -Methode zu einer Verzögerung von fünf Thread.Sleep Millisekunden. Das folgende Beispiel zeigt die Anzahl der Millisekunden, die von der -Eigenschaft zurückgegeben DateTime.Now.Milliseconds werden, erst nach dem Aufruf von Thread.Sleep .

string output = "";
for (int ctr = 0; ctr <= 20; ctr++)
{
    output += String.Format($"{DateTime.Now.Millisecond}\n");
    // Introduce a delay loop.
    for (int delay = 0; delay <= 1000; delay++)
    { }

    if (ctr == 10)
    {
        output += "Thread.Sleep called...\n";
        System.Threading.Thread.Sleep(5);
    }
}
Console.WriteLine(output);
// Press "Run" to see the output.
Dim output As String = ""
For ctr As Integer = 0 To 20
    output += Date.Now.Millisecond.ToString() + vbCrLf
    ' Introduce a delay loop.
    For delay As Integer = 0 To 1000
    Next

    If ctr = 10 Then
        output += "Thread.Sleep called..." + vbCrLf
        Thread.Sleep(5)
    End If
Next
Console.WriteLine(output)
' The example displays output like the following:
'       111
'       111
'       111
'       111
'       111
'       111
'       111
'       111
'       111
'       111
'       111
'       Thread.Sleep called...
'       143
'       143
'       143
'       143
'       143
'       143
'       143
'       143
'       143
'       143

DateTime-Vorgänge

Eine Berechnung mit einer DateTime -Struktur, z. B. oder , ändert Add den Wert der Subtract -Struktur nicht. Stattdessen gibt die Berechnung eine neue -Struktur DateTime zurück, deren Wert das Ergebnis der Berechnung ist.

Konvertierungsvorgänge zwischen Zeitzonen (z. B. zwischen UTC und Ortszeit oder zwischen einer Zeitzone und einer anderen) berücksichtigen die Sommerzeit, arithmetische vorgänge und Vergleichsvorgänge jedoch nicht.

Die DateTime Struktur selbst bietet eingeschränkte Unterstützung für die Konvertierung von einer Zeitzone in eine andere. Sie können die -Methode verwenden, um UTC in Ortszeit zu konvertieren, oder Sie können die -Methode verwenden, um von der lokalen Zeit in UTC ToLocalTime ToUniversalTime zu konvertieren. In der -Klasse ist jedoch ein vollständiger Satz von Zeitzonenkonvertierungsmethoden TimeZoneInfo verfügbar. Sie konvertieren die Zeit in einer der Zeitzonen der Welt mithilfe dieser Methoden in die Uhrzeit in einer beliebigen anderen Zeitzone.

Berechnungen und Vergleiche von Objekten sind nur sinnvoll, wenn die Objekte DateTime Zeiten in derselben Zeitzone darstellen. Sie können ein TimeZoneInfo -Objekt verwenden, um die DateTime Zeitzone eines Werts zu darstellen, obwohl die beiden lose gekoppelt sind. Ein DateTime -Objekt verfügt nicht über eine -Eigenschaft, die ein Objekt zurückgibt, das die Zeitzone dieses Datums- und Uhrzeitwerts darstellt. Die Kind -Eigenschaft gibt an, ob DateTime eine UTC, Ortszeit oder nicht angegeben ist. In einer zeitzonenorientierten Anwendung müssen Sie sich auf einen externen Mechanismus verlassen, um die Zeitzone zu bestimmen, in der ein DateTime -Objekt erstellt wurde. Sie können eine -Struktur verwenden, die sowohl den Wert als auch das Objekt umschließt, DateTime das die Zeitzone des TimeZoneInfo DateTime Werts darstellt. Weitere Informationen zur Verwendung von UTC in Berechnungen und Vergleichen mit Werten finden Sie unter Ausführen arithmetischer Operationen DateTime mit Datums- und Zeitangaben.

Jedes DateTime Member verwendet implizit den gregorianischen Kalender, um seine Operation durchzuführen. Ausnahmen sind Methoden, die implizit einen Kalender angeben. Dazu gehören Konstruktoren, die einen Kalender angeben, und Methoden mit einem von abgeleiteten IFormatProvider Parameter, z. System.Globalization.DateTimeFormatInfo B. .

Vorgänge nach Membern des Typs berücksichtigen Details wie Schaltjahre und die Anzahl DateTime der Tage in einem Monat.

DateTime-Werte und -Kalender

Die .NET Framework-Klassenbibliothek enthält eine Reihe von Kalenderklassen, die alle von der -Klasse abgeleitet Calendar werden. Sie lauten wie folgt:

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 dazu, ob Ihre Anwendungen betroffen sind, finden Sie unter Handling a new era in the Japanese calendar in .NET (Behandeln eines neuen Zeitraumes im japanischen Kalender in .NET). Informationen zum Testen Ihrer Anwendungen auf Windows Systemen, um deren Bereitschaft für den Zeitraumwechsel sicherzustellen, finden Sie unter Vorbereiten Ihrer Anwendung auf die Änderung des japanischen Zeitraumes. Informationen zu 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.

Jede Kultur verwendet einen Standardkalender, der durch ihre schreibgeschützte Eigenschaft definiert CultureInfo.Calendar wird. Jede Kultur kann einen oder mehrere Kalender unterstützen, die durch ihre schreibgeschützte Eigenschaft definiert CultureInfo.OptionalCalendars werden. Der kalender, der derzeit von einem bestimmten -Objekt verwendet CultureInfo wird, wird durch seine DateTimeFormatInfo.Calendar -Eigenschaft definiert. Dies muss einer der Kalender sein, die im Array gefunden CultureInfo.OptionalCalendars werden.

Der aktuelle Kalender einer Kultur wird in allen Formatierungsvorgängen für diese Kultur verwendet. Beispielsweise ist der Standardkalender der Kultur "Thai Essisch" der Kalender "Thai-Nachzingenzeit", der durch die -Klasse dargestellt ThaiBuddhistCalendar wird. Wenn in CultureInfo einem Datums- und Uhrzeitformatierungsvorgang ein -Objekt verwendet wird, das die Kultur des thailändischen Gilts darstellt, wird standardmäßig der Kalender der thailändischen Epoche verwendet. Der gregorianische Kalender wird nur verwendet, wenn die -Eigenschaft der Kultur DateTimeFormatInfo.Calendar geändert wird, wie im folgenden Beispiel gezeigt:

var thTH = new System.Globalization.CultureInfo("th-TH");
var value = new DateTime(2016, 5, 28);

Console.WriteLine(value.ToString(thTH));

thTH.DateTimeFormat.Calendar = new System.Globalization.GregorianCalendar();
Console.WriteLine(value.ToString(thTH));
// The example displays the following output:
//       28/5/2559 0:00:00
//       28/5/2016 0:00:00
Dim thTH As New CultureInfo("th-TH")
Dim value As New DateTime(2016, 5, 28)

Console.WriteLine(value.ToString(thTH))

thTH.DateTimeFormat.Calendar = New GregorianCalendar()
Console.WriteLine(value.ToString(thTH))
' The example displays the following output:
'       28/5/2559 0:00:00
'       28/5/2016 0:00:00

Der aktuelle Kalender einer Kultur wird auch in allen Analysevorgängen für diese Kultur verwendet, wie im folgenden Beispiel gezeigt.

var thTH = new System.Globalization.CultureInfo("th-TH");
var value = DateTime.Parse("28/05/2559", thTH);
Console.WriteLine(value.ToString(thTH));

thTH.DateTimeFormat.Calendar = new System.Globalization.GregorianCalendar();
Console.WriteLine(value.ToString(thTH));
// The example displays the following output:
//       28/5/2559 0:00:00
//       28/5/2016 0:00:00
Private Sub ThaiBuddhistEraParse()
    Dim thTH As New CultureInfo("th-TH")
    Dim value As DateTime = DateTime.Parse("28/5/2559", thTH)
    Console.WriteLine(value.ToString(thTH))

    thTH.DateTimeFormat.Calendar = New GregorianCalendar()
    Console.WriteLine(value.ToString(thTH))
    ' The example displays the following output:
    '       28/5/2559 0:00:00
    '       28/5/2016 0:00:00
End Sub

Sie instanziieren einen DateTime Wert mithilfe der Datums- und Uhrzeitelemente (Anzahl des Jahres, Monats und Tags) eines bestimmten Kalenders, indem Sie einen DateTime-Konstruktor aufrufen, der einen calendar Parameter enthält, und ihm ein Calendar -Objekt übergeben, das diesen Kalender darstellt. Im folgenden Beispiel werden die Datums- und Uhrzeitelemente aus dem ThaiBuddhistCalendar Kalender verwendet.

var thTH = new System.Globalization.CultureInfo("th-TH");
var dat = new DateTime(2559, 5, 28, thTH.DateTimeFormat.Calendar);
Console.WriteLine($"Thai Buddhist era date: {dat.ToString("d", thTH)}");
Console.WriteLine($"Gregorian date:   {dat:d}");
// The example displays the following output:
//       Thai Buddhist Era Date:  28/5/2559
//       Gregorian Date:     28/05/2016
Dim thTH As New CultureInfo("th-TH")
Dim dat As New DateTime(2559, 5, 28, thTH.DateTimeFormat.Calendar)
Console.WriteLine($"Thai Buddhist Era date: {dat.ToString("d", thTH)}")
Console.WriteLine($"Gregorian date:   {dat:d}")
' The example displays the following output:
'       Thai Buddhist Era Date:  28/5/2559
'       Gregorian Date:     28/05/2016

DateTime -Konstruktoren, die keinen calendar -Parameter enthalten, setzen voraus, dass die Datums- und Uhrzeitelemente als Einheiten im gregorianischen Kalender ausgedrückt werden.

Alle anderen DateTime Eigenschaften und Methoden verwenden den gregorianischen Kalender. Die -Eigenschaft gibt beispielsweise DateTime.Year das Jahr im gregorianischen Kalender zurück, und die DateTime.IsLeapYear(Int32) -Methode geht davon aus, dass der year Parameter ein Jahr im gregorianischen Kalender ist. Jeder DateTime Member, der den gregorianischen Kalender verwendet, verfügt über einen entsprechenden Member der Calendar -Klasse, der einen bestimmten Kalender verwendet. Die -Methode gibt beispielsweise Calendar.GetYear das Jahr in einem bestimmten Kalender zurück, und die Calendar.IsLeapYear -Methode interpretiert den year -Parameter als Jahreszahl in einem bestimmten Kalender. Im folgenden Beispiel werden sowohl die -Klasse als auch DateTime die entsprechenden Member der ThaiBuddhistCalendar -Klasse verwendet.

var thTH = new System.Globalization.CultureInfo("th-TH");
var cal = thTH.DateTimeFormat.Calendar;
var dat = new DateTime(2559, 5, 28, cal);
Console.WriteLine("Using the Thai Buddhist Era calendar:");
Console.WriteLine($"Date: {dat.ToString("d", thTH)}");
Console.WriteLine($"Year: {cal.GetYear(dat)}");
Console.WriteLine($"Leap year: {cal.IsLeapYear(cal.GetYear(dat))}\n");

Console.WriteLine("Using the Gregorian calendar:");
Console.WriteLine($"Date: {dat:d}");
Console.WriteLine($"Year: {dat.Year}");
Console.WriteLine($"Leap year: {DateTime.IsLeapYear(dat.Year)}");
// The example displays the following output:
//       Using the Thai Buddhist Era calendar
//       Date :   28/5/2559
//       Year: 2559
//       Leap year :   True
//
//       Using the Gregorian calendar
//       Date :   28/05/2016
//       Year: 2016
//       Leap year :   True
Dim thTH As New CultureInfo("th-TH")
Dim cal As Calendar = thTH.DateTimeFormat.Calendar
Dim dat As New DateTime(2559, 5, 28, cal)
Console.WriteLine("Using the Thai Buddhist Era calendar:")
Console.WriteLine($"Date: {dat.ToString("d", thTH)}")
Console.WriteLine($"Year: {cal.GetYear(dat)}")
Console.WriteLine($"Leap year: {cal.IsLeapYear(cal.GetYear(dat))}")
Console.WriteLine()

Console.WriteLine("Using the Gregorian calendar:")
Console.WriteLine($"Date: {dat:d}")
Console.WriteLine($"Year: {dat.Year}")
Console.WriteLine($"Leap year: {DateTime.IsLeapYear(dat.Year)}")
' The example displays the following output:
'       Using the Thai Buddhist Era calendar
'       Date :   28/5/2559
'       Year: 2559
'       Leap year :   True
'
'       Using the Gregorian calendar
'       Date :   28/05/2016
'       Year: 2016
'       Leap year :   True

Die DateTime -Struktur enthält eine DayOfWeek -Eigenschaft, die den Wochentag im gregorianischen Kalender zurückgibt. Sie enthält kein Mitglied, mit dem Sie die Wochennummer des Jahres abrufen können. Rufen Sie die -Methode des einzelnen Kalenders auf, um die Woche des Jahres Calendar.GetWeekOfYear abzurufen. Dies wird im folgenden Beispiel veranschaulicht.

var thTH = new System.Globalization.CultureInfo("th-TH");
var thCalendar = thTH.DateTimeFormat.Calendar;
var dat = new DateTime(1395, 8, 18, thCalendar);
Console.WriteLine("Using the Thai Buddhist Era calendar:");
Console.WriteLine($"Date: {dat.ToString("d", thTH)}");
Console.WriteLine($"Day of Week: {thCalendar.GetDayOfWeek(dat)}");
Console.WriteLine($"Week of year: {thCalendar.GetWeekOfYear(dat, System.Globalization.CalendarWeekRule.FirstDay, DayOfWeek.Sunday)}\n");

var greg = new System.Globalization.GregorianCalendar();
Console.WriteLine("Using the Gregorian calendar:");
Console.WriteLine($"Date: {dat:d}");
Console.WriteLine($"Day of Week: {dat.DayOfWeek}");
Console.WriteLine($"Week of year: {greg.GetWeekOfYear(dat, System.Globalization.CalendarWeekRule.FirstDay,DayOfWeek.Sunday)}");
// The example displays the following output:
//       Using the Thai Buddhist Era calendar
//       Date :  18/8/1395
//       Day of Week: Sunday
//       Week of year: 34
//
//       Using the Gregorian calendar
//       Date :  18/08/0852
//       Day of Week: Sunday
//       Week of year: 34
Dim thTH As New CultureInfo("th-TH")
Dim thCalendar As Calendar = thTH.DateTimeFormat.Calendar
Dim dat As New DateTime(1395, 8, 18, thCalendar)
Console.WriteLine("Using the Thai Buddhist Era calendar:")
Console.WriteLine($"Date: {dat.ToString("d", thTH)}")
Console.WriteLine($"Day of Week: {thCalendar.GetDayOfWeek(dat)}")
Console.WriteLine($"Week of year: {thCalendar.GetWeekOfYear(dat, CalendarWeekRule.FirstDay, DayOfWeek.Sunday)}")
Console.WriteLine()

Dim greg As Calendar = New GregorianCalendar()
Console.WriteLine("Using the Gregorian calendar:")
Console.WriteLine($"Date: {dat:d}")
Console.WriteLine($"Day of Week: {dat.DayOfWeek}")
Console.WriteLine($"Week of year: {greg.GetWeekOfYear(dat, CalendarWeekRule.FirstDay, DayOfWeek.Sunday)}")
' The example displays the following output:
'       Using the Thai Buddhist Era calendar
'       Date :  18/8/1395
'       Day of Week: Sunday
'       Week of year: 34
'       
'       Using the Gregorian calendar
'       Date :  18/08/0852
'       Day of Week: Sunday
'       Week of year: 34

Weitere Informationen zu Datumsangaben und Kalendern finden Sie unter Arbeiten mit Kalendern.

Beibehalten von DateTime-Werten

Sie können DateTime Werte auf vier Arten beibehalten:

Sie müssen sicherstellen, dass die Routine, die die Werte wiederherstellt, DateTime keine Daten verliert oder unabhängig von der gewählten Technik eine Ausnahme auslöst. DateTime -Werte sollten einen Roundtrip aufweisen. Das heißt, der ursprüngliche Wert und der wiederhergestellte Wert sollten identisch sein. Und wenn der ursprüngliche DateTime Wert einen einzelnen Zeitpunkt darstellt, sollte er denselben Zeitpunkt identifizieren, zu dem er wiederhergestellt wird.

Beibehalten von Werten als Zeichenfolgen

Um DateTime Werte, die als Zeichenfolgen beibehalten werden, erfolgreich wiederherzustellen, befolgen Sie die folgenden Regeln:

  • Gehen Sie bei der Wiederherstellung der Zeichenfolge von den gleichen Annahmen zur kulturspezifischen Formatierung aus wie bei der persistenten Formatierung. Um sicherzustellen, dass eine Zeichenfolge auf einem System wiederhergestellt werden kann, dessen aktuelle Kultur sich von der Kultur des Systems unterscheidet, in dem sie gespeichert wurde, rufen Sie die ToString -Überladung auf, um die Zeichenfolge mithilfe der Konventionen der invarianten Kultur zu speichern. Rufen Sie die Parse(String, IFormatProvider, DateTimeStyles) - oder TryParse(String, IFormatProvider, DateTimeStyles, DateTime) -Überladung auf, um die Zeichenfolge mithilfe der Konventionen der invarianten Kultur wiederherzustellen. Verwenden Sie niemals die ToString() Parse(String) Überladungen , oder TryParse(String, DateTime) , die die Konventionen der aktuellen Threadkultur verwenden.

  • Wenn das Datum einen einzelnen Zeitpunkt darstellt, stellen Sie sicher, dass es denselben Zeitpunkt darstellt, zu dem es wiederhergestellt wird, auch in einer anderen Zeitzone. Konvertieren Sie den DateTime Wert vor dem Speichern in koordinierte Weltzeit (UTC). Sie können den Wert auch zusammen mit Zeitzoneninformationen serialisieren. Weitere Informationen zu diesem Ansatz finden Sie unter Serialisieren von DateTime- und Zeitzonendaten.

Der häufigste Fehler beim Beibehalten von DateTime Werten als Zeichenfolgen besteht darin, sich auf die Formatierungskonventionen der Standardkultur oder der aktuellen Kultur zu verlassen. Probleme treten auf, wenn sich die aktuelle Kultur beim Speichern und Wiederherstellen der Zeichenfolgen unterscheidet. Im folgenden Beispiel werden diese Probleme veranschaulicht. Es werden fünf Datumsangaben mithilfe der Formatierungskonventionen der aktuellen Kultur gespeichert, in diesem Fall Englisch (USA). Die Datumsangaben werden mithilfe der Formatierungskonventionen einer anderen Kultur wiederhergestellt, in diesem Fall Englisch (Großbritannien). Da die Formatierungskonventionen der beiden Kulturen unterschiedlich sind, können zwei der Datumsangaben nicht wiederhergestellt werden, und die verbleibenden drei Datumsangaben werden falsch interpretiert. Wenn die ursprünglichen Datums- und Uhrzeitwerte einzelne Uhrzeitmomente darstellen, sind die wiederhergestellten Zeiten falsch, da Zeitzoneninformationen verloren gehen.

public static void PersistAsLocalStrings()
{
    SaveLocalDatesAsString();
    RestoreLocalDatesFromString();
}

private static void SaveLocalDatesAsString()
{
    DateTime[] dates = { new DateTime(2014, 6, 14, 6, 32, 0),
                   new DateTime(2014, 7, 10, 23, 49, 0),
                   new DateTime(2015, 1, 10, 1, 16, 0),
                   new DateTime(2014, 12, 20, 21, 45, 0),
                   new DateTime(2014, 6, 2, 15, 14, 0) };
    string output = null;

    Console.WriteLine($"Current Time Zone: {TimeZoneInfo.Local.DisplayName}");
    Console.WriteLine($"The dates on an {Thread.CurrentThread.CurrentCulture.Name} system:");
    for (int ctr = 0; ctr < dates.Length; ctr++)
    {
        Console.WriteLine(dates[ctr].ToString("f"));
        output += dates[ctr].ToString() + (ctr != dates.Length - 1 ? "|" : "");
    }
    var sw = new StreamWriter(filenameTxt);
    sw.Write(output);
    sw.Close();
    Console.WriteLine("Saved dates...");
}

private static void RestoreLocalDatesFromString()
{
    TimeZoneInfo.ClearCachedData();
    Console.WriteLine($"Current Time Zone: {TimeZoneInfo.Local.DisplayName}");
    Thread.CurrentThread.CurrentCulture = CultureInfo.CreateSpecificCulture("en-GB");
    StreamReader sr = new StreamReader(filenameTxt);
    string[] inputValues = sr.ReadToEnd().Split(new char[] { '|' },
                                                StringSplitOptions.RemoveEmptyEntries);
    sr.Close();
    Console.WriteLine("The dates on an {0} system:",
                      Thread.CurrentThread.CurrentCulture.Name);
    foreach (var inputValue in inputValues)
    {
        DateTime dateValue;
        if (DateTime.TryParse(inputValue, out dateValue))
        {
            Console.WriteLine($"'{inputValue}' --> {dateValue:f}");
        }
        else
        {
            Console.WriteLine("Cannot parse '{inputValue}'");
        }
    }
    Console.WriteLine("Restored dates...");
}
// When saved on an en-US system, the example displays the following output:
//       Current Time Zone: (UTC-08:00) Pacific Time (US & Canada)
//       The dates on an en-US system:
//       Saturday, June 14, 2014 6:32 AM
//       Thursday, July 10, 2014 11:49 PM
//       Saturday, January 10, 2015 1:16 AM
//       Saturday, December 20, 2014 9:45 PM
//       Monday, June 02, 2014 3:14 PM
//       Saved dates...
//
// When restored on an en-GB system, the example displays the following output:
//       Current Time Zone: (UTC) Dublin, Edinburgh, Lisbon, London
//       The dates on an en-GB system:
//       Cannot parse //6/14/2014 6:32:00 AM//
//       //7/10/2014 11:49:00 PM// --> 07 October 2014 23:49
//       //1/10/2015 1:16:00 AM// --> 01 October 2015 01:16
//       Cannot parse //12/20/2014 9:45:00 PM//
//       //6/2/2014 3:14:00 PM// --> 06 February 2014 15:14
//       Restored dates...
Public Sub PersistAsLocalStrings()
    SaveDatesAsStrings()
    RestoreDatesAsStrings()
End Sub

Private Sub SaveDatesAsStrings()
    Dim dates As Date() = {#6/14/2014 6:32AM#, #7/10/2014 11:49PM#,
                          #1/10/2015 1:16AM#, #12/20/2014 9:45PM#,
                          #6/2/2014 3:14PM#}
    Dim output As String = Nothing

    Console.WriteLine($"Current Time Zone: {TimeZoneInfo.Local.DisplayName}")
    Console.WriteLine($"The dates on an {Thread.CurrentThread.CurrentCulture.Name} system:")
    For ctr As Integer = 0 To dates.Length - 1
        Console.WriteLine(dates(ctr).ToString("f"))
        output += dates(ctr).ToString() + If(ctr <> dates.Length - 1, "|", "")
    Next
    Dim sw As New StreamWriter(filenameTxt)
    sw.Write(output)
    sw.Close()
    Console.WriteLine("Saved dates...")
End Sub

Private Sub RestoreDatesAsStrings()
    TimeZoneInfo.ClearCachedData()
    Console.WriteLine($"Current Time Zone: {TimeZoneInfo.Local.DisplayName}")
    Thread.CurrentThread.CurrentCulture = CultureInfo.CreateSpecificCulture("en-GB")
    Dim sr As New StreamReader(filenameTxt)
    Dim inputValues As String() = sr.ReadToEnd().Split({"|"c}, StringSplitOptions.RemoveEmptyEntries)
    sr.Close()
    Console.WriteLine($"The dates on an {Thread.CurrentThread.CurrentCulture.Name} system:")
    For Each inputValue In inputValues
        Dim dateValue As Date
        If DateTime.TryParse(inputValue, dateValue) Then
            Console.WriteLine($"'{inputValue}' --> {dateValue:f}")
        Else
            Console.WriteLine($"Cannot parse '{inputValue}'")
        End If
    Next
    Console.WriteLine("Restored dates...")
End Sub
' When saved on an en-US system, the example displays the following output:
'       Current Time Zone: (UTC-08:00) Pacific Time (US & Canada)
'       The dates on an en-US system:
'       Saturday, June 14, 2014 6:32 AM
'       Thursday, July 10, 2014 11:49 PM
'       Saturday, January 10, 2015 1:16 AM
'       Saturday, December 20, 2014 9:45 PM
'       Monday, June 02, 2014 3:14 PM
'       Saved dates...
'
' When restored on an en-GB system, the example displays the following output:
'       Current Time Zone: (UTC) Dublin, Edinburgh, Lisbon, London
'       The dates on an en-GB system:
'       Cannot parse '6/14/2014 6:32:00 AM'
'       '7/10/2014 11:49:00 PM' --> 07 October 2014 23:49
'       '1/10/2015 1:16:00 AM' --> 01 October 2015 01:16
'       Cannot parse '12/20/2014 9:45:00 PM'
'       '6/2/2014 3:14:00 PM' --> 06 February 2014 15:14
'       Restored dates...

Führen Sie die folgenden Schritte aus, um die Werte erfolgreich zu DateTime roundtripen:

  1. Wenn die Werte einzelne Zeitmomente darstellen, konvertieren Sie sie von der Ortszeit in DIE UTC, indem Sie die ToUniversalTime -Methode aufrufen.
  2. Konvertieren Sie die Datumsangaben in ihre Zeichenfolgendarstellungen, indem Sie die ToString(String, IFormatProvider) - oder String.Format(IFormatProvider, String, Object[]) -Überladung aufrufen. Verwenden Sie die Formatierungskonventionen der invarianten Kultur, indem Sie CultureInfo.InvariantCulture als provider Argument angeben. Geben Sie an, dass der Wert mithilfe der Standardformatzeichenfolge "O" oder "R" per Roundtrip ausgeführt werden soll.

Führen Sie die folgenden Schritte aus, um die persistenten DateTime Werte ohne Datenverlust wiederherzustellen:

  1. Analysieren Sie die Daten, indem Sie die ParseExact - oder TryParseExact -Überladung aufrufen. Geben Sie CultureInfo.InvariantCulture als provider Argument an, und verwenden Sie dieselbe Standardformatzeichenfolge, die Sie während der Konvertierung für das Argument verwendet format haben. Schließen Sie den DateTimeStyles.RoundtripKind Wert in das Argument styles ein.
  2. Wenn die DateTime Werte einzelne Zeitmomente darstellen, rufen Sie die ToLocalTime -Methode auf, um das analysierte Datum von UTC in Ortszeit zu konvertieren.

Im folgenden Beispiel werden die invariante Kultur und die Standardformatzeichenfolge "O" verwendet, um sicherzustellen, dass DateTime gespeicherte und wiederhergestellte Werte unabhängig vom System, der Kultur oder der Zeitzone des Quell- und Zielsystems denselben Zeitpunkt darstellen.

public static void PersistAsInvariantStrings()
{
    SaveDatesAsInvariantStrings();
    RestoreDatesAsInvariantStrings();
}

private static void SaveDatesAsInvariantStrings()
{
    DateTime[] dates = { new DateTime(2014, 6, 14, 6, 32, 0),
                   new DateTime(2014, 7, 10, 23, 49, 0),
                   new DateTime(2015, 1, 10, 1, 16, 0),
                   new DateTime(2014, 12, 20, 21, 45, 0),
                   new DateTime(2014, 6, 2, 15, 14, 0) };
    string output = null;

    Console.WriteLine($"Current Time Zone: {TimeZoneInfo.Local.DisplayName}");
    Console.WriteLine($"The dates on an {Thread.CurrentThread.CurrentCulture.Name} system:");
    for (int ctr = 0; ctr < dates.Length; ctr++)
    {
        Console.WriteLine(dates[ctr].ToString("f"));
        output += dates[ctr].ToUniversalTime().ToString("O", CultureInfo.InvariantCulture)
                  + (ctr != dates.Length - 1 ? "|" : "");
    }
    var sw = new StreamWriter(filenameTxt);
    sw.Write(output);
    sw.Close();
    Console.WriteLine("Saved dates...");
}

private static void RestoreDatesAsInvariantStrings()
{
    TimeZoneInfo.ClearCachedData();
    Console.WriteLine("Current Time Zone: {0}",
                      TimeZoneInfo.Local.DisplayName);
    Thread.CurrentThread.CurrentCulture = CultureInfo.CreateSpecificCulture("en-GB");
    StreamReader sr = new StreamReader(filenameTxt);
    string[] inputValues = sr.ReadToEnd().Split(new char[] { '|' },
                                                StringSplitOptions.RemoveEmptyEntries);
    sr.Close();
    Console.WriteLine("The dates on an {0} system:",
                      Thread.CurrentThread.CurrentCulture.Name);
    foreach (var inputValue in inputValues)
    {
        DateTime dateValue;
        if (DateTime.TryParseExact(inputValue, "O", CultureInfo.InvariantCulture,
                              DateTimeStyles.RoundtripKind, out dateValue))
        {
            Console.WriteLine($"'{inputValue}' --> {dateValue.ToLocalTime():f}");
        }
        else
        {
            Console.WriteLine("Cannot parse '{0}'", inputValue);
        }
    }
    Console.WriteLine("Restored dates...");
}
// When saved on an en-US system, the example displays the following output:
//       Current Time Zone: (UTC-08:00) Pacific Time (US & Canada)
//       The dates on an en-US system:
//       Saturday, June 14, 2014 6:32 AM
//       Thursday, July 10, 2014 11:49 PM
//       Saturday, January 10, 2015 1:16 AM
//       Saturday, December 20, 2014 9:45 PM
//       Monday, June 02, 2014 3:14 PM
//       Saved dates...
//
// When restored on an en-GB system, the example displays the following output:
//       Current Time Zone: (UTC) Dublin, Edinburgh, Lisbon, London
//       The dates on an en-GB system:
//       '2014-06-14T13:32:00.0000000Z' --> 14 June 2014 14:32
//       '2014-07-11T06:49:00.0000000Z' --> 11 July 2014 07:49
//       '2015-01-10T09:16:00.0000000Z' --> 10 January 2015 09:16
//       '2014-12-21T05:45:00.0000000Z' --> 21 December 2014 05:45
//       '2014-06-02T22:14:00.0000000Z' --> 02 June 2014 23:14
//       Restored dates...
Public Sub PersistAsInvariantStrings()
    SaveDatesAsInvariantStrings()
    RestoreDatesAsInvariantStrings()
End Sub

Private Sub SaveDatesAsInvariantStrings()
    Dim dates As Date() = {#6/14/2014 6:32AM#, #7/10/2014 11:49PM#,
                          #1/10/2015 1:16AM#, #12/20/2014 9:45PM#,
                          #6/2/2014 3:14PM#}
    Dim output As String = Nothing

    Console.WriteLine($"Current Time Zone: {TimeZoneInfo.Local.DisplayName}")
    Console.WriteLine($"The dates on an {Thread.CurrentThread.CurrentCulture.Name} system:")
    For ctr As Integer = 0 To dates.Length - 1
        Console.WriteLine(dates(ctr).ToString("f"))
        output += dates(ctr).ToUniversalTime().ToString("O", CultureInfo.InvariantCulture) +
                                   If(ctr <> dates.Length - 1, "|", "")
    Next
    Dim sw As New StreamWriter(filenameTxt)
    sw.Write(output)
    sw.Close()
    Console.WriteLine("Saved dates...")
End Sub

Private Sub RestoreDatesAsInvariantStrings()
    TimeZoneInfo.ClearCachedData()
    Console.WriteLine("Current Time Zone: {0}",
                    TimeZoneInfo.Local.DisplayName)
    Thread.CurrentThread.CurrentCulture = CultureInfo.CreateSpecificCulture("en-GB")
    Dim sr As New StreamReader(filenameTxt)
    Dim inputValues As String() = sr.ReadToEnd().Split({"|"c}, StringSplitOptions.RemoveEmptyEntries)
    sr.Close()
    Console.WriteLine($"The dates on an {Thread.CurrentThread.CurrentCulture.Name} system:")
    For Each inputValue In inputValues
        Dim dateValue As Date
        If DateTime.TryParseExact(inputValue, "O", CultureInfo.InvariantCulture,
                          DateTimeStyles.RoundtripKind, dateValue) Then
            Console.WriteLine($"'{inputValue}' --> {dateValue.ToLocalTime():f}")
        Else
            Console.WriteLine($"Cannot parse '{inputValue}'")
        End If
    Next
    Console.WriteLine("Restored dates...")
End Sub
' When saved on an en-US system, the example displays the following output:
'       Current Time Zone: (UTC-08:00) Pacific Time (US & Canada)
'       The dates on an en-US system:
'       Saturday, June 14, 2014 6:32 AM
'       Thursday, July 10, 2014 11:49 PM
'       Saturday, January 10, 2015 1:16 AM
'       Saturday, December 20, 2014 9:45 PM
'       Monday, June 02, 2014 3:14 PM
'       Saved dates...
'
' When restored on an en-GB system, the example displays the following output:
'       Current Time Zone: (UTC) Dublin, Edinburgh, Lisbon, London
'       The dates on an en-GB system:
'       '2014-06-14T13:32:00.0000000Z' --> 14 June 2014 14:32
'       '2014-07-11T06:49:00.0000000Z' --> 11 July 2014 07:49
'       '2015-01-10T09:16:00.0000000Z' --> 10 January 2015 09:16
'       '2014-12-21T05:45:00.0000000Z' --> 21 December 2014 05:45
'       '2014-06-02T22:14:00.0000000Z' --> 02 June 2014 23:14
'       Restored dates...
Beibehalten von Werten als ganze Zahlen

Sie können ein Datum und eine Uhrzeit als Int64 Wert beibehalten, der eine Anzahl von Ticks darstellt. In diesem Fall müssen Sie nicht die Kultur der Systeme berücksichtigen, auf denen die DateTime Werte beibehalten und wiederhergestellt werden.

So speichern Sie einen DateTime Wert als ganze Zahl

  • Wenn die DateTime Werte einzelne Zeitmomente darstellen, konvertieren Sie sie in UTC, indem Sie die ToUniversalTime -Methode aufrufen.
  • Rufen Sie die Anzahl der Ticks ab, die durch den Wert aus der -Eigenschaft dargestellt DateTime Ticks werden.

So stellen Sie einen Wert wieder her, der DateTime als ganze Zahl beibehalten wurde:

  1. Instanziieren Sie ein neues DateTime -Objekt, indem Sie den Int64 Wert an den DateTime(Int64) Konstruktor übergeben.
  2. Wenn der DateTime Wert einen einzelnen Zeitpunkt darstellt, konvertieren Sie ihn von UTC in die Ortszeit, indem Sie die ToLocalTime -Methode aufrufen.

Im folgenden Beispiel wird ein Array von DateTime Werten als ganze Zahlen auf einem System in der Zeitzone "USA Pacific Time" beibehalten. Sie wird auf einem System in der UTC-Zone wiederhergestellt. Die Datei, die die ganzen Zahlen enthält, enthält einen Int32 Wert, der die Gesamtzahl der Werte angibt, Int64 die unmittelbar darauf folgen.

public static void PersistAsIntegers()
{
    SaveDatesAsInts();
    RestoreDatesAsInts();
}

private static void SaveDatesAsInts()
{
    DateTime[] dates = { new DateTime(2014, 6, 14, 6, 32, 0),
                   new DateTime(2014, 7, 10, 23, 49, 0),
                   new DateTime(2015, 1, 10, 1, 16, 0),
                   new DateTime(2014, 12, 20, 21, 45, 0),
                   new DateTime(2014, 6, 2, 15, 14, 0) };

    Console.WriteLine($"Current Time Zone: {TimeZoneInfo.Local.DisplayName}");
    Console.WriteLine($"The dates on an {Thread.CurrentThread.CurrentCulture.Name} system:");
    var ticks = new long[dates.Length];
    for (int ctr = 0; ctr < dates.Length; ctr++)
    {
        Console.WriteLine(dates[ctr].ToString("f"));
        ticks[ctr] = dates[ctr].ToUniversalTime().Ticks;
    }
    var fs = new FileStream(filenameInts, FileMode.Create);
    var bw = new BinaryWriter(fs);
    bw.Write(ticks.Length);
    foreach (var tick in ticks)
        bw.Write(tick);

    bw.Close();
    Console.WriteLine("Saved dates...");
}

private static void RestoreDatesAsInts()
{
    TimeZoneInfo.ClearCachedData();
    Console.WriteLine($"Current Time Zone: {TimeZoneInfo.Local.DisplayName}");
    Thread.CurrentThread.CurrentCulture = CultureInfo.CreateSpecificCulture("en-GB");
    FileStream fs = new FileStream(filenameInts, FileMode.Open);
    BinaryReader br = new BinaryReader(fs);
    int items;
    DateTime[] dates;

    try
    {
        items = br.ReadInt32();
        dates = new DateTime[items];

        for (int ctr = 0; ctr < items; ctr++)
        {
            long ticks = br.ReadInt64();
            dates[ctr] = new DateTime(ticks).ToLocalTime();
        }
    }
    catch (EndOfStreamException)
    {
        Console.WriteLine("File corruption detected. Unable to restore data...");
        return;
    }
    catch (IOException)
    {
        Console.WriteLine("Unspecified I/O error. Unable to restore data...");
        return;
    }
    // Thrown during array initialization.
    catch (OutOfMemoryException)
    {
        Console.WriteLine("File corruption detected. Unable to restore data...");
        return;
    }
    finally
    {
        br.Close();
    }

    Console.WriteLine($"The dates on an {Thread.CurrentThread.CurrentCulture.Name} system:");
    foreach (var value in dates)
        Console.WriteLine(value.ToString("f"));

    Console.WriteLine("Restored dates...");
}
// When saved on an en-US system, the example displays the following output:
//       Current Time Zone: (UTC-08:00) Pacific Time (US & Canada)
//       The dates on an en-US system:
//       Saturday, June 14, 2014 6:32 AM
//       Thursday, July 10, 2014 11:49 PM
//       Saturday, January 10, 2015 1:16 AM
//       Saturday, December 20, 2014 9:45 PM
//       Monday, June 02, 2014 3:14 PM
//       Saved dates...
//
// When restored on an en-GB system, the example displays the following output:
//       Current Time Zone: (UTC) Dublin, Edinburgh, Lisbon, London
//       The dates on an en-GB system:
//       14 June 2014 14:32
//       11 July 2014 07:49
//       10 January 2015 09:16
//       21 December 2014 05:45
//       02 June 2014 23:14
//       Restored dates...
Public Sub PersistAsIntegers()
    SaveDatesAsIntegers()
    RestoreDatesAsIntegers()
End Sub

Private Sub SaveDatesAsIntegers()
    Dim dates As Date() = {#6/14/2014 6:32AM#, #7/10/2014 11:49PM#,
                          #1/10/2015 1:16AM#, #12/20/2014 9:45PM#,
                          #6/2/2014 3:14PM#}

    Console.WriteLine($"Current Time Zone: {TimeZoneInfo.Local.DisplayName}")
    Console.WriteLine($"The dates on an {Thread.CurrentThread.CurrentCulture.Name} system:")
    Dim ticks(dates.Length - 1) As Long
    For ctr As Integer = 0 To dates.Length - 1
        Console.WriteLine(dates(ctr).ToString("f"))
        ticks(ctr) = dates(ctr).ToUniversalTime().Ticks
    Next
    Dim fs As New FileStream(filenameInts, FileMode.Create)
    Dim bw As New BinaryWriter(fs)
    bw.Write(ticks.Length)
    For Each tick In ticks
        bw.Write(tick)
    Next
    bw.Close()
    Console.WriteLine("Saved dates...")
End Sub

Private Sub RestoreDatesAsIntegers()
    TimeZoneInfo.ClearCachedData()
    Console.WriteLine($"Current Time Zone: {TimeZoneInfo.Local.DisplayName}")
    Thread.CurrentThread.CurrentCulture = CultureInfo.CreateSpecificCulture("en-GB")
    Dim fs As New FileStream(filenameInts, FileMode.Open)
    Dim br As New BinaryReader(fs)
    Dim items As Integer
    Dim dates As DateTime()

    Try
        items = br.ReadInt32()
        ReDim dates(items - 1)

        For ctr As Integer = 0 To items - 1
            Dim ticks As Long = br.ReadInt64()
            dates(ctr) = New DateTime(ticks).ToLocalTime()
        Next
    Catch e As EndOfStreamException
        Console.WriteLine("File corruption detected. Unable to restore data...")
        Exit Sub
    Catch e As IOException
        Console.WriteLine("Unspecified I/O error. Unable to restore data...")
        Exit Sub
    Catch e As OutOfMemoryException     'Thrown in array initialization.
        Console.WriteLine("File corruption detected. Unable to restore data...")
        Exit Sub
    Finally
        br.Close()
    End Try

    Console.WriteLine($"The dates on an {Thread.CurrentThread.CurrentCulture.Name} system:")
    For Each value In dates
        Console.WriteLine(value.ToString("f"))
    Next
    Console.WriteLine("Restored dates...")
End Sub
' When saved on an en-US system, the example displays the following output:
'       Current Time Zone: (UTC-08:00) Pacific Time (US & Canada)
'       The dates on an en-US system:
'       Saturday, June 14, 2014 6:32 AM
'       Thursday, July 10, 2014 11:49 PM
'       Saturday, January 10, 2015 1:16 AM
'       Saturday, December 20, 2014 9:45 PM
'       Monday, June 02, 2014 3:14 PM
'       Saved dates...
'
' When restored on an en-GB system, the example displays the following output:
'       Current Time Zone: (UTC) Dublin, Edinburgh, Lisbon, London
'       The dates on an en-GB system:
'       14 June 2014 14:32
'       11 July 2014 07:49
'       10 January 2015 09:16
'       21 December 2014 05:45
'       02 June 2014 23:14
'       Restored dates...

Serialisieren von DateTime-Werten

Sie können DateTime Werte durch Serialisierung in einem Stream oder einer Datei beibehalten und dann durch Deserialisierung wiederherstellen. DateTime -Daten werden in einem angegebenen Objektformat serialisiert. Die Objekte werden wiederhergestellt, wenn sie deserialisiert werden. Ein Formatierungsprogramm oder Serialisierungsprogramm, z. XmlSerializer B. oder BinaryFormatter , verarbeitet den Serialisierungs- und Deserialisierungsprozess. Weitere Informationen zur Serialisierung und zu den vom .NET Framework unterstützten Serialisierungstypen finden Sie unter Serialisierung.

Im folgenden Beispiel wird die XmlSerializer -Klasse verwendet, um Werte zu serialisieren und zu deserialisieren. DateTime Die Werte stellen alle Schaltjahrtage im 21. Jahrhundert dar. Die Ausgabe stellt das Ergebnis dar, wenn das Beispiel auf einem System ausgeführt wird, dessen aktuelle Kultur Englisch (Großbritannien) ist. Da Sie das Objekt selbst deserialisiert DateTime haben, muss der Code keine kulturellen Unterschiede in Datums- und Uhrzeitformaten behandeln.

public static void PersistAsXML()
{
    // Serialize the data.
    var leapYears = new List<DateTime>();
    for (int year = 2000; year <= 2100; year += 4)
    {
        if (DateTime.IsLeapYear(year))
            leapYears.Add(new DateTime(year, 2, 29));
    }
    DateTime[] dateArray = leapYears.ToArray();

    var serializer = new XmlSerializer(dateArray.GetType());
    TextWriter sw = new StreamWriter(filenameXml);

    try
    {
        serializer.Serialize(sw, dateArray);
    }
    catch (InvalidOperationException e)
    {
        Console.WriteLine(e.InnerException.Message);
    }
    finally
    {
        if (sw != null) sw.Close();
    }

    // Deserialize the data.
    DateTime[] deserializedDates;
    using (var fs = new FileStream(filenameXml, FileMode.Open))
    {
        deserializedDates = (DateTime[])serializer.Deserialize(fs);
    }

    // Display the dates.
    Console.WriteLine($"Leap year days from 2000-2100 on an {Thread.CurrentThread.CurrentCulture.Name} system:");
    int nItems = 0;
    foreach (var dat in deserializedDates)
    {
        Console.Write($"   {dat:d}     ");
        nItems++;
        if (nItems % 5 == 0)
            Console.WriteLine();
    }
}
// The example displays the following output:
//    Leap year days from 2000-2100 on an en-GB system:
//       29/02/2000       29/02/2004       29/02/2008       29/02/2012       29/02/2016
//       29/02/2020       29/02/2024       29/02/2028       29/02/2032       29/02/2036
//       29/02/2040       29/02/2044       29/02/2048       29/02/2052       29/02/2056
//       29/02/2060       29/02/2064       29/02/2068       29/02/2072       29/02/2076
//       29/02/2080       29/02/2084       29/02/2088       29/02/2092       29/02/2096
Public Sub PersistAsXml()
    ' Serialize the data.
    Dim leapYears As New List(Of DateTime)()
    For year As Integer = 2000 To 2100 Step 4
        If Date.IsLeapYear(year) Then
            leapYears.Add(New Date(year, 2, 29))
        End If
    Next
    Dim dateArray As DateTime() = leapYears.ToArray()

    Dim serializer As New XmlSerializer(dateArray.GetType())
    Dim sw As TextWriter = New StreamWriter(filenameXml)

    Try
        serializer.Serialize(sw, dateArray)
    Catch e As InvalidOperationException
        Console.WriteLine(e.InnerException.Message)
    Finally
        If sw IsNot Nothing Then sw.Close()
    End Try

    ' Deserialize the data.
    Dim deserializedDates As Date()
    Using fs As New FileStream(filenameXml, FileMode.Open)
        deserializedDates = CType(serializer.Deserialize(fs), Date())
    End Using

    ' Display the dates.
    Console.WriteLine($"Leap year days from 2000-2100 on an {Thread.CurrentThread.CurrentCulture.Name} system:")
    Dim nItems As Integer
    For Each dat In deserializedDates
        Console.Write($"   {dat:d}     ")
        nItems += 1
        If nItems Mod 5 = 0 Then Console.WriteLine()
    Next
End Sub
' The example displays the following output:
'    Leap year days from 2000-2100 on an en-GB system:
'       29/02/2000       29/02/2004       29/02/2008       29/02/2012       29/02/2016
'       29/02/2020       29/02/2024       29/02/2028       29/02/2032       29/02/2036
'       29/02/2040       29/02/2044       29/02/2048       29/02/2052       29/02/2056
'       29/02/2060       29/02/2064       29/02/2068       29/02/2072       29/02/2076
'       29/02/2080       29/02/2084       29/02/2088       29/02/2092       29/02/2096

Im vorherigen Beispiel sind keine Zeitinformationen enthalten. Wenn ein DateTime Wert einen Zeitpunkt darstellt und als Ortszeit ausgedrückt wird, konvertieren Sie ihn von ortszeit in UTC, bevor Sie ihn serialisieren, indem Sie die ToUniversalTime -Methode aufrufen. Nachdem Sie sie deserialisiert haben, konvertieren Sie sie von UTC in Ortszeit, indem Sie die ToLocalTime -Methode aufrufen. Im folgenden Beispiel wird die BinaryFormatter -Klasse verwendet, um DateTime Daten auf einem System in der Zeitzone "U.S. Pacific Standard Time" zu serialisieren und auf einem System in der Zone "US Central Standard" zu deserialisieren.

public static void PersistBinary()
{
    SaveDatesBinary();
    RestoreDatesBinary();
}

private static void SaveDatesBinary()
{
    DateTime[] dates = { new DateTime(2014, 6, 14, 6, 32, 0),
                   new DateTime(2014, 7, 10, 23, 49, 0),
                   new DateTime(2015, 1, 10, 1, 16, 0),
                   new DateTime(2014, 12, 20, 21, 45, 0),
                   new DateTime(2014, 6, 2, 15, 14, 0) };
    var fs = new FileStream(filenameBin, FileMode.Create);
    var bin = new BinaryFormatter();

    Console.WriteLine($"Current Time Zone: {TimeZoneInfo.Local.DisplayName}");
    Console.WriteLine($"The dates on an {Thread.CurrentThread.CurrentCulture.Name} system:");
    for (int ctr = 0; ctr < dates.Length; ctr++)
    {
        Console.WriteLine(dates[ctr].ToString("f"));
        dates[ctr] = dates[ctr].ToUniversalTime();
    }
    bin.Serialize(fs, dates);
    fs.Close();
    Console.WriteLine("Saved dates...");
}

private static void RestoreDatesBinary()
{
    TimeZoneInfo.ClearCachedData();
    Console.WriteLine($"Current Time Zone: {TimeZoneInfo.Local.DisplayName}");
    Thread.CurrentThread.CurrentCulture = CultureInfo.CreateSpecificCulture("en-GB");

    FileStream fs = new FileStream(filenameBin, FileMode.Open);
    BinaryFormatter bin = new BinaryFormatter();
    var dates = (DateTime[])bin.Deserialize(fs);
    fs.Close();

    Console.WriteLine($"The dates on an {Thread.CurrentThread.CurrentCulture.Name} system:");
    foreach (var value in dates)
        Console.WriteLine(value.ToLocalTime().ToString("f"));

    Console.WriteLine("Restored dates...");
}
// When saved on an en-US system, the example displays the following output:
//       Current Time Zone: (UTC-08:00) Pacific Time (US & Canada)
//       The dates on an en-US system:
//       Saturday, June 14, 2014 6:32 AM
//       Thursday, July 10, 2014 11:49 PM
//       Saturday, January 10, 2015 1:16 AM
//       Saturday, December 20, 2014 9:45 PM
//       Monday, June 02, 2014 3:14 PM
//       Saved dates...
//
// When restored on an en-GB system, the example displays the following output:
//       Current Time Zone: (UTC-6:00) Central Time (US & Canada)
//       The dates on an en-GB system:
//       14 June 2014 08:32
//       11 July 2014 01:49
//       10 January 2015 03:16
//       20 December 2014 23:45
//       02 June 2014 17:14
//       Restored dates...
Public Sub PersistBinary()
    SaveDatesBinary()
    RestoreDatesBinary()
End Sub

Private Sub SaveDatesBinary()
    Dim dates As Date() = {#6/14/2014 6:32AM#, #7/10/2014 11:49PM#,
                          #1/10/2015 1:16AM#, #12/20/2014 9:45PM#,
                          #6/2/2014 3:14PM#}
    Dim fs As New FileStream(filenameBin, FileMode.Create)
    Dim bin As New BinaryFormatter()

    Console.WriteLine($"Current Time Zone: {TimeZoneInfo.Local.DisplayName}")
    Console.WriteLine("The dates on an {Thread.CurrentThread.CurrentCulture.Name} system:")
    For ctr As Integer = 0 To dates.Length - 1
        Console.WriteLine(dates(ctr).ToString("f"))
        dates(ctr) = dates(ctr).ToUniversalTime()
    Next
    bin.Serialize(fs, dates)
    fs.Close()
    Console.WriteLine("Saved dates...")
End Sub

Private Sub RestoreDatesBinary()
    TimeZoneInfo.ClearCachedData()
    Console.WriteLine("Current Time Zone: {TimeZoneInfo.Local.DisplayName}")
    Thread.CurrentThread.CurrentCulture = CultureInfo.CreateSpecificCulture("en-GB")

    Dim fs As New FileStream(filenameBin, FileMode.Open)
    Dim bin As New BinaryFormatter()
    Dim dates As DateTime() = DirectCast(bin.Deserialize(fs), Date())
    fs.Close()

    Console.WriteLine("The dates on an {Thread.CurrentThread.CurrentCulture.Name} system:")
    For Each value In dates
        Console.WriteLine(value.ToLocalTime().ToString("f"))
    Next
    Console.WriteLine("Restored dates...")
End Sub
' When saved on an en-US system, the example displays the following output:
'       Current Time Zone: (UTC-08:00) Pacific Time (US & Canada)
'       The dates on an en-US system:
'       Saturday, June 14, 2014 6:32 AM
'       Thursday, July 10, 2014 11:49 PM
'       Saturday, January 10, 2015 1:16 AM
'       Saturday, December 20, 2014 9:45 PM
'       Monday, June 02, 2014 3:14 PM
'       Saved dates...
'
' When restored on an en-GB system, the example displays the following output:
'       Current Time Zone: (UTC-6:00) Central Time (US & Canada)
'       The dates on an en-GB system:
'       14 June 2014 08:32
'       11 July 2014 01:49
'       10 January 2015 03:16
'       20 December 2014 11:45
'       02 June 2014 17:14
'       Restored dates...

Serialisieren von DateTime- und Zeitzonendaten

In den vorherigen Beispielen wurde davon ausgegangen, dass DateTime Werte als lokale Zeiten ausgedrückt werden. Der Code konvertierte die Werte zwischen UTC und Ortszeit, sodass sie denselben Zeitpunkt auf dem Quell- und Zielsystem widerspiegeln. DateTime -Werte können auch Zeitmomente in einer anderen Zeitzone als "local" und "UTC" widerspiegeln. Da die DateTime Struktur keine Zeitzonen erkennt, müssen Sie sowohl den Wert als auch das Objekt serialisieren, DateTime das seine Zeitzone TimeZoneInfo darstellt. Erstellen Sie einen Typ, dessen Felder sowohl den Wert als auch DateTime seine Zeitzone enthalten. Im folgenden Beispiel wird eine DateWithTimeZone -Struktur definiert.

using System;

namespace DateTimeExtensions
{
    [Serializable]
    public struct DateWithTimeZone
    {
        private TimeZoneInfo tz;
        private DateTime dt;

        public DateWithTimeZone(DateTime dateValue, TimeZoneInfo timeZone)
        {
            dt = dateValue;
            tz = timeZone ?? TimeZoneInfo.Local;
        }

        public TimeZoneInfo TimeZone
        {
            get { return (tz); }
            set { tz = value; }
        }

        public DateTime DateTime
        {
            get { return (dt); }
            set { dt = value; }
        }
    }
}
Namespace DateTimeExtensions
    <Serializable> Public Structure DateWithTimeZone
        Private tz As TimeZoneInfo
        Private dt As DateTime

        Public Sub New(dateValue As DateTime, timeZone As TimeZoneInfo)
            dt = dateValue
            tz = If(timeZone, TimeZoneInfo.Local)
        End Sub

        Public Property TimeZone As TimeZoneInfo
            Get
                Return tz
            End Get
            Set
                tz = Value
            End Set
        End Property

        Public Property DateTime As Date
            Get
                Return dt
            End Get
            Set
                dt = Value
            End Set
        End Property
    End Structure
End Namespace

Wichtig

Die DateWithTimeZone -Struktur wird in den nächsten beiden Beispielen verwendet, die ein Array von -Objekten serialisieren und deserialisieren. DateWithTimeZone Sie können die Quelle für den gesamten Satz von Beispielen aus diesem Artikel entweder in Visual Basic oder C# im Docs-Repository auf GitHub anzeigen.

Mithilfe der DateWithTimeZone -Struktur können Sie dann Datum und Uhrzeit zusammen mit Zeitzoneninformationen beibehalten. Im folgenden Beispiel wird die BinaryFormatter -Klasse verwendet, um ein Array von -Objekten zu DateWithTimeZone serialisieren.

public static void SaveDateWithTimeZone()
{
    DateWithTimeZone[] dates = { new DateWithTimeZone(new DateTime(2014, 8, 9, 19, 30, 0),
                              TimeZoneInfo.FindSystemTimeZoneById("Eastern Standard Time")),
                          new DateWithTimeZone(new DateTime(2014, 8, 15, 19, 0, 0),
                              TimeZoneInfo.FindSystemTimeZoneById("Pacific Standard Time")),
                          new DateWithTimeZone(new DateTime(2014, 8, 22, 19, 30, 0),
                              TimeZoneInfo.FindSystemTimeZoneById("Eastern Standard Time")),
                          new DateWithTimeZone(new DateTime(2014, 8, 28, 19, 0, 0),
                              TimeZoneInfo.FindSystemTimeZoneById("Eastern Standard Time")) };
    var fs = new FileStream(@".\Schedule.bin", FileMode.Create);
    var formatter = new BinaryFormatter();
    try
    {
        formatter.Serialize(fs, dates);
        // Display dates.
        foreach (var date in dates)
        {
            TimeZoneInfo tz = date.TimeZone;
            Console.WriteLine($"{date.DateTime} {(tz.IsDaylightSavingTime(date.DateTime) ? tz.DaylightName : tz.StandardName)}");
        }
    }
    catch (SerializationException e)
    {
        Console.WriteLine($"Serialization failed. Reason: {e.Message}");
    }
    finally
    {
        if (fs != null) fs.Close();
    }
}
// The example displays the following output:
//       8/9/2014 7:30:00 PM Eastern Daylight Time
//       8/15/2014 7:00:00 PM Pacific Daylight Time
//       8/22/2014 7:30:00 PM Eastern Daylight Time
//       8/28/2014 7:00:00 PM Eastern Daylight Time
Public Sub SaveDateWithTimeZone()
    Dim dates As DateWithTimeZone() = {New DateWithTimeZone(#8/9/2014 7:30PM#,
                                      TimeZoneInfo.FindSystemTimeZoneById("Eastern Standard Time")),
                                  New DateWithTimeZone(#8/15/2014 7:00PM#,
                                      TimeZoneInfo.FindSystemTimeZoneById("Pacific Standard Time")),
                                  New DateWithTimeZone(#8/22/2014 7:30PM#,
                                      TimeZoneInfo.FindSystemTimeZoneById("Eastern Standard Time")),
                                  New DateWithTimeZone(#8/28/2014 7:00PM#,
                                      TimeZoneInfo.FindSystemTimeZoneById("Eastern Standard Time"))}
    Dim fs As New FileStream(".\Schedule.bin", FileMode.Create)
    Dim formatter As New BinaryFormatter()
    Try
        formatter.Serialize(fs, dates)
    Catch e As SerializationException
        Console.WriteLine($"Serialization failed. Reason: {e.Message}")
    Finally
        If fs IsNot Nothing Then fs.Close()
    End Try
    ' Display dates.
    For Each dateInfo In dates
        Dim tz As TimeZoneInfo = dateInfo.TimeZone
        Console.WriteLine($"{dateInfo.DateTime} {If(tz.IsDaylightSavingTime(dateInfo.DateTime), tz.DaylightName, tz.StandardName)}")
    Next
End Sub
' The example displays the following output:
'       8/9/2014 7:30:00 PM Eastern Daylight Time
'       8/15/2014 7:00:00 PM Pacific Daylight Time
'       8/22/2014 7:30:00 PM Eastern Daylight Time
'       8/28/2014 7:00:00 PM Eastern Daylight Time

Das folgende Beispiel ruft dann die BinaryFormatter.Deserialize -Methode auf, um sie zu deserialisieren.

public static void RestoreDateWithTimeZone()
{
    const string filename = @".\Schedule.bin";
    FileStream fs;
    if (File.Exists(filename))
    {
        fs = new FileStream(filename, FileMode.Open);
    }
    else
    {
        Console.WriteLine("Unable to find file to deserialize.");
        return;
    }

    var formatter = new BinaryFormatter();
    DateWithTimeZone[] dates;
    try
    {
        dates = (DateWithTimeZone[])formatter.Deserialize(fs);
        // Display dates.
        foreach (var date in dates)
        {
            TimeZoneInfo tz = date.TimeZone;
            Console.WriteLine($"{ date.DateTime} {(tz.IsDaylightSavingTime(date.DateTime) ? tz.DaylightName : tz.StandardName)}");
        }
    }
    catch (SerializationException e)
    {
        Console.WriteLine($"Deserialization failed. Reason: {e.Message}");
    }
    finally
    {
        if (fs != null) fs.Close();
    }
}
// The example displays the following output:
//       8/9/2014 7:30:00 PM Eastern Daylight Time
//       8/15/2014 7:00:00 PM Pacific Daylight Time
//       8/22/2014 7:30:00 PM Eastern Daylight Time
//       8/28/2014 7:00:00 PM Eastern Daylight Time
Public Sub RestoreDateWithTimeZone()
    Dim fs As FileStream
    If File.Exists(filename) Then
        fs = New FileStream(filename, FileMode.Open)
    Else
        Console.WriteLine("Unable to find file to deserialize.")
        Exit Sub
    End If

    Dim formatter As New BinaryFormatter()
    Dim dates As DateWithTimeZone ()= Nothing
    Try
        dates = DirectCast(formatter.Deserialize(fs), DateWithTimeZone())
        ' Display dates.
        For Each dateInfo In dates
            Dim tz As TimeZoneInfo = dateInfo.TimeZone
            Console.WriteLine($"{dateInfo.DateTime} {If(tz.IsDaylightSavingTime(dateInfo.DateTime), tz.DaylightName, tz.StandardName)}")
        Next
    Catch e As SerializationException
        Console.WriteLine("Deserialization failed. Reason: {e.Message}")
    Finally
        If fs IsNot Nothing Then fs.Close()
    End Try
End Sub
' The example displays the following output:
'       8/9/2014 7:30:00 PM Eastern Daylight Time
'       8/15/2014 7:00:00 PM Pacific Daylight Time
'       8/22/2014 7:30:00 PM Eastern Daylight Time
'       8/28/2014 7:00:00 PM Eastern Daylight Time

DateTime im Vergleich zu TimeSpan

Die DateTime TimeSpan Werttypen und unterscheiden sich darin, dass ein DateTime einen Zeitpunkt darstellt, während ein TimeSpan ein Zeitintervall darstellt. Sie können eine Instanz von von einer anderen subtrahieren, DateTime um ein TimeSpan -Objekt abzurufen, das das Zeitintervall zwischen ihnen darstellt. Alternativ können Sie dem aktuellen ein positives TimeSpan DateTime hinzufügen, um einen Wert zu erhalten, der ein DateTime zukünftiges Datum darstellt.

Sie können ein Zeitintervall zu einem -Objekt hinzufügen oder von diesem subtrahieren. DateTime Zeitintervalle können negativ oder positiv sein und in Einheiten wie Ticks, Sekunden oder als -Objekt ausgedrückt TimeSpan werden.

Vergleichen auf Gleichheit innerhalb der Toleranz

Gleichheitsvergleiche für DateTime Werte sind genau. Das bedeutet, dass zwei Werte als die gleiche Anzahl von Ticks ausgedrückt werden müssen, um als gleich betrachtet zu werden. Diese Genauigkeit ist für viele Anwendungen häufig unnötig oder sogar falsch. Häufig möchten Sie testen, ob DateTime Objekte ungefähr gleich sind.

Im folgenden Beispiel wird veranschaulicht, wie ungefähr äquivalente Werte verglichen DateTime werden. Sie akzeptiert einen kleinen Unterschiedsrand, wenn sie als gleich deklariert werden.

public static bool RoughlyEquals(DateTime time, DateTime timeWithWindow, int windowInSeconds, int frequencyInSeconds)
{
    long delta = (long)((TimeSpan)(timeWithWindow - time)).TotalSeconds % frequencyInSeconds;
    delta = delta > windowInSeconds ? frequencyInSeconds - delta : delta;
    return Math.Abs(delta) < windowInSeconds;
}

public static void TestRoughlyEquals()
{
    int window = 10;
    int freq = 60 * 60 * 2; // 2 hours;

    DateTime d1 = DateTime.Now;

    DateTime d2 = d1.AddSeconds(2 * window);
    DateTime d3 = d1.AddSeconds(-2 * window);
    DateTime d4 = d1.AddSeconds(window / 2);
    DateTime d5 = d1.AddSeconds(-window / 2);

    DateTime d6 = (d1.AddHours(2)).AddSeconds(2 * window);
    DateTime d7 = (d1.AddHours(2)).AddSeconds(-2 * window);
    DateTime d8 = (d1.AddHours(2)).AddSeconds(window / 2);
    DateTime d9 = (d1.AddHours(2)).AddSeconds(-window / 2);

    Console.WriteLine($"d1 ({d1}) ~= d1 ({d1}): {RoughlyEquals(d1, d1, window, freq)}");
    Console.WriteLine($"d1 ({d1}) ~= d2 ({d2}): {RoughlyEquals(d1, d2, window, freq)}");
    Console.WriteLine($"d1 ({d1}) ~= d3 ({d3}): {RoughlyEquals(d1, d3, window, freq)}");
    Console.WriteLine($"d1 ({d1}) ~= d4 ({d4}): {RoughlyEquals(d1, d4, window, freq)}");
    Console.WriteLine($"d1 ({d1}) ~= d5 ({d5}): {RoughlyEquals(d1, d5, window, freq)}");

    Console.WriteLine($"d1 ({d1}) ~= d6 ({d6}): {RoughlyEquals(d1, d6, window, freq)}");
    Console.WriteLine($"d1 ({d1}) ~= d7 ({d7}): {RoughlyEquals(d1, d7, window, freq)}");
    Console.WriteLine($"d1 ({d1}) ~= d8 ({d8}): {RoughlyEquals(d1, d8, window, freq)}");
    Console.WriteLine($"d1 ({d1}) ~= d9 ({d9}): {RoughlyEquals(d1, d9, window, freq)}");
}
// The example displays output similar to the following:
//    d1 (1/28/2010 9:01:26 PM) ~= d1 (1/28/2010 9:01:26 PM): True
//    d1 (1/28/2010 9:01:26 PM) ~= d2 (1/28/2010 9:01:46 PM): False
//    d1 (1/28/2010 9:01:26 PM) ~= d3 (1/28/2010 9:01:06 PM): False
//    d1 (1/28/2010 9:01:26 PM) ~= d4 (1/28/2010 9:01:31 PM): True
//    d1 (1/28/2010 9:01:26 PM) ~= d5 (1/28/2010 9:01:21 PM): True
//    d1 (1/28/2010 9:01:26 PM) ~= d6 (1/28/2010 11:01:46 PM): False
//    d1 (1/28/2010 9:01:26 PM) ~= d7 (1/28/2010 11:01:06 PM): False
//    d1 (1/28/2010 9:01:26 PM) ~= d8 (1/28/2010 11:01:31 PM): True
//    d1 (1/28/2010 9:01:26 PM) ~= d9 (1/28/2010 11:01:21 PM): True
Public Shared Function RoughlyEquals(time As DateTime, timeWithWindow As DateTime,
                             windowInSeconds As Integer,
                             frequencyInSeconds As Integer) As Boolean
    Dim delta As Long = (timeWithWindow.Subtract(time)).TotalSeconds _
                                            Mod frequencyInSeconds

    If delta > windowInSeconds Then
        delta = frequencyInSeconds - delta
    End If

    Return Math.Abs(delta) < windowInSeconds
End Function

Public Shared Sub TestRoughlyEquals()
    Dim window As Integer = 10
    Dim freq As Integer = 60 * 60 * 2 ' 2 hours;
    Dim d1 As DateTime = DateTime.Now

    Dim d2 As DateTime = d1.AddSeconds(2 * window)
    Dim d3 As DateTime = d1.AddSeconds(-2 * window)
    Dim d4 As DateTime = d1.AddSeconds(window / 2)
    Dim d5 As DateTime = d1.AddSeconds(-window / 2)

    Dim d6 As DateTime = d1.AddHours(2).AddSeconds(2 * window)
    Dim d7 As DateTime = d1.AddHours(2).AddSeconds(-2 * window)
    Dim d8 As DateTime = d1.AddHours(2).AddSeconds(window / 2)
    Dim d9 As DateTime = d1.AddHours(2).AddSeconds(-window / 2)

    Console.WriteLine($"d1 ({d1}) ~= d1 ({d1}): {RoughlyEquals(d1, d1, window, freq)}")
    Console.WriteLine($"d1 ({d1}) ~= d2 ({d2}): {RoughlyEquals(d1, d2, window, freq)}")
    Console.WriteLine($"d1 ({d1}) ~= d3 ({d3}): {RoughlyEquals(d1, d3, window, freq)}")
    Console.WriteLine($"d1 ({d1}) ~= d4 ({d4}): {RoughlyEquals(d1, d4, window, freq)}")
    Console.WriteLine($"d1 ({d1}) ~= d5 ({d5}): {RoughlyEquals(d1, d5, window, freq)}")

    Console.WriteLine($"d1 ({d1}) ~= d6 ({d6}): {RoughlyEquals(d1, d6, window, freq)}")
    Console.WriteLine($"d1 ({d1}) ~= d7 ({d7}): {RoughlyEquals(d1, d7, window, freq)}")
    Console.WriteLine($"d1 ({d1}) ~= d8 ({d8}): {RoughlyEquals(d1, d8, window, freq)}")
    Console.WriteLine($"d1 ({d1}) ~= d9 ({d9}): {RoughlyEquals(d1, d9, window, freq)}")
End Sub
' The example displays output similar to the following:
'    d1 (1/28/2010 9:01:26 PM) ~= d1 (1/28/2010 9:01:26 PM): True
'    d1 (1/28/2010 9:01:26 PM) ~= d2 (1/28/2010 9:01:46 PM): False
'    d1 (1/28/2010 9:01:26 PM) ~= d3 (1/28/2010 9:01:06 PM): False
'    d1 (1/28/2010 9:01:26 PM) ~= d4 (1/28/2010 9:01:31 PM): True
'    d1 (1/28/2010 9:01:26 PM) ~= d5 (1/28/2010 9:01:21 PM): True
'    d1 (1/28/2010 9:01:26 PM) ~= d6 (1/28/2010 11:01:46 PM): False
'    d1 (1/28/2010 9:01:26 PM) ~= d7 (1/28/2010 11:01:06 PM): False
'    d1 (1/28/2010 9:01:26 PM) ~= d8 (1/28/2010 11:01:31 PM): True
'    d1 (1/28/2010 9:01:26 PM) ~= d9 (1/28/2010 11:01:21 PM): True

Überlegungen zu COM-Interop

Ein DateTime Wert, der an eine COM-Anwendung übertragen und dann wieder an eine verwaltete Anwendung übertragen wird, wird als Roundtrip bezeichnet. Ein Wert, der DateTime nur eine Uhrzeit angibt, führt jedoch keine Roundtrips wie erwartet durch.

Wenn Sie einen Roundtrip nur zu einem Zeitpunkt (z.B. 15:00 Uhr) unternehmen, ist das endende Datum und die Uhrzeit der 30. Dezember 1899 20.00 Uhr. um 15:00 Uhr anstatt am 1. Januar 0001 20:00 Uhr um 15:00 Uhr Die .NET Framework und COM setzen ein Standarddatum voraus, wenn nur eine Uhrzeit angegeben wird. Das COM-System geht jedoch von einem Basisdatum des 30. Dezember 1899 2009 aus, während für die .NET Framework ein Basisdatum vom 1. Januar 0001 2001 angenommen wird.

Wenn nur eine Zeit vom .NET Framework an COM übergeben wird, wird eine spezielle Verarbeitung ausgeführt, die die Zeit in das von COM verwendete Format konvertiert. Wenn nur eine Zeit von COM an die .NET Framework übergeben wird, wird keine spezielle Verarbeitung durchgeführt, da dies legitime Datums- und Uhrzeitangaben am oder vor dem 30. Dezember 1899 beschädigen würde. Wenn ein Datum den Roundtrip von COM startet, behalten die .NET Framework und COM das Datum bei.

Das Verhalten der .NET Framework und COM bedeutet, dass ihre Anwendung daran denken muss, das fehlerhafte Datum aus dem endgültigen Objekt zu ändern oder zu ignorieren, wenn Ihre Anwendung ein roundtript, DateTime das nur eine Uhrzeit angibt. DateTime

Konstruktoren

DateTime(Int32, Int32, Int32)

Initialisiert eine neue Instanz der DateTime-Struktur mit dem angegebenen Jahr, Monat und Tag.

DateTime(Int32, Int32, Int32, Calendar)

Initialisiert eine neue Instanz der DateTime-Struktur mit dem angegebenen Jahr, Monat und Tag für den angegebenen Kalender.

DateTime(Int32, Int32, Int32, Int32, Int32, Int32)

Initialisiert eine neue Instanz der DateTime-Struktur mit den angegebenen Werten für Jahr, Monat, Tag, Stunde, Minute und Sekunde.

DateTime(Int32, Int32, Int32, Int32, Int32, Int32, Calendar)

Initialisiert eine neue Instanz der DateTime-Struktur mit den angegebenen Werten für Jahr, Monat, Tag, Stunde, Minute und Sekunde für den angegebenen Kalender.

DateTime(Int32, Int32, Int32, Int32, Int32, Int32, DateTimeKind)

Initialisiert eine neue Instanz der DateTime-Struktur mit den angegebenen Werten für Jahr, Monat, Tag, Stunde, Minute, Sekunde und koordinierte Weltzeit (Coordinated Universal Time, UTC) oder Ortszeit.

DateTime(Int32, Int32, Int32, Int32, Int32, Int32, Int32)

Initialisiert eine neue Instanz der DateTime-Struktur mit den angegebenen Werten für Jahr, Monat, Tag, Stunde, Minute, Sekunde und Millisekunde.

DateTime(Int32, Int32, Int32, Int32, Int32, Int32, Int32, Calendar)

Initialisiert eine neue Instanz der DateTime-Struktur mit den angegebenen Werten für Jahr, Monat, Tag, Stunde, Minute, Sekunde und Millisekunde für den angegebenen Kalender.

DateTime(Int32, Int32, Int32, Int32, Int32, Int32, Int32, Calendar, DateTimeKind)

Initialisiert eine neue Instanz der DateTime-Struktur mit den angegebenen Werten für Jahr, Monat, Tag, Stunde, Minute, Sekunde, Millisekunde und koordinierte Weltzeit (Coordinated Universal Time, UTC) oder Ortszeit für den angegebenen Kalender.

DateTime(Int32, Int32, Int32, Int32, Int32, Int32, Int32, DateTimeKind)

Initialisiert eine neue Instanz der DateTime-Struktur mit den angegebenen Werten für Jahr, Monat, Tag, Stunde, Minute, Sekunde, Millisekunde und koordinierte Weltzeit (Coordinated Universal Time, UTC) oder Ortszeit.

DateTime(Int64)

Initialisiert eine neue Instanz der DateTime-Struktur mit einer angegebenen Anzahl von Ticks.

DateTime(Int64, DateTimeKind)

Initialisiert eine neue Instanz der DateTime-Struktur mit einer angegebenen Anzahl von Ticks und koordinierter Weltzeit (UTC) oder lokaler Zeit.

Felder

MaxValue

Stellt den größtmöglichen Wert von DateTime dar. Dieses Feld ist schreibgeschützt.

MinValue

Stellt den kleinstmöglichen Wert von DateTime dar. Dieses Feld ist schreibgeschützt.

UnixEpoch

Der Wert dieser Konstanten entspricht „00:00:00.0000000 UTC, 1. Januar 1970“ im gregorianischen Kalender. UnixEpoch definiert den Zeitpunkt, zu dem die UNIX-Zeit gleich 0 (null) ist.

Eigenschaften

Date

Ruft die Datumskomponente dieser Instanz ab.

Day

Ruft den Tag des Monats ab, der durch diese Instanz dargestellt wird.

DayOfWeek

Ruft den Wochentag ab, der durch diese Instanz dargestellt wird.

DayOfYear

Ruft den Tag des Jahres ab, der durch diese Instanz dargestellt wird.

Hour

Ruft die Komponente für die Stunden des Datums ab, das durch diese Instanz dargestellt wird.

Kind

Ruft einen Wert ab, der angibt, ob die durch diese Instanz dargestellte Zeit auf lokaler Zeit, koordinierter Weltzeit (UTC) oder keinem von beiden basiert.

Millisecond

Ruft die Komponente für die Millisekunden des Datums ab, das durch diese Instanz dargestellt wird.

Minute

Ruft die Komponente für die Minuten des Datums ab, das durch diese Instanz dargestellt wird.

Month

Ruft die Komponente für den Monat des Datums ab, das durch diese Instanz dargestellt wird.

Now

Ruft ein DateTime-Objekt ab, das auf das aktuelle Datum und die aktuelle Zeit auf dem lokalen Rechner als Ortszeit festgelegt ist.

Second

Ruft die Komponente für die Sekunden des Datums ab, das durch diese Instanz dargestellt wird.

Ticks

Ruft die Anzahl der Ticks ab, die Datum und Uhrzeit dieser Instanz darstellen.

TimeOfDay

Ruft die Uhrzeit für diese Instanz ab.

Today

Ruft das aktuelle Datum ab.

UtcNow

Ruft ein DateTime-Objekt ab, das auf die aktuelle Datums- und Uhrzeitangabe auf diesem Rechner als koordinierte Weltzeit (UTC) festgelegt ist.

Year

Ruft die Komponente für das Jahr des Datums ab, das durch diese Instanz dargestellt wird.

Methoden

Add(TimeSpan)

Gibt einen neuen DateTime-Wert zurück, der den Wert des angegebenen TimeSpan-Werts zum Wert dieser Instanz addiert.

AddDays(Double)

Gibt einen neuen DateTime-Wert zurück, der die angegebene Anzahl von Tagen zum Wert dieser Instanz addiert.

AddHours(Double)

Gibt einen neuen DateTime-Wert zurück, der die angegebene Anzahl von Stunden zum Wert dieser Instanz addiert.

AddMilliseconds(Double)

Gibt einen neuen DateTime-Wert zurück, der die angegebene Anzahl von Millisekunden zum Wert dieser Instanz addiert.

AddMinutes(Double)

Gibt einen neuen DateTime-Wert zurück, der die angegebene Anzahl von Minuten zum Wert dieser Instanz addiert.

AddMonths(Int32)

Gibt einen neuen DateTime-Wert zurück, der die angegebene Anzahl von Monaten zum Wert dieser Instanz addiert.

AddSeconds(Double)

Gibt einen neuen DateTime-Wert zurück, der die angegebene Anzahl von Sekunden zum Wert dieser Instanz addiert.

AddTicks(Int64)

Gibt einen neuen DateTime-Wert zurück, der die angegebene Anzahl von Ticks zum Wert dieser Instanz addiert.

AddYears(Int32)

Gibt einen neuen DateTime-Wert zurück, der die angegebene Anzahl von Jahren zum Wert dieser Instanz addiert.

Compare(DateTime, DateTime)

Vergleicht zwei Instanzen von DateTime und gibt eine ganze Zahl zurück, die angibt, ob die erste Instanz früher oder später als die zweite Instanz ist oder ob sie mit dieser identisch ist.

CompareTo(DateTime)

Vergleicht den Wert dieser Instanz mit einem angegebenen DateTime-Wert und gibt eine Ganzzahl zurück, die angibt, ob diese Instanz vor oder nach dem angegebenen DateTime-Wert liegt oder diesem entspricht.

CompareTo(Object)

Vergleicht den Wert dieser Instanz mit einem angegebenen Objekt, das einen angegebenen DateTime-Wert enthält, und gibt eine Ganzzahl zurück, die angibt, ob diese Instanz vor oder nach dem angegebenen DateTime-Wert liegt oder diesem entspricht.

DaysInMonth(Int32, Int32)

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

Equals(DateTime)

Gibt einen Wert zurück, der angibt, ob der Wert dieser Instanz gleich dem Wert der angegebenen DateTime-Instanz ist.

Equals(DateTime, DateTime)

Gibt einen Wert zurück, der angibt, ob zwei DateTime-Instanzen denselben Datum- und Zeitwert besitzen.

Equals(Object)

Gibt einen Wert zurück, der angibt, ob diese Instanz gleich einem angegebenen Objekt ist.

FromBinary(Int64)

Deserialisiert einen 64-Bit-Binärwert und erstellt ein ursprüngliches serialisiertes DateTime-Objekt neu.

FromFileTime(Int64)

Konvertiert die angegebene Windows-Dateizeit in eine entsprechende Ortszeit.

FromFileTimeUtc(Int64)

Konvertiert die angegebene Windows-Dateizeit in eine entsprechende UTC-Zeit.

FromOADate(Double)

Gibt eine DateTime zurück, die dem angegebenen Datum für die OLE-Automatisierung entspricht.

GetDateTimeFormats()

Konvertiert den Wert dieser Instanz in alle Zeichenfolgendarstellungen, die von den Standardformatbezeichnern für Datum und Uhrzeit unterstützt werden.

GetDateTimeFormats(Char)

Konvertiert den Wert dieser Instanz in alle Zeichenfolgendarstellungen, die von den angegebenen Standardformatbezeichnern für Datum und Uhrzeit unterstützt werden.

GetDateTimeFormats(Char, IFormatProvider)

Konvertiert den Wert dieser Instanz in alle Zeichenfolgenentsprechungen, die von dem angegebenen Standardformatbezeichner für Datum und Uhrzeit und den angegebenen kulturspezifischen Formatierungsinformationen unterstützt werden.

GetDateTimeFormats(IFormatProvider)

Konvertiert den Wert dieser Instanz in alle Zeichenfolgendarstellungen, die von den Standardformatbezeichnern für Datum und Uhrzeit und den angegebenen kulturspezifischen Formatierungsinformationen unterstützt werden.

GetHashCode()

Gibt den Hashcode für diese Instanz zurück.

GetTypeCode()

Gibt den TypeCode für den Werttyp DateTime zurück.

IsDaylightSavingTime()

Gibt an, ob sich diese Instanz von DateTime im Sommerzeitbereich für die aktuelle Zeitzone befindet.

IsLeapYear(Int32)

Gibt eine Angabe darüber zurück, ob das angegebene Jahr ein Schaltjahr ist.

Parse(ReadOnlySpan<Char>, IFormatProvider, DateTimeStyles)

Konvertiert eine Arbeitsspeicherspanne, die eine Zeichenfolgendarstellung einer Datums- und Uhrzeitangabe enthält, unter Verwendung der kulturspezifischen Formatierungsinformationen und eines Formatierungsstil in die entsprechende DateTime.

Parse(String)

Konvertiert die Zeichenfolgendarstellung einer Datums- und Uhrzeitangabe anhand der Konventionen für die aktuelle Threadkultur in die entsprechende DateTime.

Parse(String, IFormatProvider)

Konvertiert die Zeichenfolgendarstellungen einer Datums- und Uhrzeitangabe unter Verwendung der kulturspezifischen Formatierungsinformationen in die entsprechende DateTime.

Parse(String, IFormatProvider, DateTimeStyles)

Konvertiert die Zeichenfolgendarstellung einer Datums- und Uhrzeitangabe unter Verwendung der kulturspezifischen Formatierungsinformationen und eines Formatierungsstil in die entsprechende DateTime.

ParseExact(ReadOnlySpan<Char>, ReadOnlySpan<Char>, IFormatProvider, DateTimeStyles)

Konvertiert die angegebene Spannendarstellung einer Datums- und Uhrzeitangabe unter Verwendung der Angaben über Format, kulturabhängige Formatierungsinformationen und Stil in das DateTime-Äquivalent. Das Format der Zeichenfolgendarstellung muss dem angegebenen Format genau entsprechen. Andernfalls wird eine Ausnahme ausgelöst.

ParseExact(ReadOnlySpan<Char>, String[], IFormatProvider, DateTimeStyles)

Konvertiert die angegebene Spannendarstellung einer Datums- und Uhrzeitangabe unter Verwendung der Arrayangaben über Format, kulturabhängige Formatierungsinformationen und Stil in das DateTime-Äquivalent. Das Format der Zeichenfolgendarstellung muss mindestens einem der angegebenen Formate genau entsprechen. Andernfalls wird eine Ausnahme ausgelöst.

ParseExact(String, String, IFormatProvider)

Konvertiert die angegebene Zeichenfolgenentsprechung einer Datums- und Uhrzeitangabe unter Verwendung des angegebenen Formats und der angegebenen kulturabhängigen Formatierungsinformationen in die entsprechende DateTime. Das Format der Zeichenfolgendarstellung muss dem angegebenen Format genau entsprechen.

ParseExact(String, String, IFormatProvider, DateTimeStyles)

Konvertiert die angegebene Zeichenfolgenentsprechung einer Datums- und Uhrzeitangabe unter Verwendung der Angaben über Format, kulturabhängige Formatierungsinformationen und Stil in die entsprechende DateTime. Das Format der Zeichenfolgendarstellung muss dem angegebenen Format genau entsprechen. Andernfalls wird eine Ausnahme ausgelöst.

ParseExact(String, String[], IFormatProvider, DateTimeStyles)

Konvertiert die angegebene Zeichenfolgenentsprechung einer Datums- und Uhrzeitangabe unter Verwendung des angegebenen Formatarrays, der kulturspezifischen Formatierungsinformationen und des Stils in die DateTime-Entsprechung. Das Format der Zeichenfolgendarstellung muss mindestens einem der angegebenen Formate genau entsprechen. Andernfalls wird eine Ausnahme ausgelöst.

SpecifyKind(DateTime, DateTimeKind)

Erstellt ein neues DateTime-Objekt, das über die gleiche Anzahl von Ticks wie die angegebene DateTime verfügt, aber entsprechend dem DateTimeKind-Wert in Ortszeit, koordinierter Weltzeit (Coordinated Universal Time, UTC) oder keinem von beiden angegeben ist.

Subtract(DateTime)

Gibt ein neues TimeSpan-Objekt zurück, das das angegebene Datum und die angegebene Zeit von dem Wert dieser Instanz subtrahiert.

Subtract(TimeSpan)

Gibt ein neues DateTime-Objekt zurück, das die angegebene Dauer von dem Wert dieser Instanz subtrahiert.

ToBinary()

Serialisiert das aktuelle DateTime-Objekt in einen 64-Bit-Binärwert, der dann zum erneuten Erstellen des DateTime-Objekts verwendet werden kann.

ToFileTime()

Konvertiert den Wert des aktuellen DateTime-Objekts in eine Windows-Dateizeit.

ToFileTimeUtc()

Konvertiert den Wert des aktuellen DateTime-Objekts in eine Windows-Dateizeit.

ToLocalTime()

Konvertiert den Wert des aktuellen DateTime-Objekts in die Ortszeit.

ToLongDateString()

Konvertiert den Wert des aktuellen DateTime-Objekts in die entsprechende Zeichenfolgendarstellung im langen Datumsformat.

ToLongTimeString()

Konvertiert den Wert des aktuellen DateTime-Objekts in die entsprechende Zeichenfolgendarstellung im langen Zeitformat.

ToOADate()

Konvertiert den Wert dieser Instanz in das entsprechende Datum für OLE-Automatisierung.

ToShortDateString()

Konvertiert den Wert des aktuellen DateTime-Objekts in die entsprechende Zeichenfolgendarstellung im kurzen Datumsformat.

ToShortTimeString()

Konvertiert den Wert des aktuellen DateTime-Objekts in die entsprechende Zeichenfolgendarstellung im kurzen Zeitformat.

ToString()

Konvertiert den Wert des aktuellen DateTime-Objekts unter Verwendung der Formatierungskonventionen der aktuellen Kultur in die entsprechende Zeichenfolgendarstellung.

ToString(IFormatProvider)

Konvertiert den Wert des aktuellen DateTime-Objekts unter Verwendung der angegebenen kulturspezifischen Formatierungsinformationen in die entsprechende Zeichenfolgendarstellung.

ToString(String)

Konvertiert den Wert des aktuellen DateTime-Objekts unter Verwendung des angegebenen Formats und der Formatierungskonventionen der aktuellen Kultur in die entsprechende Zeichenfolgendarstellung.

ToString(String, IFormatProvider)

Konvertiert den Wert des aktuellen DateTime-Objekts unter Verwendung des angegebenen Formats sowie der kulturabhängigen Formatierungsinformationen in die entsprechende Zeichenfolgendarstellung.

ToUniversalTime()

Konvertiert den Wert des aktuellen DateTime-Objekts in koordinierte Weltzeit (UTC).

TryFormat(Span<Char>, Int32, ReadOnlySpan<Char>, IFormatProvider)

Versucht, den Wert der aktuellen datetime-Instanz in die angegebene Zeichenspanne zu formatieren.

TryParse(ReadOnlySpan<Char>, DateTime)

Konvertiert die angegebene Zeichenspanne einer Datums- und Uhrzeitangabe in deren DateTime-Äquivalent und gibt einen Wert zurück, der angibt, ob die Konvertierung erfolgreich ausgeführt wurde.

TryParse(ReadOnlySpan<Char>, IFormatProvider, DateTimeStyles, DateTime)

Konvertiert die Spannendarstellung einer Datums- und Uhrzeitangabe unter Verwendung der angegebenen kulturspezifischen Formatierungsinformationen und des Formatierungsstils in das DateTime-Äquivalent und gibt einen Wert zurück, der angibt, ob die Konvertierung erfolgreich abgeschlossen wurde.

TryParse(String, DateTime)

Konvertiert die angegebene Zeichenfolgendarstellung einer Datums- und Uhrzeitangabe in deren DateTime-Entsprechung und gibt einen Wert zurück, der angibt, ob die Konvertierung erfolgreich ausgeführt wurde.

TryParse(String, IFormatProvider, DateTimeStyles, DateTime)

Konvertiert die angegebene Zeichenfolgendarstellung einer Datums- und Uhrzeitangabe unter Verwendung der angegebenen kulturspezifischen Formatierungsinformationen und des Formatierungsstils in die entsprechende DateTime und gibt einen Wert zurück, der angibt, ob die Konvertierung erfolgreich abgeschlossen wurde.

TryParseExact(ReadOnlySpan<Char>, ReadOnlySpan<Char>, IFormatProvider, DateTimeStyles, DateTime)

Konvertiert die angegebene Spannendarstellung einer Datums- und Uhrzeitangabe unter Verwendung der Angaben über Format, kulturabhängige Formatierungsinformationen und Stil in das DateTime-Äquivalent. Das Format der Zeichenfolgendarstellung muss dem angegebenen Format genau entsprechen. Die Methode gibt einen Wert zurück, der angibt, ob die Konvertierung erfolgreich abgeschlossen wurde.

TryParseExact(ReadOnlySpan<Char>, String[], IFormatProvider, DateTimeStyles, DateTime)

Konvertiert die angegebene Zeichenspanne einer Datums- und Uhrzeitangabe in deren DateTime-Äquivalent und gibt einen Wert zurück, der angibt, ob die Konvertierung erfolgreich ausgeführt wurde.

TryParseExact(String, String, IFormatProvider, DateTimeStyles, DateTime)

Konvertiert die angegebene Zeichenfolgenentsprechung einer Datums- und Uhrzeitangabe unter Verwendung der Angaben über Format, kulturabhängige Formatierungsinformationen und Stil in die entsprechende DateTime. Das Format der Zeichenfolgendarstellung muss dem angegebenen Format genau entsprechen. Die Methode gibt einen Wert zurück, der angibt, ob die Konvertierung erfolgreich abgeschlossen wurde.

TryParseExact(String, String[], IFormatProvider, DateTimeStyles, DateTime)

Konvertiert die angegebene Zeichenfolgenentsprechung einer Datums- und Uhrzeitangabe unter Verwendung des angegebenen Formatarrays, der kulturspezifischen Formatierungsinformationen und des Stils in die DateTime-Entsprechung. Das Format der Zeichenfolgendarstellung muss mindestens einem der angegebenen Formate genau entsprechen. Die Methode gibt einen Wert zurück, der angibt, ob die Konvertierung erfolgreich abgeschlossen wurde.

Operatoren

Addition(DateTime, TimeSpan)

Addiert ein angegebenes Zeitintervall zu einer Datums- und Uhrzeitangabe und gibt eine neue Datums- und Uhrzeitangabe zurück.

Equality(DateTime, DateTime)

Bestimmt, ob zwei angegebene Instanzen von DateTime gleich sind.

GreaterThan(DateTime, DateTime)

Bestimmt, ob eine angegebene DateTime später als eine andere angegebene DateTime ist.

GreaterThanOrEqual(DateTime, DateTime)

Bestimmt, ob eine vorliegende DateTime-Angabe eine Datums- und Uhrzeitangabe darstellt, die gleichzeitig oder später als eine andere vorliegende DateTime-Angabe ist.

Inequality(DateTime, DateTime)

Bestimmt, ob zwei angegebene Instanzen von DateTime nicht gleich sind.

LessThan(DateTime, DateTime)

Bestimmt, ob eine angegebene DateTime früher als eine andere angegebene DateTime ist.

LessThanOrEqual(DateTime, DateTime)

Bestimmt, ob eine vorliegende DateTime-Angabe eine Datums- und Uhrzeitangabe darstellt, die gleichzeitig oder früher als eine andere vorliegende DateTime-Angabe ist.

Subtraction(DateTime, DateTime)

Subtrahiert eine Datums- und Uhrzeitangabe von einer anderen Datums- und Uhrzeitangabe und gibt ein Zeitintervall zurück.

Subtraction(DateTime, TimeSpan)

Subtrahiert ein angegebenes Zeitintervall von einer Datums- und Uhrzeitangabe und gibt eine neue Datums- und Uhrzeitangabe zurück.

Explizite Schnittstellenimplementierungen

IComparable.CompareTo(Object)

Vergleicht die aktuelle Instanz mit einem anderen Objekt vom selben Typ und gibt eine ganze Zahl zurück, die angibt, ob die aktuelle Instanz in der Sortierreihenfolge vor oder nach dem anderen Objekt oder an derselben Position auftritt.

IConvertible.GetTypeCode()

Gibt den TypeCode für diese Instanz zurück.

IConvertible.ToBoolean(IFormatProvider)

Diese Konvertierung wird nicht unterstützt. Bei dem Versuch der Verwendung dieser Methode wird eine InvalidCastException ausgelöst.

IConvertible.ToByte(IFormatProvider)

Diese Konvertierung wird nicht unterstützt. Bei dem Versuch der Verwendung dieser Methode wird eine InvalidCastException ausgelöst.

IConvertible.ToChar(IFormatProvider)

Diese Konvertierung wird nicht unterstützt. Bei dem Versuch der Verwendung dieser Methode wird eine InvalidCastException ausgelöst.

IConvertible.ToDateTime(IFormatProvider)

Gibt das aktuelle DateTime-Objekt zurück.

IConvertible.ToDecimal(IFormatProvider)

Diese Konvertierung wird nicht unterstützt. Bei dem Versuch der Verwendung dieser Methode wird eine InvalidCastException ausgelöst.

IConvertible.ToDouble(IFormatProvider)

Diese Konvertierung wird nicht unterstützt. Bei dem Versuch der Verwendung dieser Methode wird eine InvalidCastException ausgelöst.

IConvertible.ToInt16(IFormatProvider)

Diese Konvertierung wird nicht unterstützt. Bei dem Versuch der Verwendung dieser Methode wird eine InvalidCastException ausgelöst.

IConvertible.ToInt32(IFormatProvider)

Diese Konvertierung wird nicht unterstützt. Bei dem Versuch der Verwendung dieser Methode wird eine InvalidCastException ausgelöst.

IConvertible.ToInt64(IFormatProvider)

Diese Konvertierung wird nicht unterstützt. Bei dem Versuch der Verwendung dieser Methode wird eine InvalidCastException ausgelöst.

IConvertible.ToSByte(IFormatProvider)

Diese Konvertierung wird nicht unterstützt. Bei dem Versuch der Verwendung dieser Methode wird eine InvalidCastException ausgelöst.

IConvertible.ToSingle(IFormatProvider)

Diese Konvertierung wird nicht unterstützt. Bei dem Versuch der Verwendung dieser Methode wird eine InvalidCastException ausgelöst.

IConvertible.ToType(Type, IFormatProvider)

Konvertiert das aktuelle DateTime-Objekt in ein Objekt vom angegebenen Typ.

IConvertible.ToUInt16(IFormatProvider)

Diese Konvertierung wird nicht unterstützt. Bei dem Versuch der Verwendung dieser Methode wird eine InvalidCastException ausgelöst.

IConvertible.ToUInt32(IFormatProvider)

Diese Konvertierung wird nicht unterstützt. Bei dem Versuch der Verwendung dieser Methode wird eine InvalidCastException ausgelöst.

IConvertible.ToUInt64(IFormatProvider)

Diese Konvertierung wird nicht unterstützt. Bei dem Versuch der Verwendung dieser Methode wird eine InvalidCastException ausgelöst.

ISerializable.GetObjectData(SerializationInfo, StreamingContext)

Füllt ein SerializationInfo-Objekt mit den für das Serialisieren des aktuellen DateTime-Objekts erforderlichen Daten.

Gilt für

Threadsicherheit

Alle Member dieses Typs sind threadsicher. Member, die den Instanzzustand zu ändern scheinen, geben tatsächlich eine neue Instanz zurück, die mit dem neuen Wert initialisiert wurde. Wie bei jedem anderen Typ muss das Lesen und Schreiben in eine freigegebene Variable, die eine Instanz dieses Typs enthält, durch eine Sperre geschützt werden, um threadsicherheit zu gewährleisten.

Siehe auch