DateTime-Struktur

Artikel
08/20/2007

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

Namespace: System
Assembly: mscorlib (in mscorlib.dll)

Syntax

'Declaration
<SerializableAttribute> _
Public Structure DateTime
    Implements IComparable, IFormattable, IConvertible, ISerializable, _
    IComparable(Of DateTime), IEquatable(Of DateTime)
'Usage
Dim instance As DateTime

[SerializableAttribute] 
public struct DateTime : IComparable, IFormattable, IConvertible, 
    ISerializable, IComparable<DateTime>, IEquatable<DateTime>

[SerializableAttribute] 
public value class 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.

Hinweise

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.

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 lokale Zeit, eine koordinierte Weltzeit (Coordinated Universal Time, UTC) darstellt, oder ob UTC oder lokale Zeit nicht angegeben sind. Das Kind-Feld wird verwendet, um Konvertierungen zwischen lokaler Zeit und UTC zu behandeln, aber nicht, um Vergleichs- und Arithmetikoperationen auszuführen. Der Wert des Kind-Felds kann mit der Kind-Eigenschaft abgerufen werden.

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 lokale Zeit ist für die Anzeige auf der Benutzeroberfläche geeignet.

Wenn die Kind-Eigenschaft eines DateTime-Objekts Unspecified ist, ist keine Angabe vorhanden, ob die dargestellte Zeit die lokale Zeit oder UTC-Zeit ist. Einzelne DateTime-Member behandeln nicht angegebene Zeit in diesem Member entsprechender Weise.

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 lokaler Zeit und UTC wird die Sommerzeit berücksichtigt, bei arithmetischen und Vergleichsoperationen hingegen nicht.

Berechnungen und Vergleiche von DateTime-Objekten sind nur dann sinnvoll, wenn die Objekte Zeitangaben in der gleichen Zeitzone darstellen. Wenn aus diesem Grund für die Objekte keine Zeitzone angegeben ist, wird davon ausgegangen, dass der Entwickler einen externen Mechanismus verwendet, z. B. eine explizite Variable oder Richtlinien, die zum Bestimmen der Zeitzone verwendet werden können, in der ein DateTime-Objekt erstellt wurde.

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 eine DateTime von einer anderen subtrahiert und so das dazwischen liegende Zeitintervall abgerufen werden kann. Für die Berechnung eines Datums in der Zukunft kann auch eine positive TimeSpan zur aktuellen DateTime addiert werden.

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, IFormattable und IConvertible. Verwenden Sie für Konvertierungen die Convert-Klasse anstelle der expliziten Implementierung der Schnittstellenmember der IConvertible-Schnittstelle für diesen Typ.

Beispiel

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

Class DateTimeTester
   
   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 'RoughlyEquals
    
   
   Public Shared Sub Main()

      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 [true]: " + CStr(RoughlyEquals(d1, d1, window, freq)))
      Console.WriteLine("d1 ~= d2 [false]: " + CStr(RoughlyEquals(d1, d2, window, freq)))
      Console.WriteLine("d1 ~= d3 [false]: " + CStr(RoughlyEquals(d1, d3, window, freq)))
      Console.WriteLine("d1 ~= d4 [true]: " + CStr(RoughlyEquals(d1, d4, window, freq)))
      Console.WriteLine("d1 ~= d5 [true]: " + CStr(RoughlyEquals(d1, d5, window, freq)))
      
      Console.WriteLine("d1 ~= d6 [false]: " + CStr(RoughlyEquals(d1, d6, window, freq)))
      Console.WriteLine("d1 ~= d7 [false]: " + CStr(RoughlyEquals(d1, d7, window, freq)))
      Console.WriteLine("d1 ~= d8 [true]: " + CStr(RoughlyEquals(d1, d8, window, freq)))
      Console.WriteLine("d1 ~= d9 [true]: " + CStr(RoughlyEquals(d1, d9, window, freq)))

   End Sub 'Main 

End Class 'DateTimeTester

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));


    }
}

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;
}

int 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]: {0}", RoughlyEquals( d1, d1, window, freq ) );
   Console::WriteLine( "d1 ~= d2 [false]: {0}", RoughlyEquals( d1, d2, window, freq ) );
   Console::WriteLine( "d1 ~= d3 [false]: {0}", RoughlyEquals( d1, d3, window, freq ) );
   Console::WriteLine( "d1 ~= d4 [true]: {0}", RoughlyEquals( d1, d4, window, freq ) );
   Console::WriteLine( "d1 ~= d5 [true]: {0}", RoughlyEquals( d1, d5, window, freq ) );
   Console::WriteLine( "d1 ~= d6 [false]: {0}", RoughlyEquals( d1, d6, window, freq ) );
   Console::WriteLine( "d1 ~= d7 [false]: {0}", RoughlyEquals( d1, d7, window, freq ) );
   Console::WriteLine( "d1 ~= d8 [true]: {0}", RoughlyEquals( d1, d8, window, freq ) );
   Console::WriteLine( "d1 ~= d9 [true]: {0}", 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

Threadsicherheit

Alle öffentlichen statischen (Shared in Visual Basic) Member dieses Typs sind threadsicher. Bei Instanzmembern ist die Threadsicherheit nicht gewährleistet.

Plattformen

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

.NET Framework unterstützt nicht alle Versionen sämtlicher Plattformen. Eine Liste der unterstützten Versionen finden Sie unter Systemanforderungen.

Freigeben über

DateTime-Struktur

Syntax

Hinweise

Versionsaspekte

DateTime-Werte

DateTime-Operationen

DateTime und TimeSpan

COM-Interop-Überlegungen

Implementierte Schnittstellen

Beispiel

Threadsicherheit

Plattformen

Versionsinformationen

.NET Framework

.NET Compact Framework

Siehe auch

Referenz

Zusätzliche Ressourcen