Auswählen zwischen DateTime, DateOnly, DateTimeOffset, TimeSpan, TimeOnly und TimeZoneInfo

.NET-Anwendungen können Datums- und Uhrzeitinformationen auf verschiedene Arten verwenden. Die häufigeren Verwendungen von Datums- und Uhrzeitinformationen umfassen Folgendes:

• Darstellen eines reinen Datums, damit Zeitinformationen unberücksichtigt bleiben.
• Darstellen einer reinen Uhrzeit, damit Datumsinformationen unberücksichtigt bleiben.
• Um ein abstraktes Datum und eine Uhrzeit darzustellen, die an keine bestimmte Zeit und keinen bestimmten Ort gebunden sind (z. B. öffnen die meisten Geschäfte einer internationalen Kette an Wochentagen um 9:00 Uhr).
• Abrufen von Datums- und Uhrzeitinformationen aus Quellen außerhalb von .NET, typischerweise wo Datums- und Uhrzeitinformationen in einem einfachen Datentyp gespeichert sind.
• Eindeutiges und unzweideutiges Identifizieren eines einzigen Zeitpunkts. Einige Anwendungen erfordern, dass ein Datum und eine Uhrzeit nur auf dem Hostsystem eindeutig sind. Andere Apps erfordern, dass sie in mehreren Systemen eindeutig sind (d. h. ein auf dem einen System serialisiertes Datum kann weltweit auf einem anderen System sinnvoll deserialisiert und verwendet werden).
• Erhalten mehrerer verwandter Zeiten (z. B. die lokale Zeit des Anforderers und die Empfangszeit des Servers für eine Webanforderung).
• Durchführen von Datums- und Uhrzeitberechnungen, möglicherweise mit einem Ergebnis, das einen einzigen Zeitpunkt eindeutig identifiziert.

.NET enthält die Typen DateTime, DateOnly, DateTimeOffset, TimeSpan, TimeOnly und TimeZoneInfo, die alle zum Erstellen von Anwendungen verwendet werden können, die mit Datumsangaben und Uhrzeiten arbeiten.

Die DateTimeOffset-Struktur

Die DateTimeOffset -Struktur stellt einen Datums- und Uhrzeitwert zusammen mit einem Offset dar, der angibt, um wie viel dieser Wert von UTC abweicht. Somit identifiziert der Wert immer eindeutig einen einzigen Zeitpunkt.

Der DateTimeOffset -Typ bietet die gesamte Funktionalität des DateTime -Typs plus Unterstützung von Zeitzonen. Dadurch eignet er sich für Anwendungen, für die Folgendes gilt:

• Eindeutiges und unzweideutiges Identifizieren eines einzigen Zeitpunkts. Der DateTimeOffset -Typ kann zur eindeutigen Definition der Bedeutung von "jetzt" verwendet werden, um Transaktionszeiten zu protokollieren, die Zeiten von System- oder Anwendungsereignissen zu protokollieren und um die Zeiten der Erstellung und Änderung von Dateien aufzuzeichnen.
• Ausführen von allgemeinen Datums- und Uhrzeitberechnungen
• Erhalten mehrerer verwandter Uhrzeiten, solange diese Zeiten als zwei gesonderte Werte oder als zwei Member einer Struktur gespeichert werden.

Ein DateTimeOffset-Wert ist nicht an eine bestimmte Zeitzone gebunden, kann aber aus zahlreichen Zeitzonen stammen. Das folgende Beispiel listet die Zeitzonen auf, zu denen mehrere DateTimeOffset-Werte (einschließlich eines Werts in lokaler Pacific Standard Time) gehören können.

using System;
using System.Collections.ObjectModel;

public class TimeOffsets
{
   public static void Main()
   {
      DateTime thisDate = new DateTime(2007, 3, 10, 0, 0, 0);
      DateTime dstDate = new DateTime(2007, 6, 10, 0, 0, 0);
      DateTimeOffset thisTime;

      thisTime = new DateTimeOffset(dstDate, new TimeSpan(-7, 0, 0));
      ShowPossibleTimeZones(thisTime);

      thisTime = new DateTimeOffset(thisDate, new TimeSpan(-6, 0, 0));
      ShowPossibleTimeZones(thisTime);

      thisTime = new DateTimeOffset(thisDate, new TimeSpan(+1, 0, 0));
      ShowPossibleTimeZones(thisTime);
   }

   private static void ShowPossibleTimeZones(DateTimeOffset offsetTime)
   {
      TimeSpan offset = offsetTime.Offset;
      ReadOnlyCollection<TimeZoneInfo> timeZones;

      Console.WriteLine("{0} could belong to the following time zones:",
                        offsetTime.ToString());
      // Get all time zones defined on local system
      timeZones = TimeZoneInfo.GetSystemTimeZones();
      // Iterate time zones
      foreach (TimeZoneInfo timeZone in timeZones)
      {
         // Compare offset with offset for that date in that time zone
         if (timeZone.GetUtcOffset(offsetTime.DateTime).Equals(offset))
            Console.WriteLine("   {0}", timeZone.DisplayName);
      }
      Console.WriteLine();
   }
}
// This example displays the following output to the console:
//       6/10/2007 12:00:00 AM -07:00 could belong to the following time zones:
//          (GMT-07:00) Arizona
//          (GMT-08:00) Pacific Time (US & Canada)
//          (GMT-08:00) Tijuana, Baja California
//
//       3/10/2007 12:00:00 AM -06:00 could belong to the following time zones:
//          (GMT-06:00) Central America
//          (GMT-06:00) Central Time (US & Canada)
//          (GMT-06:00) Guadalajara, Mexico City, Monterrey - New
//          (GMT-06:00) Guadalajara, Mexico City, Monterrey - Old
//          (GMT-06:00) Saskatchewan
//
//       3/10/2007 12:00:00 AM +01:00 could belong to the following time zones:
//          (GMT+01:00) Amsterdam, Berlin, Bern, Rome, Stockholm, Vienna
//          (GMT+01:00) Belgrade, Bratislava, Budapest, Ljubljana, Prague
//          (GMT+01:00) Brussels, Copenhagen, Madrid, Paris
//          (GMT+01:00) Sarajevo, Skopje, Warsaw, Zagreb
//          (GMT+01:00) West Central Africa

Imports System.Collections.ObjectModel

Module TimeOffsets
    Public Sub Main()
        Dim thisTime As DateTimeOffset

        thisTime = New DateTimeOffset(#06/10/2007#, New TimeSpan(-7, 0, 0))
        ShowPossibleTimeZones(thisTime)

        thisTime = New DateTimeOffset(#03/10/2007#, New TimeSpan(-6, 0, 0))
        ShowPossibleTimeZones(thisTime)

        thisTime = New DateTimeOffset(#03/10/2007#, New TimeSpan(+1, 0, 0))
        ShowPossibleTimeZones(thisTime)
    End Sub

    Private Sub ShowPossibleTimeZones(offsetTime As DateTimeOffset)
        Dim offset As TimeSpan = offsetTime.Offset
        Dim timeZones As ReadOnlyCollection(Of TimeZoneInfo)

        Console.WriteLine("{0} could belong to the following time zones:", _
                          offsetTime.ToString())
        ' Get all time zones defined on local system
        timeZones = TimeZoneInfo.GetSystemTimeZones()
        ' Iterate time zones
        For Each timeZone As TimeZoneInfo In timeZones
            ' Compare offset with offset for that date in that time zone
            If timeZone.GetUtcOffset(offsetTime.DateTime).Equals(offset) Then
                Console.WriteLine("   {0}", timeZone.DisplayName)
            End If
        Next
        Console.WriteLine()
    End Sub
End Module
' This example displays the following output to the console:
'       6/10/2007 12:00:00 AM -07:00 could belong to the following time zones:
'          (GMT-07:00) Arizona
'          (GMT-08:00) Pacific Time (US & Canada)
'          (GMT-08:00) Tijuana, Baja California
'       
'       3/10/2007 12:00:00 AM -06:00 could belong to the following time zones:
'          (GMT-06:00) Central America
'          (GMT-06:00) Central Time (US & Canada)
'          (GMT-06:00) Guadalajara, Mexico City, Monterrey - New
'          (GMT-06:00) Guadalajara, Mexico City, Monterrey - Old
'          (GMT-06:00) Saskatchewan
'       
'       3/10/2007 12:00:00 AM +01:00 could belong to the following time zones:
'          (GMT+01:00) Amsterdam, Berlin, Bern, Rome, Stockholm, Vienna
'          (GMT+01:00) Belgrade, Bratislava, Budapest, Ljubljana, Prague
'          (GMT+01:00) Brussels, Copenhagen, Madrid, Paris
'          (GMT+01:00) Sarajevo, Skopje, Warsaw, Zagreb
'          (GMT+01:00) West Central Africa

Die Ausgabe zeigt, dass jeder Datums- und Uhrzeitwert in diesem Beispiel zu mindestens drei verschiedenen Zeitzonen gehören kann. Der DateTimeOffset-Wert „6/10/2007“ zeigt, dass, wenn ein Datums- und Uhrzeitwert eine Sommerzeit darstellt, sein Offset von UTC noch nicht einmal unbedingt dem UTC-Basisoffset der Ursprungszeitzone oder dem in seinem Anzeigenamen vorgefundenen Offset von UTC entsprechen muss. Da ein einzelner DateTimeOffset-Wert nicht eng mit seiner Zeitzone verknüpft ist, kann er nicht den Übergang einer Zeitzone zur und aus der Sommerzeit wiedergeben. Dies kann problematisch sein, wenn ein DateTimeOffset-Wert mithilfe von Datums- und Uhrzeitberechnungen manipuliert wird. Eine Erläuterung der Durchführung von Datums- und Uhrzeitberechnungen auf eine Weise, die die Anpassungsregeln einer Zeitzone berücksichtigt, finden Sie unter Durchführen arithmetischer Datums- und Uhrzeitoperationen.

Die DateTime-Struktur

Ein DateTime -Wert definiert ein bestimmtes Datum und eine Uhrzeit. Er enthält eine Kind-Eigenschaft, die eingeschränkte Informationen über die Zeitzone bietet, zu der dieses Datum und die Uhrzeit gehören. Der von der DateTimeKind -Eigenschaft zurückgegebene Kind Wert zeigt an, ob der DateTime -Wert eine lokale Uhrzeit darstellt (DateTimeKind.Local), eine Zeit im UTC-Format (Coordinated Universal Time) (DateTimeKind.Utc) oder eine unspezifische Uhrzeit (DateTimeKind.Unspecified).

Die DateTime-Struktur eignet sich für Anwendungen mit mindestens einem der folgenden Merkmale:

• Mit abstrakten Datums- und Uhrzeitwerten arbeiten.
• Mit Datums- und Uhrzeitwerten arbeiten, für die Zeitzoneninformationen fehlen.
• Nur mit UTC-Datums- und Uhrzeitwerten arbeiten.
• Arithmetische Operationen mit Datums- und Uhrzeitwerten durchführen, wobei aber allgemeine Ergebnisse von Belang sind. Beispielsweise ist es bei einer Additionsoperation, bei der einem bestimmten Datum und einer Uhrzeit sechs Monate hinzuaddiert werden, oft nicht wichtig, ob das Ergebnis hinsichtlich der Sommerzeit angepasst wird.

Wenn nicht ein bestimmter DateTime -Wert UTC darstellt, ist dieser Datums- und Uhrzeitwert häufig mehrdeutig oder in seiner Portierbarkeit eingeschränkt. Wenn z. B. ein DateTime-Wert die lokale Uhrzeit darstellt, ist er innerhalb dieser lokalen Zeitzone portierbar (d. h., wenn der Wert auf einem anderen System in derselben Zeitzone deserialisiert wird, identifiziert dieser Wert immer noch eindeutig einen einzigen Zeitpunkt). Außerhalb der lokalen Zeitzone kann dieser DateTime -Wert über mehrere Interpretationen verfügen. Wenn die Kind-Eigenschaft des Werts DateTimeKind.Unspecified ist, ist er sogar noch weniger portierbar: Er ist jetzt innerhalb derselben Zeitzone mehrdeutig und möglicherweise sogar auf dem selben System, auf dem er erstmalig serialisiert wurde. Nur wenn ein DateTime -Wert eine UTC-Zeit darstellt, identifiziert dieser Wert eindeutig einen einzigen Zeitpunkt, unabhängig vom System oder der Zeitzone, in der der Wert verwendet wird.

Die DateOnly-Struktur

Die DateOnly-Struktur stellt ein bestimmtes Datum ohne Uhrzeit dar. Da sie keine Uhrzeitkomponente aufweist, stellt sie ein Datum vom Anfang des Tages bis zum Ende des Tages dar. Diese Struktur eignet sich ideal zum Speichern bestimmter Datumsangaben, z. B. eines Geburtsdatums, eines Jahrestags, eines Feiertags oder geschäftsbezogener Daten.

Obwohl Sie DateTime verwenden könnten, ohne die Uhrzeitkomponente zu berücksichtigen, bietet die Verwendung von DateOnly gegenüber DateTime einige Vorteile:

• Die DateTime-Struktur kann in den vorherigen oder nächsten Tag übergehen, wenn sie durch eine Zeitzone versetzt ist. DateOnly kann nicht durch eine Zeitzone versetzt werden und stellt immer das festgelegte Datum dar.
• Das Serialisieren einer DateTime-Struktur schließt die Uhrzeitkomponente ein, die die Absicht der Daten verschleiern kann. Außerdem serialisiert DateOnly weniger Daten.
• Wenn Code mit einer Datenbank interagiert, z. B. mit SQL Server, werden im Allgemeinen vollständige Datumsangaben als date-Datentyp gespeichert, der keine Uhrzeit enthält. DateOnly entspricht dem Datenbanktyp besser.

Weitere Informationen zu DateOnly finden Sie unter Verwenden der DateOnly- und TimeOnly-Strukturen.

Die TimeSpan-Struktur

Die TimeSpan -Struktur stellt ein Zeitintervall dar. Sein zwei typischen Anwendungsmöglichkeiten sind:

• Darstellen des Zeitintervalls zwischen zwei Datums- und Uhrzeitwerten. Beispielsweise gibt die Subtraktion eines DateTime -Werts von einem anderen einen TimeSpan -Wert zurück.
• Messen der verstrichenen Zeit. Beispielsweise gibt die Stopwatch.Elapsed-Eigenschaft einen TimeSpan-Wert zurück, der das Zeitintervall angibt, das seit dem Aufrufen einer der Stopwatch-Methoden, die verstrichene Zeit zu messen beginnen, verstrichen ist.

Ein TimeSpan-Wert kann auch als Ersatz für einen DateTime-Wert verwendet werden, wenn dieser Wert eine Uhrzeit ohne Verweis auf einen bestimmten Tag widerspiegelt. Diese Verwendung ähnelt den Eigenschaften DateTime.TimeOfDay und DateTimeOffset.TimeOfDay, die einen TimeSpan-Wert zurückgeben, der die Uhrzeit ohne Verweis auf ein Datum darstellt. Beispielsweise kann die TimeSpan -Struktur verwendet werden, um die täglichen Öffnungszeiten eines Geschäfts darzustellen oder um die Uhrzeit darzustellen, zu der alle regulären Ereignisse auftreten.

Das folgende Beispiel definiert eine StoreInfo -Struktur, die TimeSpan -Objekte für Öffnungszeiten von Geschäften enthält sowie ein TimeZoneInfo -Objekt, das die Zeitzone des Geschäfts darstellt. Die Struktur enthält außerdem zwei Methoden, IsOpenNow und IsOpenAt, die angeben, ob das Geschäft zu einem vom Benutzer angegebenen Zeitpunkt geöffnet ist, wobei angenommen wird, dass er sich in der lokalen Zeitzone aufhält.

using System;

public struct StoreInfo
{
   public String store;
   public TimeZoneInfo tz;
   public TimeSpan open;
   public TimeSpan close;

   public bool IsOpenNow()
   {
      return IsOpenAt(DateTime.Now.TimeOfDay);
   }

   public bool IsOpenAt(TimeSpan time)
   {
      TimeZoneInfo local = TimeZoneInfo.Local;
      TimeSpan offset = TimeZoneInfo.Local.BaseUtcOffset;

      // Is the store in the same time zone?
      if (tz.Equals(local)) {
         return time >= open & time <= close;
      }
      else {
         TimeSpan delta = TimeSpan.Zero;
         TimeSpan storeDelta = TimeSpan.Zero;

         // Is it daylight saving time in either time zone?
         if (local.IsDaylightSavingTime(DateTime.Now.Date + time))
            delta = local.GetAdjustmentRules()[local.GetAdjustmentRules().Length - 1].DaylightDelta;

         if (tz.IsDaylightSavingTime(TimeZoneInfo.ConvertTime(DateTime.Now.Date + time, local, tz)))
            storeDelta = tz.GetAdjustmentRules()[tz.GetAdjustmentRules().Length - 1].DaylightDelta;

         TimeSpan comparisonTime = time + (offset - tz.BaseUtcOffset).Negate() + (delta - storeDelta).Negate();
         return comparisonTime >= open && comparisonTime <= close;
      }
   }
}

Public Structure StoreInfo
    Dim store As String
    Dim tz As TimeZoneInfo
    Dim open As TimeSpan
    Dim close As TimeSpan

    Public Function IsOpenNow() As Boolean
        Return IsOpenAt(Date.Now.TimeOfDay)
    End Function

    Public Function IsOpenAt(time As TimeSpan) As Boolean
        Dim local As TimeZoneInfo = TimeZoneInfo.Local
        Dim offset As TimeSpan = TimeZoneInfo.Local.BaseUtcOffset

        ' Is the store in the same time zone?
        If tz.Equals(local) Then
            Return time >= open AndAlso time <= close
        Else
            Dim delta As TimeSpan = TimeSpan.Zero
            Dim storeDelta As TimeSpan = TimeSpan.Zero

            ' Is it daylight saving time in either time zone?
            If local.IsDaylightSavingTime(Date.Now.Date + time) Then
                delta = local.GetAdjustmentRules(local.GetAdjustmentRules().Length - 1).DaylightDelta
            End If
            If tz.IsDaylightSavingTime(TimeZoneInfo.ConvertTime(Date.Now.Date + time, local, tz))
                storeDelta = tz.GetAdjustmentRules(tz.GetAdjustmentRules().Length - 1).DaylightDelta
            End If
            Dim comparisonTime As TimeSpan = time + (offset - tz.BaseUtcOffset).Negate() + (delta - storeDelta).Negate
            Return (comparisonTime >= open AndAlso comparisonTime <= close)
        End If
    End Function
End Structure

Die StoreInfo -Struktur kann dann von Clientcode wie folgt verwendet werden.

public class Example
{
   public static void Main()
   {
      // Instantiate a StoreInfo object.
      var store103 = new StoreInfo();
      store103.store = "Store #103";
      store103.tz = TimeZoneInfo.FindSystemTimeZoneById("Eastern Standard Time");
      // Store opens at 8:00.
      store103.open = new TimeSpan(8, 0, 0);
      // Store closes at 9:30.
      store103.close = new TimeSpan(21, 30, 0);

      Console.WriteLine("Store is open now at {0}: {1}",
                        DateTime.Now.TimeOfDay, store103.IsOpenNow());
      TimeSpan[] times = { new TimeSpan(8, 0, 0), new TimeSpan(21, 0, 0),
                           new TimeSpan(4, 59, 0), new TimeSpan(18, 31, 0) };
      foreach (var time in times)
         Console.WriteLine("Store is open at {0}: {1}",
                           time, store103.IsOpenAt(time));
   }
}
// The example displays the following output:
//       Store is open now at 15:29:01.6129911: True
//       Store is open at 08:00:00: True
//       Store is open at 21:00:00: True
//       Store is open at 04:59:00: False
//       Store is open at 18:31:00: True

Module Example
    Public Sub Main()
        ' Instantiate a StoreInfo object.
        Dim store103 As New StoreInfo()
        store103.store = "Store #103"
        store103.tz = TimeZoneInfo.FindSystemTimeZoneById("Eastern Standard Time")
        ' Store opens at 8:00.
        store103.open = new TimeSpan(8, 0, 0)
        ' Store closes at 9:30.
        store103.close = new TimeSpan(21, 30, 0)

        Console.WriteLine("Store is open now at {0}: {1}",
                          Date.Now.TimeOfDay, store103.IsOpenNow())
        Dim times() As TimeSpan = {New TimeSpan(8, 0, 0),
                                    New TimeSpan(21, 0, 0),
                                    New TimeSpan(4, 59, 0),
                                    New TimeSpan(18, 31, 0)}
        For Each time In times
            Console.WriteLine("Store is open at {0}: {1}",
                              time, store103.IsOpenAt(time))
        Next
    End Sub
End Module
' The example displays the following output:
'       Store is open now at 15:29:01.6129911: True
'       Store is open at 08:00:00: True
'       Store is open at 21:00:00: False
'       Store is open at 04:59:00: False
'       Store is open at 18:31:00: False

Die TimeOnly-Struktur

Die TimeOnly-Struktur stellt einen Tageszeitwert dar, z. B. einen täglichen Wecker oder die Uhrzeit,zu der Sie täglich Ihr Mittagessen einnehmen. TimeOnly ist auf den Bereich von 00:00:00.0000000 - 23:59:59.9999999 beschränkt, eine bestimmte Tageszeit.

Vor Einführung des TimeOnly-Typs haben Programmierer in der Regel entweder den DateTime-Typ oder den TimeSpan-Typ verwendet, um eine bestimmte Uhrzeit darzustellen. Die Verwendung dieser Strukturen zum Simulieren einer Uhrzeit ohne Datum kann jedoch zu einigen Problemen führen, die durch TimeOnly gelöst werden:

• TimeSpan stellt die verstrichene Zeit dar, z. B. die mit einer Stoppuhr gemessene Zeit. Der obere Bereich beträgt mehr als 29.000 Jahre, und sein Wert kann negativ sein, um eine Rückwärtsbewegung in der Zeit anzuzeigen. Ein negativer TimeSpan-Wert gibt keine bestimmte Tageszeit an.
• Wenn TimeSpan als Tageszeit verwendet wird, besteht das Risiko, dass diese Angabe zu einem Wert außerhalb des 24-Stunden-Tages manipuliert werden kann. Für TimeOnly besteht dieses Risiko nicht. Wenn die Arbeitsschicht eines Mitarbeiters bzw. einer Mitarbeiterin beispielsweise um 18:00 Uhr beginnt und 8 Stunden dauert, wird das Hinzufügen von 8 Stunden zur TimeOnly-Struktur auf 2:00 Uhr übertragen.
• Die Verwendung von DateTime für eine Tageszeit erfordert, dass ein beliebiges Datum der Uhrzeit zugeordnet und später ignoriert wird. Es ist üblich, DateTime.MinValue (0001-01-01) als Datum auszuwählen, aber wenn Stunden vom DateTime-Wert subtrahiert werden, kann eine OutOfRange-Ausnahme auftreten. TimeOnly hat dieses Problem nicht, da die Zeit um den 24-Stunden-Zeitraum vorwärts und rückwärts übertragen wird.
• Das Serialisieren einer DateTime-Struktur schließt die Datumskomponente ein, die die Absicht der Daten verschleiern kann. Außerdem serialisiert TimeOnly weniger Daten.

Weitere Informationen zu TimeOnly finden Sie unter Verwenden der DateOnly- und TimeOnly-Strukturen.

Die TimeZoneInfo-Klasse

Die TimeZoneInfo class represents any of the Earth's time zones, and enables the conversion of any date and time in one time zone to its equivalent in another time zone. Die TimeZoneInfo -Klasse ermöglicht das Arbeiten mit Datums- und Zeitwerten, sodass jeder Datums- und Uhrzeitwert eindeutig einen einzigen Zeitpunkt identifiziert. Die TimeZoneInfo -Klasse ist außerdem erweiterbar. Obwohl sie von den für Windows-Systeme bereitgestellten und in der Registrierung definierten Zeitzoneninformationen abhängt, unterstützt sie die Erstellung benutzerdefinierter Zeitzonen. Sie unterstützt außerdem die Serialisierung und Deserialisierung von Zeitzoneninformationen.

In einigen Fällen kann noch weitere Entwicklungsarbeit erforderlich sein, um die TimeZoneInfo -Klasse optimal zu nutzen. Wenn Datums- und Uhrzeitwerte nicht eng mit den Zeitzonen verknüpft sind, zu denen sie gehören, ist weitere Arbeit erforderlich. Sofern Ihre Anwendung keinen Mechanismus zum Verknüpfen eines Datums und einer Uhrzeit mit der zugeordneten Zeitzone bereitstellt, kann die Zuordnung eines Datums- und Uhrzeitwerts zu seiner Zeitzone leicht aufgehoben werden. Eine Methode zum Verknüpfen dieser Informationen besteht darin, eine Klasse oder Struktur zu definieren, die sowohl den Datums- und Zeitwert als auch sein zugeordnetes Zeitzonenobjekt enthält.

Die Zeitzonenunterstützung in .NET kann nur genutzt werden, wenn die Zeitzone, zu der ein Datums- und Uhrzeitwert gehört, bekannt ist, wenn das Datums- und Uhrzeitobjekt instanziiert wird. Die Zeitzone ist häufig nicht bekannt, insbesondere in Web- oder Netzwerk-Apps.

Weitere Informationen

• Datumsangaben, Uhrzeiten und Zeitzonen