Dela via

Så här använder du strukturerna DateOnly och TimeOnly

  • Artikel

Strukturerna DateOnly och TimeOnly introducerades med .NET 6 och representerar ett specifikt datum respektive tid på dagen. Före .NET 6, och alltid i .NET Framework, använde utvecklare DateTime typ (eller något annat alternativ) för att representera något av följande:

  • En hel datum och tid.
  • Ett datum som bortser från tiden.
  • En tid som bortser från datumet.

DateOnly och TimeOnly är typer som representerar de specifika delarna av en DateTime typ.

Viktig

DateOnly och TimeOnly typer är inte tillgängliga för .NET Framework.

DateOnly-strukturen

Den DateOnly strukturen representerar ett specifikt datum, utan tid. Eftersom den inte har någon tidskomponent representerar den ett datum från dagens början till slutet av dagen. Den här strukturen är perfekt för att lagra specifika datum, till exempel ett födelsedatum, ett jubileumsdatum eller affärsrelaterade datum.

Även om du kan använda DateTime när du ignorerar tidskomponenten finns det några fördelar med att använda DateOnly över DateTime:

  • Strukturen DateTime kan övergå till föregående eller nästa dag på grund av en tidszon. DateOnly kan inte förskjutas av en tidszon och representerar alltid det datum som angavs.

  • Serialisering av en DateTime struktur innehåller tidskomponenten, vilket kan dölja avsikten med data. Dessutom serialiserar DateOnly mindre data.

  • När koden interagerar med en databas, till exempel SQL Server, lagras hela datum vanligtvis som date datatyp, vilket inte inkluderar en tid. DateOnly matchar databastypen bättre.

DateOnly har ett intervall från 0001-01-01 till 9999-12-31, precis som DateTime. Du kan ange en specifik kalender i DateOnly konstruktorn. Ett DateOnly-objekt representerar dock alltid ett datum i den proleptiska gregorianska kalendern, oavsett vilken kalender som användes för att konstruera den. Du kan till exempel skapa datumet från en hebreisk kalender, men datumet konverteras till gregoriansk:

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

Använd följande exempel för att lära dig mer om DateOnly:

Konvertera DateTime till DateOnly

Använd den DateOnly.FromDateTime statiska metoden för att skapa en DateOnly typ från en DateTime typ, vilket visas i följande kod:

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

Lägga till eller subtrahera dagar, månader, år

Det finns tre metoder som används för att justera en DateOnly struktur: AddDays, AddMonthsoch AddYears. Varje metod tar en heltalsparameter och ökar datumet med den mätningen. Om ett negativt tal anges minskas datumet med den mätningen. Metoderna returnerar en ny instans av DateOnlyeftersom strukturen är oföränderlig.

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

Parsa och formatera DateOnly

DateOnly kan parsas från en sträng, precis som DateTime struktur. Alla standard .NET-datumbaserade parsningstoken fungerar med DateOnly. När du konverterar en DateOnly typ till en sträng kan du också använda standardformateringsmönster för .NET-datum. Mer information om formateringssträngar finns i Standard-datum- och tidsformatsträngar.

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

Jämför DateOnly

DateOnly kan jämföras med andra exempel. Du kan till exempel kontrollera om ett datum är före eller efter ett annat, eller om ett datum i dag matchar ett visst datum.

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

Strukturen TimeOnly

Den TimeOnly strukturen representerar ett tidsvärde, till exempel en daglig väckarklocka eller vilken tid du äter lunch varje dag. TimeOnly är begränsat till intervallet 00:00:00.00000000 - 23:59:59.99999999, en viss tid på dagen.

Innan den TimeOnly typen introducerades använde programmerare vanligtvis antingen den DateTime typen eller den TimeSpan typen för att representera en viss tid. Att använda dessa strukturer för att simulera en tid utan datum kan dock medföra vissa problem, vilket TimeOnly löser:

  • TimeSpan representerar förfluten tid, till exempel tid som mäts med ett stoppur. Det övre intervallet är mer än 29 000 år och dess värde kan vara negativt för att indikera att det rör sig bakåt i tiden. En negativ TimeSpan indikerar inte en viss tid på dagen.

  • Om TimeSpan används som en tid på dagen finns det en risk att det kan manipuleras till ett värde utanför 24-timmarsdagen. TimeOnly har inte den här risken. Om till exempel en anställds arbetsskift börjar kl. 18:00 och varar i 8 timmar, innebär att lägga till 8 timmar att tiden rullar över till 2:00 i TimeOnly-strukturen.

  • Användning av DateTime under en tid på dagen kräver att ett godtyckligt datum associeras med tiden och sedan ignoreras senare. Det är vanligt att välja DateTime.MinValue (0001-01-01) som datum, men om timmar subtraheras från värdet DateTime kan ett OutOfRange undantag inträffa. TimeOnly har inte det här problemet eftersom tiden rullar framåt och bakåt runt tidsramen på 24 timmar.

  • Serialisering av en DateTime struktur innehåller datumkomponenten, vilket kan dölja avsikten med data. Dessutom serialiserar TimeOnly mindre data.

TimeOnly-exempel

Använd följande exempel för att lära dig mer om TimeOnly:

Konvertera DateTime till TimeOnly

Använd den TimeOnly.FromDateTime statiska metoden för att skapa en TimeOnly typ från en DateTime typ, vilket visas i följande kod:

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

Lägg till eller subtrahera tid

Det finns tre metoder som används för att justera en TimeOnly struktur: AddHours, AddMinutesoch Add. Både AddHours och AddMinutes ta en heltalsparameter och justera värdet därefter. Du kan använda ett negativt värde för att subtrahera och ett positivt värde att lägga till. Metoderna returnerar en ny instans av TimeOnly, eftersom strukturen är oföränderlig. Metoden Add tar en TimeSpan-parameter och lägger till eller subtraherar värdet från det TimeOnly värdet.

Eftersom TimeOnly endast representerar en 24-timmarsperiod, rullar den över framåt eller bakåt på lämpligt sätt när du lägger till värden som anges i dessa tre metoder. Om du till exempel använder värdet 01:30:00 för att representera 01:30 och sedan lägger till -4 timmar från den perioden, rullas det bakåt till 21:30:00, som är 21:30. Det finns metodöverlagringar för AddHours, AddMinutesoch Add som registrerar antalet dagar som har rullats över.

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

Parsa och formatera TimeOnly

TimeOnly kan parsas från en sträng, precis som DateTime struktur. Alla standard .NET-tidsbaserade parsningstoken fungerar med TimeOnly. När du konverterar en TimeOnly typ till en sträng kan du också använda standardformateringsmönster för .NET-datum. Mer information om formateringssträngar finns i Standard-datum- och tidsformatsträngar.

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

Serialisera typerna DateOnly och TimeOnly

Med .NET 7+ stöder System.Text.Json serialisering och deserialisering av DateOnly och TimeOnly typer. Tänk på följande 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

I följande exempel serialiseras ett Appointment-objekt, visar den resulterande JSON:n och deserialiserar den sedan tillbaka till en ny instans av Appointment typ. Slutligen jämförs de ursprungliga och nyligen deserialiserade instanserna för likhet och resultaten skrivs till konsolen:

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

I föregående kod:

  • Ett Appointment objekt instansieras och tilldelas till variabeln appointment.
  • Den appointment instansen serialiseras till JSON med hjälp av JsonSerializer.Serialize.
  • Den resulterande JSON-filen skrivs till konsolen.
  • JSON deserialiseras tillbaka till en ny instans av Appointment med hjälp av JsonSerializer.Deserialize.
  • De ursprungliga och nyligen deserialiserade instanserna jämförs för likhet.
  • Resultatet av jämförelsen skrivs till konsolen.

Mer information finns i Så här serialiserar och deserialiserar du JSON i .NET.

Arbeta med TimeSpan och DateTime

TimeOnly kan skapas från och konverteras till en TimeSpan. Dessutom kan TimeOnly användas med en DateTime, antingen för att skapa TimeOnly-instansen eller för att skapa en DateTime instans så länge ett datum anges.

I följande exempel skapas ett TimeOnly objekt från en TimeSpanoch konverterar det sedan tillbaka:

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

I följande exempel skapas en DateTime från ett TimeOnly objekt, med ett godtyckligt datum valt:

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

Aritmetiska operatorer och jämförelse av TimeOnly

Två TimeOnly instanser kan jämföras med varandra och du kan använda metoden IsBetween för att kontrollera om en tid är mellan två andra gånger. När en additions- eller subtraktionsoperator används på en TimeOnlyreturneras en TimeSpan som representerar en tidsperiod.

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