Freigeben über

Wie man die Strukturen "DateOnly" und "TimeOnly" verwendet

  • Artikel

Die strukturen DateOnly und TimeOnly wurden mit .NET 6 eingeführt und stellen jeweils ein bestimmtes Datum bzw. eine bestimmte Uhrzeit dar. Vor .NET 6 und immer in .NET Framework haben Entwickler den DateTime Typ (oder eine andere Alternative) verwendet, um einen der folgenden Elemente darzustellen:

  • Ein ganzes Datum und eine ganze Uhrzeit.
  • Ein Datum, das die Uhrzeit ignoriert.
  • Eine Uhrzeit ohne Berücksichtigung des Datums.

DateOnly und TimeOnly sind Typen, die bestimmte Teile eines DateTime Typs darstellen.

Wichtig

DateOnly- und TimeOnly-Datentypen sind für das .NET Framework nicht verfügbar.

Die DateOnly-Struktur

Die DateOnly-Struktur stellt ein bestimmtes Datum ohne Uhrzeit dar. Da keine Zeitkomponente vorhanden ist, 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 oder geschäftsbezogener Datumsangaben.

Obwohl Sie DateTime verwenden können, indem Sie die Zeitkomponente ignorieren, hat die Verwendung von DateOnly gegenüber DateTimeeinige 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 verschoben werden und stellt immer das eingestellte Datum dar.

  • Das Serialisieren einer DateTime-Struktur umfasst die Zeitkomponente, die die Absicht der Daten verdecken kann. Außerdem serialisiert DateOnly weniger Daten.

  • Wenn Code mit einer Datenbank interagiert, z. B. SQL Server, werden ganze Datumsangaben in der Regel als date Datentyp gespeichert, der keine Uhrzeit enthält. DateOnly entspricht dem Datenbanktyp besser.

DateOnly hat einen Bereich von 0001-01-01 bis 9999-12-31, genau wie DateTime. Sie können einen bestimmten Kalender im DateOnly-Konstruktor angeben. Ein DateOnly -Objekt stellt jedoch immer ein Datum im proleptischen gregorianischen Kalender dar, unabhängig davon, welcher Kalender zum Konstruieren verwendet wurde. Sie können z. B. das Datum aus einem hebräischen Kalender erstellen, aber das Datum wird ins gregorianische Datum umgewandelt.

var hebrewCalendar = new System.Globalization.HebrewCalendar();
var theDate = new DateOnly(5776, 2, 8, hebrewCalendar); // 8 Cheshvan 5776

Console.WriteLine(theDate);

/* This example produces the following output:
 *
 * 10/21/2015
*/

Dim hebrewCalendar = New System.Globalization.HebrewCalendar()
Dim theDate = New DateOnly(5776, 2, 8, hebrewCalendar) ' 8 Cheshvan 5776

Console.WriteLine(theDate)

' This example produces the following output
'
' 10/21/2015

DateOnly-Beispiele

Verwenden Sie die folgenden Beispiele, um mehr über DateOnlyzu erfahren:

DateTime in DateOnly konvertieren

Verwenden Sie die statische Methode DateOnly.FromDateTime, um einen DateOnly Typ aus einem DateTime Typ zu erstellen, wie im folgenden Code gezeigt wird.

var today = DateOnly.FromDateTime(DateTime.Now);
Console.WriteLine($"Today is {today}");

/* This example produces output similar to the following:
 * 
 * Today is 12/28/2022
*/

Dim today = DateOnly.FromDateTime(DateTime.Now)
Console.WriteLine($"Today is {today}")

' This example produces output similar to the following
' 
' Today is 12/28/2022

Addieren oder Subtrahieren von Tagen, Monaten, Jahren

Es gibt drei Methoden zum Anpassen einer DateOnly-Struktur: AddDays, AddMonthsund AddYears. Jede Methode akzeptiert einen ganzzahligen Parameter und erhöht das Datum um diesen Wert. Wenn eine negative Zahl angegeben wird, wird das Datum durch diese Messung verringert. Die Methoden geben eine neue Instanz von DateOnlyzurück, da die Struktur unveränderlich ist.

var theDate = new DateOnly(2015, 10, 21);

var nextDay = theDate.AddDays(1);
var previousDay = theDate.AddDays(-1);
var decadeLater = theDate.AddYears(10);
var lastMonth = theDate.AddMonths(-1);

Console.WriteLine($"Date: {theDate}");
Console.WriteLine($" Next day: {nextDay}");
Console.WriteLine($" Previous day: {previousDay}");
Console.WriteLine($" Decade later: {decadeLater}");
Console.WriteLine($" Last month: {lastMonth}");

/* This example produces the following output:
 * 
 * Date: 10/21/2015
 *  Next day: 10/22/2015
 *  Previous day: 10/20/2015
 *  Decade later: 10/21/2025
 *  Last month: 9/21/2015
*/

Dim theDate = New DateOnly(2015, 10, 21)

Dim nextDay = theDate.AddDays(1)
Dim previousDay = theDate.AddDays(-1)
Dim decadeLater = theDate.AddYears(10)
Dim lastMonth = theDate.AddMonths(-1)

Console.WriteLine($"Date: {theDate}")
Console.WriteLine($" Next day: {nextDay}")
Console.WriteLine($" Previous day: {previousDay}")
Console.WriteLine($" Decade later: {decadeLater}")
Console.WriteLine($" Last month: {lastMonth}")

' This example produces the following output
' 
' Date: 10/21/2015
'  Next day: 10/22/2015
'  Previous day: 10/20/2015
'  Decade later: 10/21/2025
'  Last month: 9/21/2015

Analysieren und Formatieren von DateOnly

DateOnly kann aus einer Zeichenfolge analysiert werden, genau wie die DateTime-Struktur. Alle standardmäßigen datumsbasierten .NET-Analysetoken funktionieren mit DateOnly. Beim Konvertieren eines DateOnly Typs in eine Zeichenfolge können Sie auch standardmäßige datumsbasierte .NET-Formatierungsmuster verwenden. Weitere Informationen zu Formatierungszeichenfolgen finden Sie unter Standardformatierungszeichenfolgen für Datum und Uhrzeit.

var theDate = DateOnly.ParseExact("21 Oct 2015", "dd MMM yyyy", CultureInfo.InvariantCulture);  // Custom format
var theDate2 = DateOnly.Parse("October 21, 2015", CultureInfo.InvariantCulture);

Console.WriteLine(theDate.ToString("m", CultureInfo.InvariantCulture));     // Month day pattern
Console.WriteLine(theDate2.ToString("o", CultureInfo.InvariantCulture));    // ISO 8601 format
Console.WriteLine(theDate2.ToLongDateString());

/* This example produces the following output:
 * 
 * October 21
 * 2015-10-21
 * Wednesday, October 21, 2015
*/

Dim theDate = DateOnly.ParseExact("21 Oct 2015", "dd MMM yyyy", CultureInfo.InvariantCulture) ' Custom format
Dim theDate2 = DateOnly.Parse("October 21, 2015", CultureInfo.InvariantCulture)

Console.WriteLine(theDate.ToString("m", CultureInfo.InvariantCulture))     ' Month day pattern
Console.WriteLine(theDate2.ToString("o", CultureInfo.InvariantCulture))    ' ISO 8601 format
Console.WriteLine(theDate2.ToLongDateString())

' This example produces the following output
' 
' October 21
' 2015-10-21
' Wednesday, October 21, 2015

Vergleichen von DateOnly

DateOnly kann mit anderen Instanzen verglichen werden. Sie können z. B. überprüfen, ob ein Datum vor oder hinter einem anderen liegt oder ob ein Datum heute mit einem bestimmten Datum übereinstimmt.

var theDate = DateOnly.ParseExact("21 Oct 2015", "dd MMM yyyy", CultureInfo.InvariantCulture);  // Custom format
var theDate2 = DateOnly.Parse("October 21, 2015", CultureInfo.InvariantCulture);
var dateLater = theDate.AddMonths(6);
var dateBefore = theDate.AddDays(-10);

Console.WriteLine($"Consider {theDate}...");
Console.WriteLine($" Is '{nameof(theDate2)}' equal? {theDate == theDate2}");
Console.WriteLine($" Is {dateLater} after? {dateLater > theDate} ");
Console.WriteLine($" Is {dateLater} before? {dateLater < theDate} ");
Console.WriteLine($" Is {dateBefore} after? {dateBefore > theDate} ");
Console.WriteLine($" Is {dateBefore} before? {dateBefore < theDate} ");

/* This example produces the following output:
 * 
 * Consider 10/21/2015
 *  Is 'theDate2' equal? True
 *  Is 4/21/2016 after? True
 *  Is 4/21/2016 before? False
 *  Is 10/11/2015 after? False
 *  Is 10/11/2015 before? True
*/

Dim theDate = DateOnly.ParseExact("21 Oct 2015", "dd MMM yyyy", CultureInfo.InvariantCulture) ' Custom format
Dim theDate2 = DateOnly.Parse("October 21, 2015", CultureInfo.InvariantCulture)
Dim dateLater = theDate.AddMonths(6)
Dim dateBefore = theDate.AddDays(-10)

Console.WriteLine($"Consider {theDate}...")
Console.WriteLine($" Is '{NameOf(theDate2)}' equal? {theDate = theDate2}")
Console.WriteLine($" Is {dateLater} after? {dateLater > theDate} ")
Console.WriteLine($" Is {dateLater} before? {dateLater < theDate} ")
Console.WriteLine($" Is {dateBefore} after? {dateBefore > theDate} ")
Console.WriteLine($" Is {dateBefore} before? {dateBefore < theDate} ")

' This example produces the following output
' 
' Consider 10/21/2015
'  Is 'theDate2' equal? True
'  Is 4/21/2016 after? True
'  Is 4/21/2016 before? False
'  Is 10/11/2015 after? False
'  Is 10/11/2015 before? True

Die TimeOnly-Struktur

Die TimeOnly Struktur stellt einen Tageszeitwert dar, z. B. eine tägliche Weckeruhr oder die Uhrzeit, zu der Sie jeden Tag Mittagessen essen. TimeOnly ist auf den Bereich von 00:00:00.0000000 - 23:59:59.9999999 beschränkt, eine bestimmte Tageszeit.

Vor der 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 Zeit ohne Datum kann jedoch einige Probleme verursachen, die TimeOnly lösen:

  • TimeSpan stellt 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 die Rückwärtsbewegung in der Zeit anzuzeigen. Ein negativer TimeSpan gibt keine bestimmte Tageszeit an.

  • Wenn TimeSpan als Tageszeit verwendet wird, besteht das Risiko, dass sie außerhalb des 24-Stunden-Tages in einen Wert geändert werden kann. TimeOnly hat dieses Risiko nicht. Wenn die Arbeitsschicht eines Mitarbeiters 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 mit der Uhrzeit verknüpft und dann später ignoriert wird. Es ist üblich, DateTime.MinValue (0001-01-01) als Datum auszuwählen, jedoch, 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 umfasst die Datumskomponente, was die Absicht der Daten verfälschen kann. Außerdem serialisiert TimeOnly weniger Daten.

TimeOnly-Beispiele

Verwenden Sie die folgenden Beispiele, um mehr über TimeOnlyzu erfahren:

DateTime in TimeOnly konvertieren

Verwenden Sie die statische Methode TimeOnly.FromDateTime, um einen Typ TimeOnly aus einem Typ DateTime zu erstellen, wie im folgenden Code gezeigt:

var now = TimeOnly.FromDateTime(DateTime.Now);
Console.WriteLine($"It is {now} right now");

/* This example produces output similar to the following:
 * 
 * It is 2:01 PM right now
*/

Dim now = TimeOnly.FromDateTime(DateTime.Now)
Console.WriteLine($"It is {now} right now")

' This example produces output similar to the following
' 
' It is 2:01 PM right now

Addieren oder subtrahieren einer Uhrzeit

Es gibt drei Methoden, die zum Anpassen einer TimeOnly-Struktur verwendet werden: AddHours, AddMinutes und Add. Sowohl AddHours als auch AddMinutes nehmen einen ganzzahligen Parameter und passen den Wert entsprechend an. Sie können einen negativen Wert verwenden, um subtrahieren und einen positiven Wert zu addieren. Von den Methoden wird eine neue Instanz von TimeOnly zurückgegeben, da die Struktur unveränderlich ist. Die Add-Methode nimmt einen TimeSpan-Parameter entgegen und addiert oder subtrahiert den Wert von dem TimeOnly-Wert.

Da TimeOnly nur einen Zeitraum von 24 Stunden darstellt, wird beim Addieren von Werten, die für diese drei Methoden bereitgestellt werden, eine entsprechende Übertragung nach vorn oder zurück vorgenommen. Wenn Sie z. B. einen Wert von 01:30:00 verwenden, um 1:30 Uhr darzustellen, und dann -4 Stunden zu diesem Zeitraum addieren, wird eine Rückübertragung zu 21:30:00 ausgeführt, d. h. zu 21:30 Uhr. Es gibt Methodenüberladungen für AddHours, AddMinutes und Add, die die Anzahl der Tage erfassen, für die eine Übertragung erfolgt.

var theTime = new TimeOnly(7, 23, 11);

var hourLater = theTime.AddHours(1);
var minutesBefore = theTime.AddMinutes(-12);
var secondsAfter = theTime.Add(TimeSpan.FromSeconds(10));
var daysLater = theTime.Add(new TimeSpan(hours: 21, minutes: 200, seconds: 83), out int wrappedDays);
var daysBehind = theTime.AddHours(-222, out int wrappedDaysFromHours);

Console.WriteLine($"Time: {theTime}");
Console.WriteLine($" Hours later: {hourLater}");
Console.WriteLine($" Minutes before: {minutesBefore}");
Console.WriteLine($" Seconds after: {secondsAfter}");
Console.WriteLine($" {daysLater} is the time, which is {wrappedDays} days later");
Console.WriteLine($" {daysBehind} is the time, which is {wrappedDaysFromHours} days prior");

/* This example produces the following output:
 * 
 * Time: 7:23 AM
 *  Hours later: 8:23 AM
 *  Minutes before: 7:11 AM
 *  Seconds after: 7:23 AM
 *  7:44 AM is the time, which is 1 days later 
 *  1:23 AM is the time, which is -9 days prior
*/

Dim wrappedDays As Integer
Dim wrappedDaysFromHours As Integer

Dim theTime = New TimeOnly(7, 23, 11)

Dim hourLater = theTime.AddHours(1)
Dim minutesBefore = theTime.AddMinutes(-12)
Dim secondsAfter = theTime.Add(TimeSpan.FromSeconds(10))
Dim daysLater = theTime.Add(New TimeSpan(hours:=21, minutes:=200, seconds:=83), wrappedDays)
Dim daysBehind = theTime.AddHours(-222, wrappedDaysFromHours)

Console.WriteLine($"Time: {theTime}")
Console.WriteLine($" Hours later: {hourLater}")
Console.WriteLine($" Minutes before: {minutesBefore}")
Console.WriteLine($" Seconds after: {secondsAfter}")
Console.WriteLine($" {daysLater} is the time, which is {wrappedDays} days later")
Console.WriteLine($" {daysBehind} is the time, which is {wrappedDaysFromHours} days prior")

' This example produces the following output
' 
' Time: 7:23 AM
'  Hours later: 8:23 AM
'  Minutes before: 7:11 AM
'  Seconds after: 7:23 AM
'  7:44 AM is the time, which is 1 days later 
'  1:23 AM is the time, which is -9 days prior

Analysieren und Formatieren von TimeOnly

TimeOnly kann aus einer Zeichenfolge analysiert werden, genau wie die DateTime-Struktur. Alle standardmäßigen uhrzeitbasierten .NET-Analysetoken funktionieren mit TimeOnly. Beim Konvertieren eines TimeOnly-Typs in eine Zeichenfolge können Sie auch datumsbasierte .NET-Standardformatierungsmuster verwenden. Weitere Informationen zu Formatierungszeichenfolgen finden Sie unter Standardformatierungszeichenfolgen für Datum und Uhrzeit.

var theTime = TimeOnly.ParseExact("5:00 pm", "h:mm tt", CultureInfo.InvariantCulture);  // Custom format
var theTime2 = TimeOnly.Parse("17:30:25", CultureInfo.InvariantCulture);

Console.WriteLine(theTime.ToString("o", CultureInfo.InvariantCulture));     // Round-trip pattern.
Console.WriteLine(theTime2.ToString("t", CultureInfo.InvariantCulture));    // Long time format
Console.WriteLine(theTime2.ToLongTimeString());

/* This example produces the following output:
 * 
 * 17:00:00.0000000
 * 17:30
 * 5:30:25 PM
*/

Dim theTime = TimeOnly.ParseExact("5:00 pm", "h:mm tt", CultureInfo.InvariantCulture) ' Custom format
Dim theTime2 = TimeOnly.Parse("17:30:25", CultureInfo.InvariantCulture)

Console.WriteLine(theTime.ToString("o", CultureInfo.InvariantCulture))     ' Round-trip pattern.
Console.WriteLine(theTime2.ToString("t", CultureInfo.InvariantCulture))    ' Long time format
Console.WriteLine(theTime2.ToLongTimeString())

' This example produces the following output
' 
' 17:00:00.0000000
' 17:30
' 5:30:25 PM

Serialisieren der DateOnly- und TimeOnly-Typen

Mit .NET 7+ unterstützt System.Text.Json die Serialisierung und Deserialisierung von Typen DateOnly und TimeOnly. Betrachten Sie das folgende Objekt:

sealed file record Appointment(
    Guid Id,
    string Description,
    DateOnly Date,
    TimeOnly StartTime,
    TimeOnly EndTime);

Public NotInheritable Class Appointment
    Public Property Id As Guid
    Public Property Description As String
    Public Property DateValue As DateOnly?
    Public Property StartTime As TimeOnly?
    Public Property EndTime As TimeOnly?
End Class

Im folgenden Beispiel wird ein Appointment-Objekt serialisiert, der resultierende JSON-Code angezeigt und anschließend eine Deserialisierung in eine neue Instanz des Typs Appointment durchgeführt. Abschließend wird die ursprüngliche Instanz mit der neu deserialisierten Instanz verglichen, um zu ermitteln, ob sie gleich sind, und die Ergebnisse werden in die Konsole geschrieben:

Appointment originalAppointment = new(
    Id: Guid.NewGuid(),
    Description: "Take dog to veterinarian.",
    Date: new DateOnly(2002, 1, 13),
    StartTime: new TimeOnly(5,15),
    EndTime: new TimeOnly(5, 45));
string serialized = JsonSerializer.Serialize(originalAppointment);

Console.WriteLine($"Resulting JSON: {serialized}");

Appointment deserializedAppointment =
    JsonSerializer.Deserialize<Appointment>(serialized)!;

bool valuesAreTheSame = originalAppointment == deserializedAppointment;
Console.WriteLine($"""
    Original record has the same values as the deserialized record: {valuesAreTheSame}
    """);

        Dim originalAppointment As New Appointment With {
            .Id = Guid.NewGuid(),
            .Description = "Take dog to veterinarian.",
            .DateValue = New DateOnly(2002, 1, 13),
            .StartTime = New TimeOnly(5, 3, 1),
            .EndTime = New TimeOnly(5, 3, 1)
}
        Dim serialized As String = JsonSerializer.Serialize(originalAppointment)

        Console.WriteLine($"Resulting JSON: {serialized}")

        Dim deserializedAppointment As Appointment =
            JsonSerializer.Deserialize(Of Appointment)(serialized)

        Dim valuesAreTheSame As Boolean =
            (originalAppointment.DateValue = deserializedAppointment.DateValue AndAlso
            originalAppointment.StartTime = deserializedAppointment.StartTime AndAlso
            originalAppointment.EndTime = deserializedAppointment.EndTime AndAlso
            originalAppointment.Id = deserializedAppointment.Id AndAlso
            originalAppointment.Description = deserializedAppointment.Description)

        Console.WriteLine(
            $"Original object has the same values as the deserialized object: {valuesAreTheSame}")

Im obigen Code:

  • Ein Appointment-Objekt wird instanziiert und der appointment Variablen zugewiesen.
  • Die appointment-Instanz wird mithilfe von JsonSerializer.Serialize zu JSON serialisiert.
  • Der resultierende JSON-Code wird in die Konsole geschrieben.
  • Der JSON-Code wird mithilfe von JsonSerializer.Deserialize in eine neue Instanz des Typs Appointment deserialisiert.
  • Die ursprüngliche Instanz wird mit der neu deserialisierten Instanz verglichen, um zu überprüfen, ob sie gleich sind.
  • Das Ergebnis des Vergleichs wird in die Konsole geschrieben.

Weitere Informationen finden Sie unter Wie man JSON in .NET serialisiert und deserialisiert.

Arbeiten mit TimeSpan und DateTime

TimeOnly kann aus TimeSpan erstellt und in ein TimeSpan-Element konvertiert werden. Außerdem kann TimeOnly mit DateTime verwendet werden, entweder um die TimeOnly-Instanz zu erstellen, oder um eine DateTime-Instanz zu erstellen, solange ein Datum angegeben wird.

Im folgenden Beispiel wird ein TimeOnly-Objekt aus einem TimeSpan-Element erstellt und dann wieder zurückkonvertiert:

// TimeSpan must in the range of 00:00:00.0000000 to 23:59:59.9999999
var theTime = TimeOnly.FromTimeSpan(new TimeSpan(23, 59, 59));
var theTimeSpan = theTime.ToTimeSpan();

Console.WriteLine($"Variable '{nameof(theTime)}' is {theTime}");
Console.WriteLine($"Variable '{nameof(theTimeSpan)}' is {theTimeSpan}");

/* This example produces the following output:
 * 
 * Variable 'theTime' is 11:59 PM
 * Variable 'theTimeSpan' is 23:59:59
*/

' TimeSpan must in the range of 00:00:00.0000000 to 23:59:59.9999999
Dim theTime = TimeOnly.FromTimeSpan(New TimeSpan(23, 59, 59))
Dim theTimeSpan = theTime.ToTimeSpan()

Console.WriteLine($"Variable '{NameOf(theTime)}' is {theTime}")
Console.WriteLine($"Variable '{NameOf(theTimeSpan)}' is {theTimeSpan}")

' This example produces the following output
' 
' Variable 'theTime' is 11:59 PM
' Variable 'theTimeSpan' is 23:59:59

Im folgenden Beispiel wird eine DateTime aus einem TimeOnly-Objekt erstellt, wobei ein beliebiges Datum ausgewählt ist:

var theTime = new TimeOnly(11, 25, 46);   // 11:25 AM and 46 seconds
var theDate = new DateOnly(2015, 10, 21); // October 21, 2015
var theDateTime = theDate.ToDateTime(theTime);
var reverseTime = TimeOnly.FromDateTime(theDateTime);

Console.WriteLine($"Date only is {theDate}");
Console.WriteLine($"Time only is {theTime}");
Console.WriteLine();
Console.WriteLine($"Combined to a DateTime type, the value is {theDateTime}");
Console.WriteLine($"Converted back from DateTime, the time is {reverseTime}");

/* This example produces the following output:
 * 
 * Date only is 10/21/2015
 * Time only is 11:25 AM
 * 
 * Combined to a DateTime type, the value is 10/21/2015 11:25:46 AM
 * Converted back from DateTime, the time is 11:25 AM
*/

Dim theTime = New TimeOnly(11, 25, 46) ' 11:   25 PM And 46 seconds
Dim theDate = New DateOnly(2015, 10, 21) ' October 21, 2015
Dim theDateTime = theDate.ToDateTime(theTime)
Dim reverseTime = TimeOnly.FromDateTime(theDateTime)

Console.WriteLine($"Date only is {theDate}")
Console.WriteLine($"Time only is {theTime}")
Console.WriteLine()
Console.WriteLine($"Combined to a DateTime type, the value is {theDateTime}")
Console.WriteLine($"Converted back from DateTime, the time is {reverseTime}")

' This example produces the following output
' 
' Date only is 10/21/2015
' Time only is 11:25 AM
' 
' Combined to a DateTime type, the value is 10/21/2015 11:25:46 AM
' Converted back from DateTime, the time is 11:25 AM

Arithmetische Operatoren und Vergleichen von TimeOnly

Zwei TimeOnly Instanzen können miteinander verglichen werden, und Sie können die IsBetween-Methode verwenden, um zu überprüfen, ob eine Zeit zwischen zwei anderen Zeiten liegt. Wenn ein Additions- oder Subtraktionsoperator für ein TimeOnly-Element verwendet wird, wird eine TimeSpan-Angabe zurückgegeben, die eine Dauer darstellt.

var start = new TimeOnly(10, 12, 01); // 10:12:01 AM
var end = new TimeOnly(14, 00, 53); // 02:00:53 PM

var outside = start.AddMinutes(-3);
var inside = start.AddMinutes(120);

Console.WriteLine($"Time starts at {start} and ends at {end}");
Console.WriteLine($" Is {outside} between the start and end? {outside.IsBetween(start, end)}");
Console.WriteLine($" Is {inside} between the start and end? {inside.IsBetween(start, end)}");
Console.WriteLine($" Is {start} less than {end}? {start < end}");
Console.WriteLine($" Is {start} greater than {end}? {start > end}");
Console.WriteLine($" Does {start} equal {end}? {start == end}");
Console.WriteLine($" The time between {start} and {end} is {end - start}");

/* This example produces the following output:
 * 
 * Time starts at 10:12 AM and ends at 2:00 PM
 *  Is 10:09 AM between the start and end? False
 *  Is 12:12 PM between the start and end? True
 *  Is 10:12 AM less than 2:00 PM? True
 *  Is 10:12 AM greater than 2:00 PM? False
 *  Does 10:12 AM equal 2:00 PM? False
 *  The time between 10:12 AM and 2:00 PM is 03:48:52
*/

Dim startDate = New TimeOnly(10, 12, 1) ' 10:12:01 AM
Dim endDate = New TimeOnly(14, 0, 53) ' 02:00:53 PM

Dim outside = startDate.AddMinutes(-3)
Dim inside = startDate.AddMinutes(120)

Console.WriteLine($"Time starts at {startDate} and ends at {endDate}")
Console.WriteLine($" Is {outside} between the start and end? {outside.IsBetween(startDate, endDate)}")
Console.WriteLine($" Is {inside} between the start and end? {inside.IsBetween(startDate, endDate)}")
Console.WriteLine($" Is {startDate} less than {endDate}? {startDate < endDate}")
Console.WriteLine($" Is {startDate} greater than {endDate}? {startDate > endDate}")
Console.WriteLine($" Does {startDate} equal {endDate}? {startDate = endDate}")
Console.WriteLine($" The time between {startDate} and {endDate} is {endDate - startDate}")

' This example produces the following output
' 
' Time starts at 10:12 AM And ends at 2:00 PM
'  Is 10:09 AM between the start And end? False
'  Is 12:12 PM between the start And end? True
'  Is 10:12 AM less than 2:00 PM? True
'  Is 10:12 AM greater than 2:00 PM? False
'  Does 10:12 AM equal 2:00 PM? False
'  The time between 10:12 AM and 2:00 PM is 03:48:52