Jak používat struktury DateOnly a TimeOnly
V DateOnly rozhraní .NET 6 byly zavedeny struktury TimeOnly a představují konkrétní datum nebo čas v uvedeném pořadí. Před .NET 6 a vždy v rozhraní .NET Framework použili DateTime vývojáři typ (nebo jinou alternativu), aby představovali jednu z následujících možností:
- Celé datum a čas.
- Datum, které ignoruje čas.
- Čas, který ignoruje datum.
DateOnly
a TimeOnly
jsou typy, které představují tyto konkrétní části DateTime
typu.
DateOnly – struktura
Struktura DateOnly představuje konkrétní datum bez času. Vzhledem k tomu, že nemá žádnou časovou komponentu, představuje datum od začátku dne do konce dne. Tato struktura je ideální pro ukládání konkrétních kalendářních dat, jako jsou datum narození, datum výročí nebo obchodní data.
I když byste mohli použít DateTime
při ignorování časové komponenty, existuje několik výhod, které můžete použítDateOnly
:DateTime
Pokud
DateTime
je struktura posunutá časovým pásmem, může se vrátit do předchozího nebo následujícího dne.DateOnly
nemůže být posunut časovým pásmem a vždy představuje datum, které bylo nastaveno.Serializace
DateTime
struktury zahrnuje časovou komponentu, která může zakrýt záměr dat.DateOnly
Serializuje také méně dat.Když kód komunikuje s databází, jako je SQL Server, jsou všechna kalendářní data obecně uložena jako
date
datový typ, který nezahrnuje čas.DateOnly
odpovídá lepšímu typu databáze.
DateOnly
má rozsah od 0001-01-01 do 9999-12-31, stejně jako DateTime
. V konstruktoru DateOnly
můžete zadat konkrétní kalendář. DateOnly
Objekt však vždy představuje datum v proleptickém gregoriánském kalendáři bez ohledu na to, který kalendář byl použit k jeho vytvoření. Můžete například vytvořit datum z hebrejského kalendáře, ale datum se převede na gregoriánský:
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
Příklady DateOnly
Další informace najdete DateOnly
v následujících příkladech:
- Převod data a času na DateOnly
- Sčítání nebo odečítání dnů, měsíců, roků
- Parsování a formátování DateOnly
- Porovnat DateOnly
Převod data a času na DateOnly
DateOnly.FromDateTime Pomocí statické metody vytvořte DateOnly
typ z DateTime
typu, jak je znázorněno v následujícím kódu:
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
Sčítání nebo odečítání dnů, měsíců, roků
K úpravě DateOnly struktury se používají tři metody: AddDays, AddMonthsa AddYears. Každá metoda přebírá celočíselné parametry a zvyšuje datum podle tohoto měření. Pokud je zadané záporné číslo, datum se zmenší tímto měřením. Metody vrací novou instanci DateOnly
, protože struktura je neměnná.
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
Parsování a formátování DateOnly
DateOnly lze analyzovat z řetězce, stejně jako struktura DateTime . Všechny standardní tokeny analýzy založené na datech .NET fungují s DateOnly
. Při převodu DateOnly
typu na řetězec můžete použít standardní vzory formátování založené na datech .NET. Další informace o formátování řetězců naleznete v tématu Standardní řetězce formátu data a času.
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
Porovnat DateOnly
DateOnly lze porovnat s jinými instancemi. Můžete například zkontrolovat, jestli je datum před nebo po jiném, nebo jestli datum dnes odpovídá určitému datu.
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
TimeOnly – struktura
Struktura TimeOnly představuje denní hodnotu, například denní budík nebo čas, kdy každý den sníte oběd. TimeOnly
je omezena na rozsah 00:00:00.000000 - 23:59:59.999999999, určitý čas dne.
Před uvedením TimeOnly
typu programátoři obvykle použili DateTime typ nebo TimeSpan typ k vyjádření určitého času. Použití těchto struktur k simulaci času bez data však může představovat některé problémy, které TimeOnly
řeší:
TimeSpan
představuje uplynulý čas, například čas měřený pomocí stopek. Horní oblast je více než 29 000 let a její hodnota může být záporná, aby bylo možné označit posun v čase zpět. ZápornáTimeSpan
hodnota neuvádí konkrétní čas dne.Pokud
TimeSpan
se používá jako denní čas, existuje riziko, že může být manipulováno s hodnotou mimo 24hodinový den.TimeOnly
tohle riziko nemá. Pokud například pracovní směna zaměstnance začíná v 18:00 a trvá 8 hodin, přidání 8 hodin doTimeOnly
struktury se převrací na 2:00.Použití
DateTime
pro čas dne vyžaduje, aby bylo k času přidruženo libovolné datum a později ignorováno. Jako datum je běžné zvolitDateTime.MinValue
(0001-01-01), ale pokud jsou hodiny odečteny odDateTime
hodnoty, může dojít k výjimceOutOfRange
.TimeOnly
nemá tento problém, protože se čas posunuje dopředu a dozadu kolem 24hodinového časového rámce.Serializace
DateTime
struktury zahrnuje komponentu data, která může překrývat záměr dat.TimeOnly
Serializuje také méně dat.
Příklady TimeOnly
Další informace najdete TimeOnly
v následujících příkladech:
- Převod data a času na ČasOnly
- Sčítání nebo odečítání času
- Parsování a formátování TimeOnly
- Práce s TimeSpan a DateTime
- Aritmetické operátory a porovnání TimeOnly
Převod data a času na ČasOnly
TimeOnly.FromDateTime Pomocí statické metody vytvořte TimeOnly
typ z DateTime
typu, jak je znázorněno v následujícím kódu:
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
Sčítání nebo odečítání času
K úpravě TimeOnly struktury se používají tři metody: AddHours, AddMinutesa Add. A AddHours
AddMinutes
převezměte celočíselnou hodnotu a odpovídajícím způsobem upravte hodnotu. K odečtení a kladné hodnoty můžete použít zápornou hodnotu, kterou chcete přičíst. Metody vracejí novou instanci TimeOnly
je vrácena, protože struktura je neměnná. Metoda Add
vezme TimeSpan parametr a přičte nebo odečte hodnotu z TimeOnly
hodnoty.
Vzhledem k tomu TimeOnly
, že představuje pouze 24hodinovou dobu, převrácí se dopředu nebo dozadu správně při přidávání hodnot zadaných do těchto tří metod. Pokud například použijete hodnotu 01:30:00
představující hodnotu 1:30, přidáte -4 hodiny od tohoto období, vrátí se zpět na 21:30:00
hodnotu 9:30. Existují přetížení metody pro AddHours
, AddMinutes
a Add
které zachycují počet dnů vrácených.
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
Parsování a formátování TimeOnly
TimeOnly lze analyzovat z řetězce, stejně jako struktura DateTime . Všechny standardní tokeny analýzy založené na čase .NET fungují s TimeOnly
. Při převodu TimeOnly
typu na řetězec můžete použít standardní vzory formátování založené na datech .NET. Další informace o formátování řetězců naleznete v tématu Standardní řetězce formátu data a času.
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
Serializace typů DateOnly a TimeOnly
S .NET 7+ System.Text.Json
podporuje serializaci a deserializaci DateOnly a TimeOnly typy. Představte si následující 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
Následující příklad serializuje Appointment
objekt, zobrazí výsledný JSON a pak deserializuje zpět do nové instance Appointment
typu. Nakonec se původní a nově deserializované instance porovnávají s rovností a výsledky se zapisují do konzoly:
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}")
V předchozím kódu:
- Vytvoří
Appointment
instanci objektuappointment
a přiřadí se k proměnné. - Instance je serializována
appointment
do FORMÁTU JSON pomocí JsonSerializer.Serialize. - Výsledný json se zapíše do konzoly.
- JSON se deserializuje zpět do nové instance
Appointment
typu pomocí JsonSerializer.Deserialize. - Původní a nově deserializované instance se porovnávají s rovností.
- Výsledek porovnání se zapíše do konzoly.
Další informace naleznete v tématu Jak serializovat a deserializovat JSON v .NET.
Práce s TimeSpan a DateTime
TimeOnly lze vytvořit z a převést na TimeSpan. TimeOnly
Lze také použít s , DateTimebuď k vytvoření TimeOnly
instance, nebo k vytvoření DateTime
instance, pokud je k dispozici datum.
Následující příklad vytvoří TimeOnly
objekt z objektu TimeSpan
a pak ho převede zpět:
// 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
Následující příklad vytvoří z objektu DateTime
TimeOnly
libovolné datum s vybraným datem:
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
Aritmetické operátory a porovnání TimeOnly
Dvě TimeOnly instance se dají vzájemně porovnat a pomocí IsBetween metody můžete zkontrolovat, jestli je čas mezi dvěma časy. Při použití operátoru sčítání nebo odčítání u operátoru TimeOnly
, je vrácen a TimeSpan představuje dobu trvání.
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
Váš názor
https://aka.ms/ContentUserFeedback.
Připravujeme: V průběhu roku 2024 budeme postupně vyřazovat problémy z GitHub coby mechanismus zpětné vazby pro obsah a nahrazovat ho novým systémem zpětné vazby. Další informace naleznete v tématu:Odeslat a zobrazit názory pro