Freigeben über

Verwenden der DateOnly- und TimeOnly-Strukturen

  • Artikel

Die DateOnly- und TimeOnly-Strukturen wurden mit .NET 6 eingeführt und stellen 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 Werte darzustellen:

  • Ein vollständiges Datum und eine vollständige Uhrzeit.
  • Ein Datum ohne Berücksichtigung der Uhrzeit.
  • Eine Uhrzeit ohne Berücksichtigung des Datums.

DateOnly und TimeOnly sind Typen, die diese bestimmten Teile eines DateTime-Typs darstellen.

Wichtig

DateOnly- und TimeOnly-Typen sind in .NET Framework nicht verfügbar.

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 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.

DateOnly weist einen Bereich von 0001-01-01 bis 9999-12-31 auf, ebenso 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 Generieren verwendet wurde. Sie können z. B. das Datum aus einem hebräischen Kalender erstellen, aber das Datum wird in den gregorianischen Kalender konvertiert:

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 DateOnly zu erfahren:

Konvertieren von DateTime in DateOnly

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

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, die zum Anpassen einer DateOnly-Struktur verwendet werden: AddDays, AddMonths und AddYears. Jede Methode nimmt einen ganzzahligen Parameter an und erhöht das Datum um diese Angabe. Wenn eine negative Zahl angegeben wird, wird das Datum um diese Angabe verringert. Die Methoden geben eine neue Instanz von DateOnly zurü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 datumsbasierte .NET-Standardformatierungsmuster 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 beispielsweise überprüfen, ob ein Datum vor oder nach einem anderen Datum 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. 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 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.

TimeOnly-Beispiele

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

Konvertieren von DateTime in TimeOnly

Verwenden Sie die statische TimeOnly.FromDateTime-Methode, um einen TimeOnly-Typ aus einem DateTime-Typ 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 als AddHours auch AddMinutes nehmen einen ganzzahligen Parameter an und passen den Wert entsprechend an. Sie können einen negativen Wert zum Subtrahieren und einen positiven Wert zum Addieren hinzufügen. Von den Methoden wird eine neue Instanz von TimeOnly zurückgegeben, da die Struktur unveränderlich ist. Die Add-Methode nimmt einen TimeSpan-Parameter an und addiert den Wert dann zum TimeOnly-Wert oder subtrahiert ihn.

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

Ab .NET 7 unterstützt System.Text.Json das Serialisieren und Deserialisieren von DateOnly- und TimeOnly-Typen. Sehen Sie sich das folgende Objekt an:

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}")

Für den Code oben gilt:

  • Ein Appointment-Objekt wird instanziiert und der Variablen appointment 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 der Konsole ausgegeben.

Weitere Informationen finden Sie unter Serialisieren und Deserialisieren von JSON-Daten in .NET.

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 ein DateTime-Element aus einem TimeOnly-Objekt erstellt, wobei ein beliebiges Datum ausgewählt wird:

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 Uhrzeit zwischen zwei anderen Zeitangaben 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