DateTime Struktur
Definition
Wichtig
Einige Informationen beziehen sich auf Vorabversionen, die vor dem Release ggf. grundlegend überarbeitet werden. Microsoft übernimmt hinsichtlich der hier bereitgestellten Informationen keine Gewährleistungen, seien sie ausdrücklich oder konkludent.
Stellt einen Zeitpunkt dar, der üblicherweise als Datum und Uhrzeit ausgedrückt wird.
public value class DateTime : IComparable, IComparable<DateTime>, IConvertible, IEquatable<DateTime>, IFormattablepublic value class DateTime : IComparable, IComparable<DateTime>, IConvertible, IEquatable<DateTime>, IFormattable, System::Runtime::Serialization::ISerializablepublic value class DateTime : IComparable, IComparable<DateTime>, IConvertible, IEquatable<DateTime>, ISpanFormattable, System::Runtime::Serialization::ISerializablepublic value class DateTime : IComparable, IComparable<DateTime>, IConvertible, IEquatable<DateTime>, IParsable<DateTime>, ISpanFormattable, ISpanParsable<DateTime>, System::Runtime::Serialization::ISerializablepublic value class DateTime : IComparable, IComparable<DateTime>, IConvertible, IEquatable<DateTime>, IParsable<DateTime>, ISpanFormattable, ISpanParsable<DateTime>, IUtf8SpanFormattable, System::Runtime::Serialization::ISerializablepublic value class DateTime : IComparable, IConvertible, IFormattablepublic value class DateTime : IComparable, IComparable<DateTime>, IEquatable<DateTime>, IFormattablepublic struct DateTime : IComparable, IComparable<DateTime>, IConvertible, IEquatable<DateTime>, IFormattablepublic readonly struct DateTime : IComparable, IComparable<DateTime>, IConvertible, IEquatable<DateTime>, IFormattable, System.Runtime.Serialization.ISerializablepublic readonly struct DateTime : IComparable, IComparable<DateTime>, IConvertible, IEquatable<DateTime>, ISpanFormattable, System.Runtime.Serialization.ISerializablepublic readonly struct DateTime : IComparable, IComparable<DateTime>, IConvertible, IEquatable<DateTime>, IParsable<DateTime>, ISpanFormattable, ISpanParsable<DateTime>, System.Runtime.Serialization.ISerializablepublic readonly struct DateTime : IComparable, IComparable<DateTime>, IConvertible, IEquatable<DateTime>, IParsable<DateTime>, ISpanFormattable, ISpanParsable<DateTime>, IUtf8SpanFormattable, System.Runtime.Serialization.ISerializablepublic struct DateTime : IComparable, IComparable<DateTime>, IConvertible, IEquatable<DateTime>, IFormattable, 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.ISerializablepublic struct DateTime : IComparable, IComparable<DateTime>, IEquatable<DateTime>, IFormattabletype DateTime = struct
interface IConvertible
interface IFormattabletype DateTime = struct
interface IConvertible
interface IFormattable
interface ISerializabletype DateTime = struct
interface IConvertible
interface ISpanFormattable
interface IFormattable
interface ISerializabletype DateTime = struct
interface IConvertible
interface IFormattable
interface IParsable<DateTime>
interface ISpanFormattable
interface ISpanParsable<DateTime>
interface ISerializabletype DateTime = struct
interface IConvertible
interface IFormattable
interface IParsable<DateTime>
interface ISpanFormattable
interface ISpanParsable<DateTime>
interface ISerializable
interface IUtf8SpanFormattable[<System.Serializable>]
type DateTime = struct
interface IFormattable
interface IConvertible[<System.Serializable>]
type DateTime = struct
interface IFormattable
interface IConvertible
interface ISerializabletype DateTime = struct
interface IFormattablePublic Structure DateTime
Implements IComparable, IComparable(Of DateTime), IConvertible, IEquatable(Of DateTime), IFormattablePublic Structure DateTime
Implements IComparable, IComparable(Of DateTime), IConvertible, IEquatable(Of DateTime), IFormattable, ISerializablePublic Structure DateTime
Implements IComparable, IComparable(Of DateTime), IConvertible, IEquatable(Of DateTime), ISerializable, ISpanFormattablePublic Structure DateTime
Implements IComparable, IComparable(Of DateTime), IConvertible, IEquatable(Of DateTime), IParsable(Of DateTime), ISerializable, ISpanFormattable, ISpanParsable(Of DateTime)Public Structure DateTime
Implements IComparable, IComparable(Of DateTime), IConvertible, IEquatable(Of DateTime), IParsable(Of DateTime), ISerializable, ISpanFormattable, ISpanParsable(Of DateTime), IUtf8SpanFormattablePublic Structure DateTime
Implements IComparable, IConvertible, IFormattablePublic Structure DateTime
Implements IComparable, IComparable(Of DateTime), IEquatable(Of DateTime), IFormattable- Vererbung
- 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 zum Ermitteln, ob Ihre Anwendungen betroffen sind, finden Sie unter Behandeln einer neuen Ära im japanischen Kalender in .NET. Informationen zum Testen Ihrer Anwendungen auf Windows-Systemen, um ihre Bereitschaft für die Änderung der Ära sicherzustellen, finden Sie unter Vorbereiten der Anwendung für die Änderung der japanischen Ära. Features in .NET, die Kalender mit mehreren Epochen unterstützen, und bewährte Methoden für die Arbeit mit Kalendern, die mehrere Epochen unterstützen, finden Sie unter Arbeiten mit Epochen.
Direktlinks zum Beispielcode
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 DateTime Typ verwenden:
Initialisierungsbeispiele
- Aufrufen eines Konstruktors
- Aufrufen des impliziten parameterlosen Konstruktors
- Zuweisung vom Rückgabewert
- Analysieren einer Zeichenfolge, die ein Datum und eine Uhrzeit darstellt
- Visual Basic-Syntax zum Initialisieren eines Datums und einer Uhrzeit
Formatieren von DateTime Objekten als Zeichenfolgen
- Verwenden des Standardformats für Datumszeit
- Formatieren eines Datums und einer Uhrzeit mithilfe einer bestimmten Kultur
- Formatieren einer Datumszeit mithilfe einer Standard- oder benutzerdefinierten Formatzeichenfolge
- Angeben einer Formatzeichenfolge und einer bestimmten Kultur
- Formatieren einer Datumszeit mithilfe der ISO 8601-Norm für Webdienste
Analysieren von Zeichenfolgen als DateTime Objekte
- Verwenden
ParseoderTryParsekonvertieren einer Zeichenfolge in ein Datum und eine Uhrzeit - Verwenden
ParseExactoderTryParseExactKonvertieren einer Zeichenfolge in ein bekanntes Format - Konvertieren von der ISO 8601-Zeichenfolgendarstellung in ein Datum und eine Uhrzeit
DateTime Auflösung
- Untersuchen der Auflösung von Datums- und Uhrzeitwerten
- Vergleichen auf Gleichheit innerhalb einer Toleranz
Kultur und Kalender
- Anzeigen von Datums- und Uhrzeitwerten mithilfe kulturspezifischer Kalender
- Analysieren von Zeichenfolgen gemäß einem kulturspezifischen Kalender
- Initialisieren eines Datums und einer Uhrzeit aus dem Kalender einer bestimmten Kultur
- Zugreifen auf Datums- und Uhrzeiteigenschaften mithilfe des Kalenders einer bestimmten Kultur
- Abrufen der Woche des Jahres mithilfe kulturspezifischer Kalender
Persistenz
- Beibehalten von Datums- und Uhrzeitwerten als Zeichenfolgen in der lokalen Zeitzone
- Beibehalten von Datums- und Uhrzeitwerten als Zeichenfolgen in einem kultur- und zeitinvarianten Format
- Beibehalten von Datums- und Uhrzeitwerten als ganze Zahlen
- Beibehalten von Datums- und Uhrzeitwerten mithilfe des
XmlSerializer
Schnelllinks zu Themen zu Anmerkungen
Dieser Abschnitt enthält Themen zu vielen häufigen Verwendungen der DateTime Struktur:
- Initialisieren eines
DateTimeObjekts - DateTime-Werte und ihre Zeichenfolgendarstellungen
- Analysieren von DateTime-Werten aus Zeichenfolgen
- DateTime-Werte
- DateTime-Vorgänge
- DateTime-Auflösung
- DateTime-Werte und -Kalender
- Beibehalten von DateTime-Werten
- DateTime im Vergleich zu TimeSpan
- Vergleichen auf Gleichheit innerhalb der Toleranz
- Überlegungen zur COM-Interop
Der DateTime Werttyp stellt Datums- und Uhrzeitangaben mit Werten zwischen 00:00:00 (Mitternacht), 1. Januar 0001 Anno Domini (Common Era) bis 23:59:59 Uhr, 31. Dezember 9999 n. Chr. (C.E.) im gregorianischen Kalender dar.
Zeitwerte werden in 100 Nanosekundeneinheiten gemessen, die als Ticks bezeichnet werden. Ein bestimmtes Datum ist die Anzahl der Ticks seit 12:00 Uhr Mitternacht, 1. Januar 0001 A.D. (C.E.) im GregorianCalendar Kalender. Die Zahl schließt Ticks aus, die durch Sprungsekunden hinzugefügt würden. Beispielsweise stellt ein Ticks-Wert von 312413760000000000L das Datum Freitag, 01. Januar 0100 12:00:00 Uhr Mitternacht dar. Ein DateTime Wert wird immer im Kontext eines expliziten oder Standardkalenders ausgedrückt.
Hinweis
Wenn Sie mit einem Ticks-Wert arbeiten, den Sie in ein anderes Zeitintervall konvertieren möchten, z. B. Minuten oder Sekunden, sollten Sie die TimeSpan.TicksPerDayKonstante , TimeSpan.TicksPerHour, TimeSpan.TicksPerMinuteTimeSpan.TicksPerSecond, oder TimeSpan.TicksPerMillisecond verwenden, um die Konvertierung auszuführen. Um beispielsweise die Anzahl von Sekunden, die durch eine angegebene Anzahl von Ticks dargestellt wird, der Second Komponente eines DateTime Werts hinzuzufügen, können Sie den Ausdruck dateValue.Second + nTicks/Timespan.TicksPerSecondverwenden.
Sie können die Quelle für den gesamten Satz von Beispielen aus diesem Artikel entweder in Visual Basic, F# oder C# im Dokumentrepository auf GitHub anzeigen.
Hinweis
Eine Alternative zur DateTime Struktur zum Arbeiten mit Datums- und Uhrzeitwerten in bestimmten Zeitzonen ist die DateTimeOffset Struktur. Die DateTimeOffset Struktur speichert Datums- und Uhrzeitinformationen in einem privaten DateTime Feld und die Anzahl der Minuten, um die sich dieses Datum und die Uhrzeit von UTC in einem privaten Int16 Feld 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 DateTime Struktur oder die DateTimeOffset Struktur beim Arbeiten mit Datums- und Uhrzeitwerten verwendet werden soll, finden Sie unter Auswählen zwischen DateTime, DateTimeOffset, TimeSpan und TimeZoneInfo.
Initialisieren eines DateTime-Objekts
Sie können einem neuen DateTime Wert auf viele verschiedene Arten einen Anfangswert zuweisen:
- Aufrufen eines Konstruktors, entweder eines, in dem Sie Argumente für Werte angeben, oder verwenden Sie den impliziten parameterlosen Konstruktor.
- Zuweisen eines
DateTimezum Rückgabewert einer Eigenschaft oder Methode. - Analysieren eines
DateTimeWerts aus seiner Zeichenfolgendarstellung. - Verwenden von Visual Basic-spezifischen Sprachfeatures zum Instanziieren von
DateTime.
Die folgenden Codeausschnitte zeigen Beispiele für jeden.
Aufrufen von Konstruktoren
Sie rufen eine der Überladungen des Konstruktors auf, die DateTime Elemente des Datums- und Uhrzeitwerts angeben (z. B. Das Jahr, den Monat und den Tag oder die Anzahl der Ticks). Der folgende Code erstellt ein bestimmtes Datum mithilfe des Konstruktors, der DateTime das Jahr, den Monat, den Tag, die Stunde, die Minute und die Sekunde angibt.
Dim date1 As New Date(2008, 5, 1, 8, 30, 52)
var date1 = new DateTime(2008, 5, 1, 8, 30, 52);
Console.WriteLine(date1);
let date1 = DateTime(2008, 5, 1, 8, 30, 52)
printfn $"{date1}"
Sie rufen den impliziten parameterlosen Konstruktor der DateTime Struktur auf, wenn Sie einen DateTime mit ihrem Standardwert initialisieren möchten. (Ausführliche Informationen zum impliziten parameterlosen Konstruktor eines Werttyps finden Sie unter Werttypen.) Einige Compiler unterstützen auch das Deklarieren eines DateTime Werts, ohne ihm explizit einen Wert zuzuweisen. Das Erstellen eines Werts ohne explizite Initialisierung führt auch zum Standardwert. Das folgende Beispiel veranschaulicht den DateTime impliziten parameterlosen Konstruktor in C# und Visual Basic sowie eine DateTime Deklaration 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));
let dat1 = DateTime()
// The following method call displays 1/1/0001 12:00:00 AM.
printfn $"{dat1.ToString System.Globalization.CultureInfo.InvariantCulture}"
// The following method call displays True.
printfn $"{dat1.Equals DateTime.MinValue}"
Zuweisen eines berechneten Werts
Sie können dem Objekt einen Datums- und Uhrzeitwert zuweisen, der DateTime von einer Eigenschaft oder Methode zurückgegeben wird. Im folgenden Beispiel werden das aktuelle Datum und die aktuelle Uhrzeit, das aktuelle Datum und die Uhrzeit der koordinierten 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;
let date1 = DateTime.Now
let date2 = DateTime.UtcNow
let date3 = DateTime.Today
Analysieren einer Zeichenfolge, die eine DateTime darstellt
Die ParseMethoden , ParseExact, TryParseund TryParseExact konvertieren eine 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 DateTime Wert zu konvertieren. Das zweite Format verwendet ein Formular, das von der ISO 8601-Norm unterstützt wird, um Datum und Uhrzeit im Zeichenfolgenformat darzustellen. 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);
let dateString = "5/1/2008 8:30:52 AM"
let date1 = DateTime.Parse(dateString, System.Globalization.CultureInfo.InvariantCulture)
let iso8601String = "20080501T08:30:52Z"
let dateISO8602 = DateTime.ParseExact(iso8601String, "yyyyMMddTHH:mm:ssZ", System.Globalization.CultureInfo.InvariantCulture)
Die TryParse Methoden und TryParseExact geben an, ob eine Zeichenfolge eine gültige Darstellung eines DateTime Werts ist, und führt die Konvertierung aus.
Sprachspezifische Syntax für Visual Basic
Die folgende Visual Basic-Anweisung initialisiert einen neuen DateTime Wert.
Dim date1 As Date = #5/1/2008 8:30:52AM#
DateTime-Werte und ihre Zeichenfolgendarstellungen
Intern werden alle DateTime Werte als Die Anzahl der Ticks (die Anzahl der Intervalle von 100 Nanosekunden) dargestellt, die seit 12:00:00 Uhr Mitternacht, 1. Januar 0001 verstrichen sind. Der tatsächliche DateTime Wert ist unabhängig von der Art und Weise, in der dieser Wert angezeigt wird, wenn er angezeigt wird. Die Darstellung eines DateTime Werts ist das Ergebnis eines Formatierungsvorgangs, der einen Wert in seine Zeichenfolgendarstellung konvertiert.
Die Darstellung von Datums- und Uhrzeitwerten hängt von kultur, 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 Standardmethode DateTime.ToString() gibt die Zeichenfolgendarstellung eines Datums- und Uhrzeitwerts unter Verwendung des Musters für kurzes Datum und lange Zeit der aktuellen Kultur zurück. Im folgenden Beispiel wird die Standardmethode DateTime.ToString() verwendet. Das Datum und die Uhrzeit werden unter Verwendung des Musters "Kurzes Datum" und "Lange Zeit" für die aktuelle Kultur angezeigt. Die en-US-Kultur 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
let date1 = DateTime(2008, 3, 1, 7, 0, 0)
printfn $"{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 Webszenarien zu unterstützen, in denen sich der Server möglicherweise in einer anderen Kultur als der Client befindet. Sie geben die Kultur mit der DateTime.ToString(IFormatProvider) -Methode an, um die Kurz- und Langzeitdarstellung in einer bestimmten Kultur zu erstellen. Im folgenden Beispiel wird die DateTime.ToString(IFormatProvider) -Methode verwendet, um das Datum und die Uhrzeit unter Verwendung des Musters für kurzes Datum und lange Zeit für die 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
let date1 = DateTime(2008, 3, 1, 7, 0, 0)
printfn $"""{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 Standard- oder benutzerdefinierten Formatbezeichner unter Verwendung der Formatierungskonventionen der aktuellen Kultur definiert wird. Im folgenden Beispiel wird die DateTime.ToString(String) -Methode verwendet, um das vollständige Datums- und Uhrzeitmuster für die en-US-Kultur anzuzeigen, 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("F"));
// Displays Saturday, March 01, 2008 7:00:00 AM
let date1 = DateTime(2008, 3, 1, 7, 0, 0)
printfn $"""{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 mit der -Methode sowohl die Kultur als auch das DateTime.ToString(String, IFormatProvider) Format angeben. Im folgenden Beispiel wird die DateTime.ToString(String, IFormatProvider) -Methode verwendet, um das vollständige Datums- und Uhrzeitmuster für die fr-FR-Kultur 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
let date1 = DateTime(2008, 3, 1, 7, 0, 0)
printfn $"""{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 eine Zeichenfolge mit dem ISO 8601-Standardformat formatiert wird, das häufig für Webdienste verwendet wird. Das Iso 8601-Format verfügt nicht über eine entsprechende Standardformatzeichenfolge.
var date1 = new DateTime(2008, 3, 1, 7, 0, 0, DateTimeKind.Utc);
Console.WriteLine(date1.ToString("yyyy-MM-ddTHH:mm:sszzz", System.Globalization.CultureInfo.InvariantCulture));
// Displays 2008-03-01T07:00:00+00:00
let date1 = DateTime(2008, 3, 1, 7, 0, 0, DateTimeKind.Utc)
printfn $"""{date1.ToString("yyyy-MM-ddTHH:mm:sszzz", System.Globalization.CultureInfo.InvariantCulture)}"""
// Displays 2008-03-01T07:00:00+00:00
Dim date1 As DateTime = New DateTime(2008, 3, 1, 7, 0, 0, DateTimeKind.Utc)
Console.WriteLine(date1.ToString("yyyy-MM-ddTHH:mm:sszzz", System.Globalization.CultureInfo.InvariantCulture))
' Displays 2008-03-01T07:00:00+00:00
Weitere Informationen zu Formatierungswerten DateTime finden Sie unter Standard-Datums- und Uhrzeitformatzeichenfolgen und benutzerdefinierte Datums- und Uhrzeitformatzeichenfolgen.
Analysieren von DateTime-Werten aus Zeichenfolgen
Die Analyse konvertiert die Zeichenfolgendarstellung eines Datums und einer Uhrzeit in einen DateTime Wert. In der Regel weisen Datums- und Uhrzeitzeichenfolgen zwei unterschiedliche Verwendungen in Anwendungen auf:
Ein Datum und eine Uhrzeit nehmen eine Vielzahl von Formen an 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, einen Datumswert als "15.12.2013" oder "15. Dezember 2013" einzugeben. Es ermöglicht einem Benutzer, dessen aktuelle Kultur en-gb ist, einen Datumswert als "15.12.2013" oder "15. Dezember 2013" einzugeben.
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. Für eine Anwendung kann die Eingabe von Datumsangaben im kurzen Datumsformat der aktuellen Kultur erforderlich sein.
Sie verwenden die Parse -Methode oder TryParse , um eine Zeichenfolge aus einem der gängigen Datums- und Uhrzeitformate einer Kultur in einen DateTime Wert zu konvertieren. Das folgende Beispiel zeigt, wie Sie Datumszeichenfolgen in verschiedenen kulturspezifischen Formaten in einen DateTime Wert konvertieren könnenTryParse. Es ändert die aktuelle Kultur in Englisch (Vereinigtes Königreich) und ruft die GetDateTimeFormats() -Methode auf, um ein Array von Datums- und Uhrzeitzeichenfolgen zu generieren. Anschließend wird jedes Element im Array an die TryParse -Methode übergeben. Die Ausgabe des Beispiels zeigt, dass die Analysemethode jede der kulturspezifischen Datums- und Uhrzeitzeichenfolgen 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.
System.Threading.Thread.CurrentThread.CurrentCulture <-
System.Globalization.CultureInfo.CreateSpecificCulture "en-GB"
let date1 = DateTime(2013, 6, 1, 12, 32, 30)
let badFormats = ResizeArray<String>()
printfn "%-37s %-19s\n" "Date String" "Date"
for dateString in date1.GetDateTimeFormats() do
match DateTime.TryParse dateString with
| true, parsedDate ->
printfn $"%-37s{dateString} %-19O{parsedDate}\n"
| _ ->
badFormats.Add dateString
// Display strings that could not be parsed.
if badFormats.Count > 0 then
printfn "\nStrings that could not be parsed: "
for badFormat in badFormats do
printfn $" {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 ParseExact Methoden und TryParseExact , um eine Zeichenfolge, die einem bestimmten Format oder format entsprechen muss, in einen DateTime Wert zu konvertieren. Sie geben mindestens eine Datums- und Uhrzeitformatzeichenfolge als Parameter für die Analysemethode an. Im folgenden Beispiel wird die TryParseExact(String, String[], IFormatProvider, DateTimeStyles, DateTime) -Methode verwendet, um Zeichenfolgen zu konvertieren, die entweder im Format "jjjjMMDdd" oder im Format "HHmmss" in DateTime Werte konvertiert werden müssen.
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
let formats = [| "yyyyMMdd"; "HHmmss" |]
let dateStrings =
[ "20130816"; "20131608"; " 20130816 "
"115216"; "521116"; " 115216 " ]
for dateString in dateStrings do
match DateTime.TryParseExact(dateString, formats, null,
System.Globalization.DateTimeStyles.AllowWhiteSpaces |||
System.Globalization.DateTimeStyles.AdjustToUniversal) with
| true, parsedDate ->
printfn $"{dateString} --> {parsedDate:g}"
| _ ->
printfn $"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 häufige Verwendung für ParseExact ist das Konvertieren einer Zeichenfolgendarstellung aus einem Webdienst, normalerweise im ISO 8601-Standardformat . Der folgende Code zeigt die richtige Formatzeichenfolge an, die verwendet werden soll:
var iso8601String = "20080501T08:30:52Z";
DateTime dateISO8602 = DateTime.ParseExact(iso8601String, "yyyyMMddTHH:mm:ssZ",
System.Globalization.CultureInfo.InvariantCulture);
Console.WriteLine($"{iso8601String} --> {dateISO8602:g}");
let iso8601String = "20080501T08:30:52Z"
let dateISO8602 = DateTime.ParseExact(iso8601String, "yyyyMMddTHH:mm:ssZ", System.Globalization.CultureInfo.InvariantCulture)
printfn $"{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ösen die Parse Methoden und ParseExact eine Ausnahme aus. Die TryParse Methoden und TryParseExact geben einen Boolean Wert zurück, der angibt, ob die Konvertierung erfolgreich war oder fehlgeschlagen ist. Sie sollten die TryParse -Methode oder TryParseExact in Szenarien verwenden, in denen die Leistung wichtig ist. Der Analysevorgang für Datums- und Uhrzeitzeichenfolgen weist in der Regel eine hohe Fehlerrate auf, und die Ausnahmebehandlung ist teuer. Verwenden Sie diese Methoden, wenn Zeichenfolgen von Benutzern eingegeben werden oder aus einer unbekannten Quelle stammen.
Weitere Informationen zum Analysieren von Datums- und Uhrzeitwerten finden Sie unter Analysieren von Datums- und Uhrzeitzeichenfolgen.
DateTime-Werte
Beschreibungen von Zeitwerten im DateTime Typ werden häufig mit dem UTC-Standard (Coordinated Universal Time) ausgedrückt. Coordinated Universal Time ist der international anerkannte Name für Greenwich Mean Time (GMT). Koordinierte Weltzeit ist die Zeit, die bei 0 Grad Längengrad gemessen wird, 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 in Stunden vom UTC-Ursprungspunkt. Darüber hinaus wird die Ortszeit optional von der Sommerzeit beeinflusst, die eine Zeitintervallanpassung hinzufügt oder subtrahiert. Die Ortszeit wird berechnet, indem der Zeitzonenoffset zu UTC hinzugefügt und bei Bedarf die Sommerzeit angepasst wird. Der Zeitzonenoffset am UTC-Ursprungspunkt ist 0.
Die UTC-Zeit eignet sich für Berechnungen, Vergleiche und das Speichern von Datums- und Uhrzeitdaten in Dateien. Die Ortszeit eignet sich für die Anzeige in Benutzeroberflächen von Desktopanwendungen. Zeitzonenfähige Anwendungen (z. B. viele Webanwendungen) müssen auch mit einer Reihe anderer Zeitzonen arbeiten.
Wenn die Kind -Eigenschaft eines DateTime -Objekts ist, ist DateTimeKind.Unspecifiednicht angegeben, ob die dargestellte Zeit die Ortszeit, UTC-Zeit oder eine Zeit in einer anderen Zeitzone ist.
DateTime-Auflösung
Hinweis
Alternativ zur Ausführung von Datums- und Uhrzeitarithmetik für DateTime Werte zum Messen der verstrichenen Zeit können Sie die Stopwatch -Klasse verwenden.
Die Ticks Eigenschaft drückt Datums- und Uhrzeitwerte in Einheiten von einer Zehnmillionstel Sekunde aus. Die Millisecond Eigenschaft gibt die Tausendstel sekunden in einem Datums- und Uhrzeitwert zurück. Die Verwendung wiederholter Aufrufe der DateTime.Now -Eigenschaft zum Messen verstrichener Zeit hängt von der Systemuhr ab. Die Systemuhr auf Windows 7- und Windows 8-Systemen hat eine Auflösung von etwa 15 Millisekunden. Diese Auflösung wirkt sich auf kleine Zeitintervalle unter 100 Millisekunden aus.
Das folgende Beispiel veranschaulicht die Abhängigkeit aktueller Datums- und Uhrzeitwerte von der Auflösung der Systemuhr. Im Beispiel wiederholt 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 Thread.Sleep Methode zu einer Verzögerung von fünf Millisekunden. Das folgende Beispiel zeigt die Anzahl der Millisekunden, die von den DateTime.Now.Milliseconds Eigenschaftenänderungen erst nach dem Aufruf Thread.Sleepvon zurückgegeben werden.
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.
let mutable output = ""
for i = 0 to 20 do
output <- output + $"{DateTime.Now.Millisecond}\n"
// Introduce a delay loop.
for _ = 0 to 1000 do ()
if i = 10 then
output <- output + "Thread.Sleep called...\n"
System.Threading.Thread.Sleep 5
printfn $"{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, die eine DateTime Struktur verwendet, z Add . B. oder Subtract, ändert den Wert der Struktur nicht. Stattdessen gibt die Berechnung eine neue DateTime Struktur zurück, deren Wert das Ergebnis der Berechnung ist.
Bei Konvertierungsvorgängen zwischen Zeitzonen (z. B. zwischen UTC und Ortszeit oder zwischen einer Zeitzone und einer anderen Zeitzone) wird die Sommerzeit berücksichtigt, arithmetische und Vergleichsvorgänge jedoch nicht.
Die DateTime Struktur selbst bietet nur eingeschränkte Unterstützung für die Konvertierung von einer Zeitzone in eine andere. Sie können die ToLocalTime Methode verwenden, um UTC in Ortszeit zu konvertieren, oder Sie können die Methode verwenden, um von der ToUniversalTime Lokalen Zeit in UTC zu konvertieren. In der TimeZoneInfo -Klasse ist jedoch ein vollständiger Satz von Zeitzonenkonvertierungsmethoden verfügbar. Mit diesen Methoden konvertieren Sie die Zeit in einer der Zeitzonen der Welt in die Zeit in jeder anderen Zeitzone.
Berechnungen und Vergleiche von DateTime Objekten sind nur dann sinnvoll, wenn die Objekte Zeiten in derselben Zeitzone darstellen. Sie können ein TimeZoneInfo -Objekt verwenden, um die Zeitzone eines DateTime Werts darzustellen, 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 eine DateTime UTC, Ortszeit oder nicht angegeben ist. In einer Zeitzonen-fähigen 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 DateTime Wert als auch das TimeZoneInfo Objekt umschließt, das die DateTime Zeitzone des Werts darstellt. Ausführliche Informationen zur Verwendung von UTC in Berechnungen und Vergleichen mit DateTime Werten finden Sie unter Ausführen von arithmetischen Vorgängen mit Datums- und Uhrzeitangaben.
Jedes DateTime Mitglied verwendet implizit den gregorianischen Kalender, um seinen Vorgang auszuführen. Ausnahmen sind Methoden, die implizit einen Kalender angeben. Dazu gehören Konstruktoren, die einen Kalender angeben, und Methoden mit einem von IFormatProviderabgeleiteten Parameter wie System.Globalization.DateTimeFormatInfo.
Vorgänge nach Mitgliedern des DateTime Typs berücksichtigen Details wie Schaltjahre und die Anzahl der Tage in einem Monat.
DateTime-Werte und -Kalender
Die .NET-Klassenbibliothek enthält eine Reihe von Kalenderklassen, die alle von der Calendar -Klasse abgeleitet werden. Sie lauten wie folgt:
- Die ChineseLunisolarCalendar-Klasse.
- Die EastAsianLunisolarCalendar-Klasse.
- Die GregorianCalendar-Klasse.
- Die HebrewCalendar-Klasse.
- Die HijriCalendar-Klasse.
- Die JapaneseCalendar-Klasse.
- Die JapaneseLunisolarCalendar-Klasse.
- Die JulianCalendar-Klasse.
- Die KoreanCalendar-Klasse.
- Die KoreanLunisolarCalendar-Klasse.
- Die PersianCalendar-Klasse.
- Die TaiwanCalendar-Klasse.
- Die TaiwanLunisolarCalendar-Klasse.
- Die ThaiBuddhistCalendar-Klasse.
- Die UmAlQuraCalendar-Klasse.
Wichtig
Die Zeitrechnung in japanischen Kalendern basiert auf den Regierungsperioden der Kaiser und wird sich daher erwartungsgemäß ändern. Beispiel: Der 1. Mai 2019 markiert den Beginn des Reiwa-Zeitabschnitts in den Kalendern des Typs JapaneseCalendar und JapaneseLunisolarCalendar. Eine derartige Änderung der Zeitabschnitte betrifft alle Anwendungen, die diese Kalender verwenden. Weitere Informationen und informationen zum Ermitteln, ob Ihre Anwendungen betroffen sind, finden Sie unter Behandeln einer neuen Ära im japanischen Kalender in .NET. Informationen zum Testen Ihrer Anwendungen auf Windows-Systemen, um ihre Bereitschaft für die Änderung der Ära sicherzustellen, finden Sie unter Vorbereiten der Anwendung für die Änderung der japanischen Ära. Features in .NET, die Kalender mit mehreren Epochen unterstützen, und bewährte Methoden für die Arbeit mit Kalendern, die mehrere Epochen unterstützen, finden Sie unter Arbeiten mit Epochen.
Jede Kultur verwendet einen Standardkalender, der durch die schreibgeschützte CultureInfo.Calendar Eigenschaft definiert wird. Jede Kultur unterstützt möglicherweise einen oder mehrere Kalender, die durch ihre schreibgeschützte CultureInfo.OptionalCalendars Eigenschaft definiert sind. Der Kalender, der derzeit von einem bestimmten CultureInfo Objekt verwendet wird, wird durch seine DateTimeFormatInfo.Calendar -Eigenschaft definiert. Es muss einer der Kalender sein, die CultureInfo.OptionalCalendars sich im Array befinden.
Der aktuelle Kalender einer Kultur wird in allen Formatierungsvorgängen für diese Kultur verwendet. Der Standardkalender der thailändischen buddhistischen Kultur ist beispielsweise der Kalender der thailändischen buddhistischen Ära, der durch die ThaiBuddhistCalendar Klasse dargestellt wird. Wenn ein CultureInfo Objekt, das die thailändische buddhistische Kultur darstellt, in einem Datums- und Uhrzeitformatierungsvorgang verwendet wird, wird standardmäßig der Kalender der thailändischen buddhistischen Ära verwendet. Der gregorianische Kalender wird nur verwendet, wenn die Eigenschaft der Kultur DateTimeFormatInfo.Calendar geändert wird, wie das folgende Beispiel zeigt:
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
let thTH = System.Globalization.CultureInfo "th-TH"
let value = DateTime(2016, 5, 28)
printfn $"{value.ToString thTH}"
thTH.DateTimeFormat.Calendar <- System.Globalization.GregorianCalendar()
printfn $"{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 das folgende Beispiel zeigt.
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
let thTH = System.Globalization.CultureInfo "th-TH"
let value = DateTime.Parse("28/05/2559", thTH)
printfn $"{value.ToString thTH}"
thTH.DateTimeFormat.Calendar <- System.Globalization.GregorianCalendar()
printfn $"{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 Tages) eines bestimmten Kalenders, indem Sie einen DateTime-Konstruktor aufrufen, der einen calendar Parameter enthält, und übergeben sie ein Calendar Objekt, 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
let thTH = System.Globalization.CultureInfo "th-TH"
let dat = DateTime(2559, 5, 28, thTH.DateTimeFormat.Calendar)
printfn $"""Thai Buddhist era date: {dat.ToString("d", thTH)}"""
printfn $"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 Parameter enthalten calendar , gehen davon aus, 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. Jedes DateTime Element, das den gregorianischen Kalender verwendet, verfügt über ein entsprechendes Element der Klasse, das Calendar einen bestimmten Kalender verwendet. Beispielsweise gibt die Calendar.GetYear -Methode 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 DateTime member als auch 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
let thTH = System.Globalization.CultureInfo "th-TH"
let cal = thTH.DateTimeFormat.Calendar
let dat = DateTime(2559, 5, 28, cal)
printfn "Using the Thai Buddhist Era calendar:"
printfn $"""Date: {dat.ToString("d", thTH)}"""
printfn $"Year: {cal.GetYear dat}"
printfn $"Leap year: {cal.IsLeapYear(cal.GetYear dat)}\n"
printfn "Using the Gregorian calendar:"
printfn $"Date: {dat:d}"
printfn $"Year: {dat.Year}"
printfn $"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. Es enthält kein Mitglied, mit dem Sie die Wochennummer des Jahres abrufen können. Um die Woche des Jahres abzurufen, rufen Sie die -Methode des einzelnen Kalenders Calendar.GetWeekOfYear auf. 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
let thTH = System.Globalization.CultureInfo "th-TH"
let thCalendar = thTH.DateTimeFormat.Calendar
let dat = DateTime(1395, 8, 18, thCalendar)
printfn "Using the Thai Buddhist Era calendar:"
printfn $"""Date: {dat.ToString("d", thTH)}"""
printfn $"Day of Week: {thCalendar.GetDayOfWeek dat}"
printfn $"Week of year: {thCalendar.GetWeekOfYear(dat, System.Globalization.CalendarWeekRule.FirstDay, DayOfWeek.Sunday)}\n"
let greg = System.Globalization.GregorianCalendar()
printfn "Using the Gregorian calendar:"
printfn $"Date: {dat:d}"
printfn $"Day of Week: {dat.DayOfWeek}"
printfn $"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 Werte auf folgende Weise beibehalten DateTime :
- Konvertieren Sie sie in Zeichenfolgen , und speichern Sie die Zeichenfolgen.
- Konvertieren Sie sie in 64-Bit-Ganzzahlwerte (den Wert der Ticks -Eigenschaft), und speichern Sie die ganzen Zahlen.
- Serialisieren Sie die DateTime-Werte.
Sie müssen sicherstellen, dass die Routine, mit der die DateTime Werte wiederhergestellt werden, unabhängig von der gewählten Technik keine Daten verliert oder eine Ausnahme auslöst. DateTime -Werte sollten einen Roundtrip ausführen. 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 den gleichen Zeitpunkt identifizieren, zu dem er wiederhergestellt wird.
Beibehalten von Werten als Zeichenfolgen
Führen Sie die folgenden Regeln aus, um Werte erfolgreich wiederherzustellen DateTime , die als Zeichenfolgen beibehalten werden:
Treffen Sie die gleichen Annahmen über kulturspezifische Formatierungen, wenn Sie die Zeichenfolge wiederherstellen, als wenn Sie sie beibehalten haben. 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()Überladungen , Parse(String)oder TryParse(String, DateTime) , die die Konventionen der aktuellen Kultur 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 in koordinierte Weltzeit (UTC), bevor Sie ihn speichern, oder verwenden Sie DateTimeOffset.
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 die aktuelle Kultur beim Speichern und Wiederherstellen der Zeichenfolgen anders ist. Im folgenden Beispiel werden diese Probleme veranschaulicht. Es speichert fünf Datumsangaben unter Verwendung der Formatierungskonventionen der aktuellen Kultur, die in diesem Fall Englisch (USA) ist. Die Datumsangaben werden mithilfe der Formatierungskonventionen einer anderen Kultur wiederhergestellt, die in diesem Fall Englisch (Vereinigtes Königreich) ist. 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 Momente 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...
let saveLocalDatesAsString () =
let dates =
[ DateTime(2014, 6, 14, 6, 32, 0)
DateTime(2014, 7, 10, 23, 49, 0)
DateTime(2015, 1, 10, 1, 16, 0)
DateTime(2014, 12, 20, 21, 45, 0)
DateTime(2014, 6, 2, 15, 14, 0) ]
printfn $"Current Time Zone: {TimeZoneInfo.Local.DisplayName}"
printfn $"The dates on an {Thread.CurrentThread.CurrentCulture.Name} system:"
let output =
[ for date in dates do
printfn $"{date}"
string date ]
|> String.concat "|"
use sw = new StreamWriter(filenameTxt)
sw.Write output
printfn "Saved dates..."
let restoreLocalDatesFromString () =
TimeZoneInfo.ClearCachedData()
printfn $"Current Time Zone: {TimeZoneInfo.Local.DisplayName}"
Thread.CurrentThread.CurrentCulture <- CultureInfo.CreateSpecificCulture "en-GB"
use sr = new StreamReader(filenameTxt)
let inputValues =
sr.ReadToEnd().Split('|', StringSplitOptions.RemoveEmptyEntries)
printfn $"The dates on an {Thread.CurrentThread.CurrentCulture.Name} system:"
for inputValue in inputValues do
match DateTime.TryParse inputValue with
| true, dateValue ->
printfn $"'{inputValue}' --> {dateValue:f}"
| _ ->
printfn $"Cannot parse '{inputValue}'"
printfn "Restored dates..."
let persistAsLocalStrings () =
saveLocalDatesAsString ()
restoreLocalDatesFromString ()
// 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 roundtripen DateTime :
- Wenn die Werte einzelne Zeitmomente darstellen, konvertieren Sie sie von der Ortszeit in UTC, indem Sie die ToUniversalTime -Methode aufrufen.
- Konvertieren Sie die Datumsangaben in ihre Zeichenfolgendarstellungen, indem Sie die - oder String.Format(IFormatProvider, String, Object[]) -ToString(String, IFormatProvider)Überladung aufrufen. Verwenden Sie die Formatierungskonventionen der invarianten Kultur, indem Sie als
providerArgument angebenCultureInfo.InvariantCulture. Geben Sie an, dass der Wert einen Roundtrip durchführen soll, indem Sie die Standardformatzeichenfolge "O" oder "R" verwenden.
Führen Sie die folgenden Schritte aus, um die persistenten DateTime Werte ohne Datenverlust wiederherzustellen:
- Analysieren Sie die Daten, indem Sie die ParseExact - oder TryParseExact -Überladung aufrufen. Geben Sie CultureInfo.InvariantCulture als
providerArgument an, und verwenden Sie dieselbe Standardformatzeichenfolge, die Sie bei der Konvertierung für dasformatArgument verwendet haben. Schließen Sie den DateTimeStyles.RoundtripKind Wert in dasstylesArgument ein. - Wenn die DateTime Werte einzelne Momente 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...
let saveDatesAsInvariantStrings () =
let dates =
[ DateTime(2014, 6, 14, 6, 32, 0)
DateTime(2014, 7, 10, 23, 49, 0)
DateTime(2015, 1, 10, 1, 16, 0)
DateTime(2014, 12, 20, 21, 45, 0)
DateTime(2014, 6, 2, 15, 14, 0) ]
printfn $"Current Time Zone: {TimeZoneInfo.Local.DisplayName}"
printfn $"The dates on an {Thread.CurrentThread.CurrentCulture.Name} system:"
let output =
[ for date in dates do
printfn $"{date:f}"
date.ToUniversalTime().ToString("O", CultureInfo.InvariantCulture) ]
|> String.concat "|"
use sw = new StreamWriter(filenameTxt)
sw.Write output
printfn "Saved dates..."
let restoreDatesAsInvariantStrings () =
TimeZoneInfo.ClearCachedData()
printfn $"Current Time Zone: {TimeZoneInfo.Local.DisplayName}"
Thread.CurrentThread.CurrentCulture <- CultureInfo.CreateSpecificCulture "en-GB"
use sr = new StreamReader(filenameTxt)
let inputValues =
sr.ReadToEnd().Split('|', StringSplitOptions.RemoveEmptyEntries)
printfn $"The dates on an {Thread.CurrentThread.CurrentCulture.Name} system:"
for inputValue in inputValues do
match DateTime.TryParseExact(inputValue, "O", CultureInfo.InvariantCulture, DateTimeStyles.RoundtripKind) with
| true, dateValue ->
printfn $"'{inputValue}' --> {dateValue.ToLocalTime():f}"
| _ ->
printfn $"Cannot parse '{inputValue}'"
printfn "Restored dates..."
let persistAsInvariantStrings () =
saveDatesAsInvariantStrings ()
restoreDatesAsInvariantStrings ()
// 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 Wert Int64 beibehalten, der eine Anzahl von Teilstrichen 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 Momente in der Zeit darstellen, konvertieren Sie sie in UTC, indem Sie die ToUniversalTime -Methode aufrufen.
- Rufen Sie die Anzahl der Durch den DateTime -Wert dargestellten Teilstriche aus seiner Ticks -Eigenschaft ab.
So stellen Sie einen DateTime Wert wieder her, der als ganze Zahl beibehalten wurde:
- Instanziieren Sie ein neues DateTime Objekt, indem Sie den Int64 Wert an den DateTime(Int64) Konstruktor übergeben.
- 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 "US Pacific" beibehalten. Es wird auf einem System in der UTC-Zone wiederhergestellt. Die Datei, die die ganzen Zahlen enthält, enthält einen Int32 Wert, der die Gesamtanzahl der Int64 Werte angibt, 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...
let saveDatesAsInts () =
let dates =
[ DateTime(2014, 6, 14, 6, 32, 0)
DateTime(2014, 7, 10, 23, 49, 0)
DateTime(2015, 1, 10, 1, 16, 0)
DateTime(2014, 12, 20, 21, 45, 0)
DateTime(2014, 6, 2, 15, 14, 0) ]
printfn $"Current Time Zone: {TimeZoneInfo.Local.DisplayName}"
printfn $"The dates on an {Thread.CurrentThread.CurrentCulture.Name} system:"
let ticks =
[| for date in dates do
printfn $"{date:f}"
date.ToUniversalTime().Ticks |]
use fs = new FileStream(filenameInts, FileMode.Create)
use bw = new BinaryWriter(fs)
bw.Write ticks.Length
for tick in ticks do
bw.Write tick
printfn "Saved dates..."
let restoreDatesAsInts () =
TimeZoneInfo.ClearCachedData()
printfn $"Current Time Zone: {TimeZoneInfo.Local.DisplayName}"
Thread.CurrentThread.CurrentCulture <- CultureInfo.CreateSpecificCulture "en-GB"
use fs = new FileStream(filenameInts, FileMode.Open)
use br = new BinaryReader(fs)
try
let items = br.ReadInt32()
let dates =
[| for _ in 0..items do
let ticks = br.ReadInt64()
DateTime(ticks).ToLocalTime() |]
printfn $"The dates on an {Thread.CurrentThread.CurrentCulture.Name} system:"
for value in dates do
printfn $"{value:f}"
with
| :? EndOfStreamException ->
printfn "File corruption detected. Unable to restore data..."
| :? IOException ->
printfn "Unspecified I/O error. Unable to restore data..."
// Thrown during array initialization.
| :? OutOfMemoryException ->
printfn"File corruption detected. Unable to restore data..."
printfn "Restored dates..."
let persistAsIntegers () =
saveDatesAsInts ()
restoreDatesAsInts ()
// 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 Werte durch Serialisierung in einem Stream oder einer Datei beibehalten DateTime und dann durch Deserialisierung wiederherstellen. DateTime Daten werden in einem bestimmten Objektformat serialisiert. Die Objekte werden wiederhergestellt, wenn sie deserialisiert werden. Ein Formatierer oder Serialisierer, z JsonSerializer . B. oder XmlSerializer, verarbeitet den Serialisierungs- und Deserialisierungsprozess. Weitere Informationen zur Serialisierung und zu den von .NET 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 einundzwanzigsten Jahrhundert dar. Die Ausgabe stellt das Ergebnis dar, wenn das Beispiel auf einem System ausgeführt wird, dessen aktuelle Kultur Englisch (Vereinigtes Königreich) ist. Da Sie das DateTime Objekt selbst deserialisiert 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;
if (deserializedDates is not null)
{
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
let persistAsXML () =
// Serialize the data.
let leapYears =
[| for year in 2000..4..2100 do
if DateTime.IsLeapYear year then
DateTime(year, 2, 29) |]
let serializer = XmlSerializer(leapYears.GetType())
use sw = new StreamWriter(filenameXml)
try
serializer.Serialize(sw, leapYears)
with :? InvalidOperationException as e ->
printfn $"{e.InnerException.Message}"
// Deserialize the data.
use fs = new FileStream(filenameXml, FileMode.Open)
let deserializedDates = serializer.Deserialize fs :?> DateTime []
// Display the dates.
printfn $"Leap year days from 2000-2100 on an {Thread.CurrentThread.CurrentCulture.Name} system:"
let mutable nItems = 0
for dat in deserializedDates do
printf $" {dat:d} "
nItems <- nItems + 1
if nItems % 5 = 0 then
printfn ""
// 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
Das vorherige Beispiel enthält keine Zeitinformationen. Wenn ein DateTime Wert einen Zeitpunkt darstellt und als Ortszeit ausgedrückt wird, konvertieren Sie ihn von ortszeit in UTC, bevor Sie ihn durch Aufrufen der ToUniversalTime -Methode serialisieren. Nachdem Sie sie deserialisiert haben, konvertieren Sie sie von UTC in Ortszeit, indem Sie die ToLocalTime -Methode aufrufen.
DateTime im Vergleich zu TimeSpan
Die DateTime Werttypen und TimeSpan unterscheiden sich darin, dass ein DateTime einen Zeitpunkt darstellt, während ein TimeSpan ein zeitintervall darstellt. Sie können eine instance von DateTime einer anderen subtrahieren, um ein TimeSpan Objekt zu erhalten, das das Zeitintervall zwischen ihnen darstellt. Alternativ können Sie dem aktuellen DateTime ein Positives TimeSpan hinzufügen, um einen DateTime Wert zu erhalten, der ein zukünftiges Datum darstellt.
Sie können einem Objekt ein Zeitintervall DateTime hinzufügen oder subtrahieren. Zeitintervalle können negativ oder positiv sein, und sie können in Einheiten wie Ticks, Sekunden oder als TimeSpan Objekt ausgedrückt werden.
Vergleichen auf Gleichheit innerhalb der Toleranz
Gleichheitsvergleiche für DateTime Werte sind exakt. Das bedeutet, dass zwei Werte als die gleiche Anzahl von Teilstrichen ausgedrückt werden müssen, die als gleich angesehen werden sollen. Diese Genauigkeit ist für viele Anwendungen oft 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 gleichwertige DateTime Werte verglichen werden. Es akzeptiert eine kleine Differenz, wenn sie als gleich deklariert wird.
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
let roughlyEquals (time: DateTime) (timeWithWindow: DateTime) windowInSeconds frequencyInSeconds =
let delta =
int64 (timeWithWindow - time).TotalSeconds % frequencyInSeconds
let delta = if delta > windowInSeconds then frequencyInSeconds - delta else delta
abs delta < windowInSeconds
let testRoughlyEquals () =
let window = 10
let window' = 10.
let freq = 60 * 60 * 2 // 2 hours
let d1 = DateTime.Now
let d2 = d1.AddSeconds(2. * window')
let d3 = d1.AddSeconds(-2. * window')
let d4 = d1.AddSeconds(window' / 2.)
let d5 = d1.AddSeconds(-window' / 2.)
let d6 = (d1.AddHours 2).AddSeconds(2. * window')
let d7 = (d1.AddHours 2).AddSeconds(-2. * window')
let d8 = (d1.AddHours 2).AddSeconds(window' / 2.)
let d9 = (d1.AddHours 2).AddSeconds(-window' / 2.)
printfn $"d1 ({d1}) ~= d1 ({d1}): {roughlyEquals d1 d1 window freq}"
printfn $"d1 ({d1}) ~= d2 ({d2}): {roughlyEquals d1 d2 window freq}"
printfn $"d1 ({d1}) ~= d3 ({d3}): {roughlyEquals d1 d3 window freq}"
printfn $"d1 ({d1}) ~= d4 ({d4}): {roughlyEquals d1 d4 window freq}"
printfn $"d1 ({d1}) ~= d5 ({d5}): {roughlyEquals d1 d5 window freq}"
printfn $"d1 ({d1}) ~= d6 ({d6}): {roughlyEquals d1 d6 window freq}"
printfn $"d1 ({d1}) ~= d7 ({d7}): {roughlyEquals d1 d7 window freq}"
printfn $"d1 ({d1}) ~= d8 ({d8}): {roughlyEquals d1 d8 window freq}"
printfn $"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 zur COM-Interop
Ein DateTime Wert, der in eine COM-Anwendung übertragen wird und dann wieder an eine verwaltete Anwendung übertragen wird, wird als Roundtrip bezeichnet. Ein DateTime Wert, der nur eine Zeit angibt, führt jedoch nicht wie erwartet einen Roundtrip durch.
Wenn Sie nur eine Hin- und Rückfahrt ausführen, z. B. um 15 Uhr, ist das Enddatum und die Endzeit der 30. Dezember 1899 c.E. um 15:00 Uhr anstatt am 1. Januar 0001 C.E. um 15:00 Uhr C.E. Die .NET Framework und COM gehen von einem Standarddatum aus, wenn nur eine Uhrzeit angegeben wird. Das COM-System geht jedoch von einem Basisdatum vom 30. Dezember 1899 C.E. aus, während die .NET Framework von einem Basisdatum des 1. Januar 0001 c.E.
Wenn nur eine Zeit vom .NET Framework an COM übergeben wird, wird eine spezielle Verarbeitung durchgeführt, die die Zeit in das von COM verwendete Format konvertiert. Wenn nur eine Zeit von COM an den .NET Framework übergeben wird, wird keine besondere Verarbeitung durchgeführt, da dadurch legitime Datums- und Uhrzeitangaben am oder vor dem 30. Dezember 1899 beschädigt würden. Wenn ein Datum seinen Roundtrip von COM beginnt, behalten die .NET Framework und COM das Datum bei.
Das Verhalten der .NET Framework und COM bedeutet, dass ihre Anwendung, wenn ihre Anwendung roundtrips nur DateTime einen Zeitpunkt angibt, daran denken muss, das fehlerhafte Datum aus dem endgültigen DateTime Objekt zu ändern oder zu ignorieren.
Konstruktoren
| DateTime(DateOnly, TimeOnly) |
Initialisiert eine neue instance der DateTime -Struktur für die angegebenen DateOnly und TimeOnly. Die neue instance wird die Unspecified Art haben. |
| DateTime(DateOnly, TimeOnly, DateTimeKind) |
Initialisiert eine neue instance der DateTime -Struktur für die angegebene DateOnly und TimeOnly und unter Berücksichtigung des angegebenen DateTimeKind. |
| 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(Int32, 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, Millisekunde und koordinierte Weltzeit (Coordinated Universal Time, UTC) oder Ortszeit für den angegebenen Kalender. |
| DateTime(Int32, 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, Millisekunde und koordinierte Weltzeit (Coordinated Universal Time, UTC) oder Ortszeit für den angegebenen Kalender. |
| DateTime(Int32, 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, 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 für den angegebenen Kalender. |
| 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. |
| Microsecond |
Die Mikrosekundenkomponente, ausgedrückt als Wert zwischen 0 und 999. |
| 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. |
| Nanosecond |
Die Nanosekundenkomponente, ausgedrückt als Wert zwischen 0 und 900 (in Schritten von 100 Nanosekunden). |
| 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. |
| AddMicroseconds(Double) |
Gibt eine neue DateTime zurück, die dem Wert dieses instance die angegebene Anzahl von Mikrosekunden hinzufügt. |
| 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. |
| Deconstruct(DateOnly, TimeOnly) |
Dekonstruiert diese DateTime instance nach DateOnly und TimeOnly. |
| Deconstruct(Int32, Int32, Int32) |
Dekonstruiert dieses DateOnly instance durch Year, Monthund Day. |
| 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 Datums- und Uhrzeitwert aufweisen. |
| 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() | |
| 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) |
Analysiert eine Spanne von Zeichen in einen Wert. |
| 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 eines Datums und einer Uhrzeit unter Verwendung der Konventionen der aktuellen Kultur in DateTime seine Entsprechung. |
| 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<Byte>, Int32, ReadOnlySpan<Char>, IFormatProvider) |
Versucht, den Wert des aktuellen instance als UTF-8 in die angegebene Bytesspanne zu formatieren. |
| 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, DateTime) |
Versucht, eine Spanne von Zeichen in einen Wert zu analysieren. |
| 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, DateTime) |
Versucht, eine Zeichenfolge in einen Wert zu analysieren. |
| 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 instance Zustand zu ändern scheinen, geben tatsächlich eine neue instance 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 instance dieses Typs enthält, durch eine Sperre geschützt werden, um die Threadsicherheit zu gewährleisten.
Weitere Informationen
- DateTimeOffset
- TimeSpan
- Calendar
- GetUtcOffset(DateTime)
- TimeZoneInfo
- Auswählen zwischen „DateTime“, „DateTimeOffset“, „TimeSpan“ und „TimeZoneInfo“
- Arbeiten mit Kalendern
- Beispiel: .NET Core-Hilfsprogramm zur Formatierung von WinForms (C#)
- Beispiel: .NET Core-Hilfsprogramm zur Formatierung von WinForms (Visual Basic)
Feedback
Feedback senden und anzeigen für