1 von 2 fanden dies hilfreich - Dieses Thema bewerten.

DateTime-Struktur

Aktualisiert: Juli 2008

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

Namespace:  System
Assembly:  mscorlib (in mscorlib.dll)
[SerializableAttribute]
public struct DateTime : IComparable, IFormattable, 
	IConvertible, ISerializable, IComparable<DateTime>, IEquatable<DateTime>
/** @attribute SerializableAttribute */ 
public final class DateTime extends ValueType implements IComparable, 
	IFormattable, IConvertible, ISerializable, IComparable<DateTime>, 
	IEquatable<DateTime>
JScript unterstützt die Verwendung von Strukturen, aber nicht die Deklaration von neuen Strukturen.

Ein DateTime-Wert stellt Angaben über Datum und Uhrzeit vom 1. Januar 0001, 00:00:00 u. Z. (unserer Zeitrechnung) bis zum 31. Dezember 9999, 23:59:59 u. Z. dar.

Zeitwerte werden in Einheiten von 100 Nanosekunden gemessen, die als Ticks bezeichnet werden. Ein bestimmtes Datum ist die Anzahl Ticks seit dem 1. Januar 0001, 00:00:00 u. Z. nach dem GregorianCalendar-Kalender. Ein Tickswert von 31241376000000000 stellt z. B. Freitag, den 1. Januar 0100, 00:00:00 dar. Ein DateTime-Wert bezieht sich immer auf den Kontext eines expliziten Kalenders oder eines Standardkalenders.

Instanziieren eines DateTime-Objekts

Sie verfügen über folgende Möglichkeiten, um einen neuen DateTime-Wert zu erstellen:

  • Durch das Aufrufen einer der Überladungen des DateTime-Konstruktors, die das Angeben spezifischer Elemente des Datums- und Uhrzeitwerts (wie Jahr, Monat und Tag oder Anzahl der Ticks) ermöglichen. Die folgende Anweisung veranschaulicht einen Aufruf eines der DateTime-Konstruktoren, um ein Datum mit den spezifischen Angaben für Jahr, Monat, Tag, Stunde, Minute und Sekunde zu erstellen.

    DateTime date1 = new DateTime(2008, 5, 1, 8, 30, 52);
    
    
    
  • Durch das Verwenden einer compilerspezifischen Syntax zum Deklarieren von Datums- und Uhrzeitwerten. Durch die folgende Visual Basic-Anweisung wird z. B. ein neuer DateTime-Wert initialisiert.

    Dim date1 As Date = #5/1/2008 8:30:52AM#
    
    
    
  • Durch das Zuweisen eines Datums- und Uhrzeitwerts zum DateTime-Objekt, der von einer Eigenschaft oder einer Methode zurückgegeben wurde. Im folgenden Beispiel werden drei neuen DateTime-Variablen das aktuelle Datum und die aktuelle Uhrzeit, die aktuellen UTC-Werte (Coordinated Universal Time) für Datum und Uhrzeit sowie das aktuelle Datum zugewiesen.

    DateTime date1 = DateTime.Now;
    DateTime date2 = DateTime.UtcNow;
    DateTime date3 = DateTime.Today;
    
    
    
  • Durch das Analysieren der Zeichenfolgendarstellung eines Datums- und Uhrzeitwerts. Die Methoden Parse, ParseExact, TryParse und TryParseExact konvertieren eine Zeichenfolge in ihren entsprechenden Datums- und Uhrzeitwert. Im folgenden Beispiel wird mit der Parse-Methode eine Zeichenfolge analysiert und in einen DateTime-Wert konvertiert.

    string dateString = "5/1/2008 8:30:52 AM";
    DateTime date1 = DateTime.Parse(dateString, CultureInfo.InvariantCulture); 
    
    
    
  • Durch das Aufrufen des impliziten Standardkonstruktors der DateTime-Struktur. (Einzelheiten zum impliziten Standardkonstruktor eines Werttyps finden Sie unter Werttypen (C#-Referenz).) Eine ungefähre Entsprechung für Compiler, die dies unterstützen, deklariert einen DateTime-Wert, ohne dass diesem explizit ein Datums- und Uhrzeitwert zugewiesen wird. Im folgenden Beispiel werden ein Aufruf des impliziten DateTime-Standardkonstruktors in C# und Visual Basic sowie eine DateTime-Variablendeklaration ohne Zuweisung in Visual Basic veranschaulicht.

    DateTime dat1 = new DateTime();
    // The following method call displays 1/1/0001 12:00:00 AM.
    Console.WriteLine(dat1.ToString(CultureInfo.InvariantCulture));
    // The following method call displays True.
    Console.WriteLine(dat1.Equals(DateTime.MinValue));
    
    
    

DateTime-Werte und ihre Zeichenfolgendarstellungen

Intern werden alle DateTime-Werte als Anzahl der Ticks (d. h. Anzahl der Intervalle von 100 Nanosekunden) dargestellt, die seit 12:00:00 Mitternacht, 1. Januar 0001 verstrichen sind. Der tatsächliche DateTime-Wert ist unabhängig von der Art der Darstellung dieses Werts bei der Anzeige in einem Benutzeroberflächenelement oder bei der Ausgabe in eine Datei. Die Darstellung eines DateTime-Werts ist das Ergebnis eines Formatierungsvorgangs. Beim Formatieren wird ein Wert in seine Zeichenfolgendarstellung konvertiert.

Da die Darstellung von Datum und Uhrzeit von Faktoren wie der Kultur, internationalen Standards, Anwendungsanforderungen und persönlichen Einstellungen abhängt, bietet die DateTime-Struktur beim Formatieren von Datums- und Uhrzeitwerten mit den Überladungen ihrer ToString-Methode ein hohes Maß an Flexibilität. Die standardmäßige DateTime.ToString()-Methode gibt die Zeichenfolgendarstellung eines Datums- und Uhrzeitwerts mit dem Datum im Kurzformat und der Uhrzeit im Langformat der aktuellen Kultur zurück. Im folgenden Beispiel werden mit der standardmäßigen DateTime.ToString()-Methode Datum und Uhrzeit im kurzen Datumsformat und im langen Uhrzeitformat für die Kultur en-US angezeigt, der aktuellen Kultur auf dem Computer, auf dem das Beispiel ausgeführt wurde.

DateTime 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


Die DateTime.ToString(IFormatProvider)-Methode gibt die Zeichenfolgendarstellung eines Datums- und Uhrzeitwerts mit dem kurzen Datumsformat und dem langen Uhrzeitformat einer bestimmten Kultur zurück. Im folgenden Beispiel werden mit der DateTime.ToString(IFormatProvider)-Methode Datum und Uhrzeit mit dem kurzen Datumsformat und dem langen Uhrzeitformat für die Kultur fr-FR angezeigt.

DateTime date1 = new DateTime(2008, 3, 1, 7, 0, 0);
Console.WriteLine(date1.ToString(CultureInfo.CreateSpecificCulture("fr-FR")));
// Displays 01/03/2008 07:00:00


Die DateTime.ToString(String)-Methode gibt die Zeichenfolgendarstellung des Datums und der Uhrzeit in einem Format zurück, das von einem standardmäßigen oder benutzerdefinierten Formatbezeichner und mithilfe der Formatierungskonventionen der aktuellen Kultur definiert wird. Im folgenden Beispiel wird mit der DateTime.ToString(String)-Methode das vollständige Datums- und Uhrzeitmuster für die Kultur en-US angezeigt, der aktuellen Kultur auf dem Computer, auf dem das Beispiel ausgeführt wurde.

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


Die DateTime.ToString(String, IFormatProvider)-Methode gibt die Zeichenfolgendarstellung des Datums und der Uhrzeit in einem Format zurück, das von einem spezifischen Formatbezeichner und mithilfe der Formatierungskonventionen einer spezifischen Kultur definiert wird. Im folgenden Beispiel wird mit der DateTime.ToString(String, IFormatProvider)-Methode das vollständige Datums- und Uhrzeitmuster für die Kultur fr-FR angezeigt.

DateTime date1 = new DateTime(2008, 3, 1, 7, 0, 0);
Console.WriteLine(date1.ToString("F", new CultureInfo("fr-FR")));
// Displays samedi 1 mars 2008 07:00:00


Versionsaspekte

Vor .NET Framework, Version 2.0, enthält die DateTime-Struktur ein 64-Bit-Feld, das aus einem nicht verwendeten 2-Bit-Feld und einem privaten Ticks-Feld zusammengesetzt ist. Letzteres ist ein 62-Bit-Feld ohne Vorzeichen, das die Anzahl von Ticks zum Darstellen des Datums und der Uhrzeit enthält. Der Wert des Ticks-Felds kann mit der Ticks-Eigenschaft abgerufen werden.

Ab .NET Framework 2.0 enthält die DateTime-Struktur ein 64-Bit-Feld, das aus einem privaten Kind-Feld und dem Ticks-Feld zusammengesetzt ist. Das Kind-Feld ist ein 2-Bit-Feld, das angibt, ob die DateTime-Struktur eine Ortszeit, eine UTC-Zeit (Coordinated Universal Time) oder die Zeit in einer nicht angegebenen Zeitzone darstellt. Das Kind-Feld wird verwendet, um Konvertierungen zwischen Zeitzonen auszuführen, nicht jedoch für Vergleichs- und Arithmetikoperationen mit Zeitwerten. Der Wert des Kind-Felds kann mit der Kind-Eigenschaft abgerufen werden.

03ybds8y.alert_note(de-de,VS.90).gif Hinweis:

Eine Alternative zur DateTime-Struktur zum Arbeiten mit Datums- und Zeitwerten in bestimmten Zeitzonen ist die DateTimeOffset-Struktur. Die DateTimeOffset-Struktur speichert Datums- und Zeitinformationen in einem privaten DateTime-Feld sowie die Anzahl der Minuten, um die ein Datum und eine Uhrzeit von UTC abweicht, in einem privaten Int16-Feld. So kann ein DateTimeOffset-Wert die Zeit in einer bestimmten Zeitzone darstellen, während ein DateTime-Wert nur UTC und die Zeit der lokalen Zeitzone eindeutig darstellen kann. Eine Beschreibung der Fälle, in denen die DateTime-Struktur bzw. die DateTimeOffset-Struktur beim Arbeiten mit Datums- und Zeitwerten verwendet wird, finden Sie unter Auswählen zwischen "DateTime", "DateTimeOffset" und "TimeZoneInfo".

DateTime-Werte

Beschreibungen der Zeitwerte im DateTime-Typ werden oft mithilfe des Standards der koordinierten Weltzeit (Coordinated Universal Time, UTC) ausgedrückt. Dies ist der international anerkannte Name für Greenwich Mean Time (GMT). Koordinierte Weltzeit ist die auf dem Längengrad 0, dem UTC-Ursprungspunkt, gemessene Zeit. Sommerzeit wird bei UTC nicht berücksichtigt.

Die lokale Zeit ist relativ zu einer bestimmten Zeitzone. Eine Zeitzone ist einem Zeitzonenoffset zugeordnet, der den Versatz der Zeitzone in Stunden vom UTC-Ursprungspunkt angibt. Zusätzlich wird bei der lokalen Zeit optional die Sommerzeit berücksichtigt, wodurch von der Dauer eines Tages eine Stunde abgezogen oder zu dieser hinzuaddiert wird. Folglich wird die lokale Zeit durch Addieren des Zeitzonenoffsets zu UTC und ggf. Berücksichtigen der Sommerzeit berechnet. Der Zeitzonenoffset am UTC-Ursprungspunkt ist 0 (null).

Die UTC-Zeit ist für Berechnungen, Vergleiche und das Speichern von Datums- und Zeitangaben in Dateien geeignet. Die Ortszeit ist für die Anzeige in Benutzeroberflächen von Desktopanwendungen geeignet. Anwendungen, die Zeitzonen unterstützen (z. B. viele Webanwendungen), müssen darüber hinaus mit einer Anzahl von anderen Zeitzonen arbeiten.

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

DateTime-Operationen

Durch Berechnungen mit einer DateTime-Struktur, z. B. Add oder Subtract wird der Wert der Struktur nicht geändert. Die Berechnung gibt hingegen eine neue DateTime-Struktur zurück, deren Wert das Ergebnis der Berechnung ist.

Bei Konvertierungsoperationen zwischen Zeitzonen (z. B. zwischen UTC-Zeit und Ortszeit oder zwischen zwei Zeitzonen) wird die Sommerzeit berücksichtigt, bei arithmetischen und Vergleichsoperationen hingegen nicht.

Die DateTime-Struktur selbst verfügt über eine begrenzte Unterstützung für das Konvertieren zwischen Zeitzonen. Sie können mit der ToLocalTime-Methode UTC in Ortszeit konvertieren oder mit der ToUniversalTime-Methode eine Konvertierung von der Ortszeit in UTC durchführen. Der vollständige Satz der Konvertierungsmethoden für Zeitzonen ist jedoch in der TimeZoneInfo-Klasse verfügbar. Mit diesen Methoden können Sie die Zeit in einer beliebigen Zeitzone in die Zeit einer beliebigen anderen Zeitzone konvertieren.

Berechnungen und Vergleiche von DateTime-Objekten sind nur dann sinnvoll, wenn die Objekte Zeitangaben in der gleichen Zeitzone darstellen. Sie können mit einem TimeZoneInfo-Objekt die Zeitzone eines DateTime-Werts darstellen, auch wenn diese lose verknüpft sind. (Das heißt, ein DateTime-Objekt verfügt über keine Eigenschaft, die ein Objekt zurückgibt, das eine andere Zeitzone für den betreffenden Datums- und Zeitwert als die Kind-Eigenschaft darstellt.) Aus diesem Grund müssen Sie sich in einer Anwendung, die Zeitzonen erkennt, auf einen externen Mechanismus stützen, um die Zeitzone zu bestimmen, in der ein DateTime-Objekt erstellt wurde. Sie können z. B. eine Struktur verwenden, die den DateTime-Wert und das TimeZoneInfo-Objekt umschließt, das die Zeitzone des DateTime-Werts darstellt. Einzelheiten zum Verwenden von UTC in Berechnungen und Vergleichen mit DateTime-Werten finden Sie unter Durchführen arithmetischer Datums- und Uhrzeitoperationen.

Alle DateTime-Member verwenden implizit den gregorianischen Kalender für Operationen. Ausnahmen hierbei sind Konstruktoren, die einen Kalender angeben, und Methoden mit einem von IFormatProvider abgeleiteten Parameter, z. B. System.Globalization.DateTimeFormatInfo, durch den implizit ein Kalender angegeben wird.

Operation durch Member des DateTime-Typs berücksichtigen Einzelheiten wie Schaltjahre und die Anzahl der Tage eines Monats.

DateTime und TimeSpan

Die Werttypen DateTime und TimeSpan unterscheiden sich darin, dass DateTime einen Zeitpunkt und TimeSpan ein Zeitintervall darstellt. Dies bedeutet z. B., dass Sie eine Instanz von DateTime von einer anderen subtrahieren können, um ein TimeSpan-Objekt zu erhalten, dass das zwischen ihnen liegende Zeitintervall darstellt. Sie können auch eine positive TimeSpan zur aktuellen DateTime addieren, um einen DateTime-Wert zu erhalten, der ein Datum in der Zukunft darstellt.

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

COM-Interop-Überlegungen

Ein DateTime-Wert, der an eine COM-Anwendung übertragen wird, wird dann im so genannten Round-Trip zurück an die verwaltete Anwendung übertragen. Ein DateTime-Wert, der nur eine Zeit angibt, verhält sich im Round-Trip hingegen nicht wie erwartet.

Beim Round-Trip einer Zeitangabe, z. B. 15 Uhr, ist das endgültige Datum der 30. Dezember 1899 u. Z. um 15 Uhr und nicht der 1. Januar 0001 u. Z. um 15 Uhr. Dies liegt daran, dass .NET Framework und COM nur ein Standarddatum annehmen, wenn nur eine Uhrzeit angegeben wird. Das COM-System nimmt allerdings als Basisdatum den 30. Dezember 1899 u. Z. an, wohingegen .NET Framework als Basisdatum den 1. Januar 0001 u. Z. annimmt.

Wenn von .NET Framework an COM nur eine Zeit übergeben wird, wird eine besondere Verarbeitung ausgeführt, bei die Zeit in das von COM verwendete Format konvertiert wird. Wenn von COM an .NET Framework nur eine Zeit übergeben wird, wird keine besondere Verarbeitung ausgeführt, weil diese korrekte Datums- und Zeitangaben am und vor dem 30. Dezember 1899 beschädigen würde. Dies bedeutet, dass bei einem Beginn des Round-Trips auf COM-Seite .NET Framework und COM das Datum beibehalten.

Das Verhalten von .NET Framework und COM bedeutet, dass bei einem Round-Trip einer DateTime in der Anwendung, mit der nur eine Zeit angegeben wird, die Anwendung die Aufgabe hat, falsche Datumsangaben im letztgültigen DateTime-Objekt zu ändern oder zu ignorieren.

Implementierte Schnittstellen

Dieser Typ implementiert die Schnittstellen IComparable, IComparable<T>, IFormattable und IConvertible. Verwenden Sie für Konvertierungen die Convert-Klasse anstelle der expliziten Implementierung der Schnittstellenmember der IConvertible-Schnittstelle für diesen Typ.

Im folgenden Codebeispiel wird der grobe Vergleich äquivalenter DateTime-Werte veranschaulicht, wobei ein geringer Unterschied für die Bestimmung als gleich zulässig ist.

using System;

class DateTimeTester {

	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 Main() 
	{
            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 [true]: " + RoughlyEquals(d1, d1, window, freq));
            Console.WriteLine("d1 ~= d2 [false]: " + RoughlyEquals(d1, d2, window, freq));
            Console.WriteLine("d1 ~= d3 [false]: " + RoughlyEquals(d1, d3, window, freq));
            Console.WriteLine("d1 ~= d4 [true]: " + RoughlyEquals(d1, d4, window, freq));
            Console.WriteLine("d1 ~= d5 [true]: " + RoughlyEquals(d1, d5, window, freq));

            Console.WriteLine("d1 ~= d6 [false]: " + RoughlyEquals(d1, d6, window, freq));
            Console.WriteLine("d1 ~= d7 [false]: " + RoughlyEquals(d1, d7, window, freq));
            Console.WriteLine("d1 ~= d8 [true]: " + RoughlyEquals(d1, d8, window, freq));
            Console.WriteLine("d1 ~= d9 [true]: " + RoughlyEquals(d1, d9, window, freq));


	}
}


class DateTimeTester
{
    public static boolean RoughlyEquals(DateTime time, 
        DateTime timeWithWindow, int windowInSeconds, int frequencyInSeconds)
    {
        long delta = (long)((TimeSpan)timeWithWindow.Subtract(time)).
            get_TotalSeconds() % frequencyInSeconds;
        delta = delta > windowInSeconds ? frequencyInSeconds - delta : delta;
        return (System.Convert.ToBoolean(System.Math.Abs(delta) 
            < windowInSeconds));
    } //RoughlyEquals

    public static void main(String[] args)
    {
        int window = 10;
        int freq = 60 * 60 * 2; // 2 hours;
        DateTime d1 = DateTime.get_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 [true]: " 
            + RoughlyEquals(d1, d1, window, freq));
        Console.WriteLine("d1 ~= d2 [false]: " 
            + RoughlyEquals(d1, d2, window, freq));
        Console.WriteLine("d1 ~= d3 [false]: " 
            + RoughlyEquals(d1, d3, window, freq));
        Console.WriteLine("d1 ~= d4 [true]: " 
            + RoughlyEquals(d1, d4, window, freq));
        Console.WriteLine("d1 ~= d5 [true]: " 
            + RoughlyEquals(d1, d5, window, freq));
        Console.WriteLine("d1 ~= d6 [false]: " 
            + RoughlyEquals(d1, d6, window, freq));
        Console.WriteLine("d1 ~= d7 [false]: " 
            + RoughlyEquals(d1, d7, window, freq));
        Console.WriteLine("d1 ~= d8 [true]: " 
            + RoughlyEquals(d1, d8, window, freq));
        Console.WriteLine("d1 ~= d9 [true]: " 
            + RoughlyEquals(d1, d9, window, freq));
    } //main 
} //DateTimeTester 


Alle Member dieses Typs sind threadsicher. Member, die scheinbar den Zustand einer Instanz ändern, geben in Wirklichkeit eine neue Instanz zurück, die mit dem neuen Wert initialisiert wurde. Wie bei allen anderen Typen müssen Lese- und Schreibzugriffe auf eine freigegebene Variable, die eine Instanz dieses Typs enthält, durch eine Sperre geschützt werden, um Threadsicherheit zu garantieren.

03ybds8y.alert_caution(de-de,VS.90).gif Vorsicht:

Die Zuweisung einer Instanz dieses Typs ist nicht auf allen Hardwareplattformen threadsicher, da die binäre Darstellung der Instanz u. U. zu groß ist, sodass die Zuweisung nicht in einem einzelnen atomaren Vorgang abgeschlossen werden kann.

Windows Vista, Windows XP SP2, Windows XP Media Center Edition, Windows XP Professional x64 Edition, Windows XP Starter Edition, Windows Server 2003, Windows Server 2000 SP4, Windows Millennium Edition, Windows 98, Windows CE, Windows Mobile für Smartphone, Windows Mobile für Pocket PC, Xbox 360

.NET Framework und .NET Compact Framework unterstützen nicht alle Versionen sämtlicher Plattformen. Eine Liste der unterstützten Versionen finden Sie unter Systemanforderungen für .NET Framework.

.NET Framework

Unterstützt in: 3.5, 3.0, 2.0, 1.1, 1.0

.NET Compact Framework

Unterstützt in: 3.5, 2.0, 1.0

XNA Framework

Unterstützt in: 2.0, 1.0

Datum

Versionsgeschichte

Grund

Juli 2008

Verwendung eines impliziten Standardkonstruktors zur Liste der Instanziierungsmöglichkeiten für ein DateTime-Objekt hinzugefügt.

Kundenfeedback.

Fanden Sie dies hilfreich?
(1500 verbleibende Zeichen)
Community-Inhalt Hinzufügen
Anmerkungen FAQ