DateTime Struktúra

Definíció

public value class DateTime : IComparable, IComparable<DateTime>, IConvertible, IEquatable<DateTime>, IFormattable

public value class DateTime : IComparable, IComparable<DateTime>, IConvertible, IEquatable<DateTime>, IParsable<DateTime>, ISpanFormattable, ISpanParsable<DateTime>, IUtf8SpanFormattable, System::Runtime::Serialization::ISerializable

public value class DateTime : IComparable, IComparable<DateTime>, IConvertible, IEquatable<DateTime>, IFormattable, System::Runtime::Serialization::ISerializable

public value class DateTime : IComparable, IComparable<DateTime>, IConvertible, IEquatable<DateTime>, ISpanFormattable, System::Runtime::Serialization::ISerializable

public value class DateTime : IComparable, IComparable<DateTime>, IConvertible, IEquatable<DateTime>, IParsable<DateTime>, ISpanFormattable, ISpanParsable<DateTime>, System::Runtime::Serialization::ISerializable

public value class DateTime : IComparable, IConvertible, IFormattable

public value class DateTime : IComparable, IComparable<DateTime>, IEquatable<DateTime>, IFormattable

public struct DateTime : IComparable, IComparable<DateTime>, IConvertible, IEquatable<DateTime>, IFormattable

public readonly struct DateTime : IComparable, IComparable<DateTime>, IConvertible, IEquatable<DateTime>, IParsable<DateTime>, ISpanFormattable, ISpanParsable<DateTime>, IUtf8SpanFormattable, System.Runtime.Serialization.ISerializable

public readonly struct DateTime : IComparable, IComparable<DateTime>, IConvertible, IEquatable<DateTime>, IFormattable, System.Runtime.Serialization.ISerializable

public readonly struct DateTime : IComparable, IComparable<DateTime>, IConvertible, IEquatable<DateTime>, ISpanFormattable, System.Runtime.Serialization.ISerializable

public readonly struct DateTime : IComparable, IComparable<DateTime>, IConvertible, IEquatable<DateTime>, IParsable<DateTime>, ISpanFormattable, ISpanParsable<DateTime>, System.Runtime.Serialization.ISerializable

public struct DateTime : IComparable, IComparable<DateTime>, IConvertible, IEquatable<DateTime>, IFormattable, System.Runtime.Serialization.ISerializable

[System.Serializable]
public struct DateTime : IComparable, IConvertible, IFormattable

[System.Serializable]
public struct DateTime : IComparable, IComparable<DateTime>, IConvertible, IEquatable<DateTime>, IFormattable, System.Runtime.Serialization.ISerializable

public struct DateTime : IComparable, IComparable<DateTime>, IEquatable<DateTime>, IFormattable

type DateTime = struct
    interface IConvertible
    interface IFormattable

type DateTime = struct
    interface IConvertible
    interface IFormattable
    interface IParsable<DateTime>
    interface ISpanFormattable
    interface ISpanParsable<DateTime>
    interface IUtf8SpanFormattable
    interface ISerializable

type DateTime = struct
    interface IConvertible
    interface IFormattable
    interface ISerializable

type DateTime = struct
    interface IConvertible
    interface ISpanFormattable
    interface IFormattable
    interface ISerializable

type DateTime = struct
    interface IConvertible
    interface IFormattable
    interface IParsable<DateTime>
    interface ISpanFormattable
    interface ISpanParsable<DateTime>
    interface ISerializable

type DateTime = struct
    interface IConvertible
    interface IFormattable
    interface IParsable<DateTime>
    interface ISpanFormattable
    interface ISpanParsable<DateTime>
    interface ISerializable
    interface IUtf8SpanFormattable

[<System.Serializable>]
type DateTime = struct
    interface IFormattable
    interface IConvertible

[<System.Serializable>]
type DateTime = struct
    interface IFormattable
    interface IConvertible
    interface ISerializable

type DateTime = struct
    interface IFormattable

Public Structure DateTime
Implements IComparable, IComparable(Of DateTime), IConvertible, IEquatable(Of DateTime), IFormattable

Public Structure DateTime
Implements IComparable, IComparable(Of DateTime), IConvertible, IEquatable(Of DateTime), IParsable(Of DateTime), ISerializable, ISpanFormattable, ISpanParsable(Of DateTime), IUtf8SpanFormattable

Public Structure DateTime
Implements IComparable, IComparable(Of DateTime), IConvertible, IEquatable(Of DateTime), IFormattable, ISerializable

Public Structure DateTime
Implements IComparable, IComparable(Of DateTime), IConvertible, IEquatable(Of DateTime), ISerializable, ISpanFormattable

Public Structure DateTime
Implements IComparable, IComparable(Of DateTime), IConvertible, IEquatable(Of DateTime), IParsable(Of DateTime), ISerializable, ISpanFormattable, ISpanParsable(Of DateTime)

Public Structure DateTime
Implements IComparable, IConvertible, IFormattable

Public Structure DateTime
Implements IComparable, IComparable(Of DateTime), IEquatable(Of DateTime), IFormattable

Öröklődés

Object

ValueType

DateTime

Attribútumok

SerializableAttribute

Megvalósítás

IComparable IComparable<DateTime> IConvertible IEquatable<DateTime> IFormattable IParsable<DateTime> IParsable<TSelf> ISpanFormattable ISpanParsable<DateTime> IUtf8SpanFormattable ISerializable

Megjegyzések

Áttekintés

Az DateTime értéktípus dátumokat és időpontokat jelöl, amelyek értéke a Gergely-naptár szerint 00:00:00 (éjfél), 0001. január 1., Anno Domini (Közös Időszámítás szerint), és 23:59:59, 9999. december 31. között mozog.

Az időértékeket 100 nanoszekundumos egységekben, úgynevezett tikkszelvényekben mérik. Egy adott dátum az GregorianCalendar naptárban az időegységek száma, amelyek az i.sz. 0001. január 1-jei éjfél óta eltelt időt mérik. A szám kizárja azokat a kullancsokat, amelyeket szökő másodpercek alatt adnának hozzá. A 31241376000000000L érték például a 0100. január 01., péntek 12:00:00 éjféli dátumot jelöli. Az DateTime érték mindig explicit vagy alapértelmezett naptár kontextusában van kifejezve.

Példakódra mutató gyorshivatkozások

Ez a cikk több példát is tartalmaz, amelyek a következő típust DateTime használják:

Inicializálási példák

• Konstruktor meghívása
• Az implicit paraméter nélküli konstruktor meghívása
• Hozzárendelés visszatérési értékből
• Dátumot és időt jelképező sztring elemzése
• Visual Basic szintaxis dátum és idő inicializálásához

Objektumok formázása DateTime példákként sztringekké

• Az alapértelmezett dátum időformátumának használata
• Dátum és idő formázása egy adott kultúra használatával
• Dátum és idő formázása szabványos vagy egyéni formázási sztring használatával
• Adjon meg mind egy formátumsztringet, mind egy adott kultúrát
• Dátumidő formázása a webszolgáltatások ISO 8601 szabványának használatával

Sztringek elemzése például objektumként DateTime

• Használd a Parse vagy TryParse sztring konvertálásához dátummá és idővé
• Használjon ParseExact vagy TryParseExact elemet egy ismert formátumú sztring konvertálására
• Átalakítás az ISO 8601 formátumról dátumra és időpontra

DateTime megoldási példák

• A dátum- és időértékek feloldásának megismerése
• Az egyenlőség összehasonlítása egy tűréshatáron belül

Példák a kultúra és a naptárak használatára

• Dátum- és időértékek megjelenítése kultúraspecifikus naptárak használatával
• Sztringek elemzése kultúraspecifikus naptár szerint
• Dátum és idő inicializálása egy adott kultúra naptárából
• Dátum- és időtulajdonságok elérése egy adott kultúra naptárával
• Az év hetének lekérése kultúraspecifikus naptárak használatával

Adatmegőrzési példák

• Dátum- és időértékek tárolása sztringként a helyi időzónában
• Dátum- és időértékek megőrzése sztringként kulturális és időbeli invariáns formátumban
• Dátum- és időértékek megőrzése egész számként
• Dátum- és időértékek megőrzése a XmlSerializer

DateTime-objektum inicializálása

A kezdeti értékeket többféleképpen rendelheti hozzá egy új DateTime értékhez:

• Meghívhat egy konstruktort, amely argumentumokat ad meg az értékekhez, vagy használja az implicit paraméter nélküli konstruktort.
• DateTime Tulajdonság vagy metódus visszatérési értékének hozzárendelése.
• Sztring ábrázolásból DateTime érték elemzése.
• Visual Basic-specifikus nyelvi funkciók használata a példányosításhoz DateTime.

Az alábbi kódrészletek példákat mutatnak az egyes kódokra.

Konstruktorok meghívása

Ön meghívja a DateTime konstruktor bármelyik túlterhelését, amely megadja a dátum- és időérték elemeit (például az évet, a hónapot és a napot, vagy az időegységek számát). Az alábbi kód egy adott dátumot hoz létre a DateTime konstruktor használatával, amely megadja az évet, a hónapot, a napot, az órát, a percet és a másodpercet.

Dim date1 As New Date(2008, 5, 1, 8, 30, 52)

var date1 = new DateTime(2008, 5, 1, 8, 30, 52);
Console.WriteLine(date1);

let date1 = DateTime(2008, 5, 1, 8, 30, 52)
printfn $"{date1}"

Meghívja a DateTime struktúra implicit paraméter nélküli konstruktorát, ha inicializálni szeretné DateTime az alapértelmezett értékre. (Egy értéktípus implicit paraméter nélküli konstruktorával kapcsolatos részletekért lásd: Értéktípusok.) Egyes fordítók az érték deklarálását DateTime is támogatják anélkül, hogy explicit módon hozzárendelnek hozzá értéket. Ha explicit inicializálás nélkül hoz létre értéket, az alapértelmezett értéket is eredményezi. Az alábbi példa a C# és a Visual Basic implicit, paraméter nélküli konstruktorát, valamint a Visual Basic hozzárendelés nélküli deklarációját mutatja be.

Dim dat1 As DateTime
' The following method call displays 1/1/0001 12:00:00 AM.
Console.WriteLine(dat1.ToString(System.Globalization.CultureInfo.InvariantCulture))
' The following method call displays True.
Console.WriteLine(dat1.Equals(Date.MinValue))

Dim dat2 As New DateTime()
' The following method call displays 1/1/0001 12:00:00 AM.
Console.WriteLine(dat2.ToString(System.Globalization.CultureInfo.InvariantCulture))
' The following method call displays True.
Console.WriteLine(dat2.Equals(Date.MinValue))

var dat1 = new DateTime();
// The following method call displays 1/1/0001 12:00:00 AM.
Console.WriteLine(dat1.ToString(System.Globalization.CultureInfo.InvariantCulture));
// The following method call displays True.
Console.WriteLine(dat1.Equals(DateTime.MinValue));

let dat1 = DateTime()

// The following method call displays 1/1/0001 12:00:00 AM.
printfn $"{dat1.ToString System.Globalization.CultureInfo.InvariantCulture}"

// The following method call displays True.
printfn $"{dat1.Equals DateTime.MinValue}"

Számított érték hozzárendelése

Az objektumhoz hozzárendelhet DateTime egy tulajdonság vagy metódus által visszaadott dátum- és időértéket. Az alábbi példa az aktuális dátumot és időt, az aktuális egyezményes világidőt (UTC) és az aktuális dátumot három új DateTime változóhoz rendeli.

Dim date1 As Date = Date.Now
Dim date2 As Date = Date.UtcNow
Dim date3 As Date = Date.Today

DateTime date1 = DateTime.Now;
DateTime date2 = DateTime.UtcNow;
DateTime date3 = DateTime.Today;

let date1 = DateTime.Now
let date2 = DateTime.UtcNow
let date3 = DateTime.Today

Dátumot és időt ábrázoló karakterlánc elemzése

A Parse, ParseExact, TryParseés TryParseExact metódusok mindegyike átalakít egy sztringet annak megfelelő dátum- és időértékké. Az alábbi példák a Parse és ParseExact módszereket használják egy sztring elemzésére és annak DateTime értékké alakítására. A második formátum az ISO 8601 szabvány által támogatott űrlapot használja a dátum és idő sztringformátumban való ábrázoláshoz. Ezt a szabványos megjelenítést gyakran használják a webszolgáltatások dátumadatainak átvitelére.

Dim dateString As String = "5/1/2008 8:30:52 AM"
Dim date1 As Date = Date.Parse(dateString,
                       System.Globalization.CultureInfo.InvariantCulture)
Dim iso8601String As String = "20080501T08:30:52Z"
Dim dateISO8602 As Date = DateTime.ParseExact(iso8601String, "yyyyMMddTHH:mm:ssZ",
                              System.Globalization.CultureInfo.InvariantCulture)
Console.WriteLine(dateISO8602)

var dateString = "5/1/2008 8:30:52 AM";
DateTime date1 = DateTime.Parse(dateString,
                          System.Globalization.CultureInfo.InvariantCulture);
var iso8601String = "20080501T08:30:52Z";
DateTime dateISO8602 = DateTime.ParseExact(iso8601String, "yyyyMMddTHH:mm:ssZ",
                                System.Globalization.CultureInfo.InvariantCulture);

let dateString = "5/1/2008 8:30:52 AM"
let date1 = DateTime.Parse(dateString, System.Globalization.CultureInfo.InvariantCulture)
let iso8601String = "20080501T08:30:52Z"
let dateISO8602 = DateTime.ParseExact(iso8601String, "yyyyMMddTHH:mm:ssZ", System.Globalization.CultureInfo.InvariantCulture)

A TryParse és TryParseExact metódusok azt jelzik, hogy egy karaktersorozat érvényes ábrázolása-e egy DateTime értéknek, és ha igen, elvégzik az átalakítást.

A Visual Basic nyelvspecifikus szintaxisa

Az alábbi Visual Basic utasítás inicializál egy új DateTime értéket.

Dim date1 As Date = #5/1/2008 8:30:52AM#

DateTime-értékek és sztring-ábrázolásuk

Belsőleg minden DateTime érték a 0001. január 1-jei éjféltől eltelt 100 nanoszekundumos intervallumok számaként jelenik meg. A tényleges DateTime érték független az érték megjelenítési módjától. A DateTime érték megjelenése egy olyan formázási művelet eredménye, amely egy értéket szöveges formátumúvá alakít.

A dátum- és időértékek megjelenése a kultúrától, a nemzetközi szabványoktól, az alkalmazáskövetelményektől és a személyes preferenciától függ. A DateTime struktúra rugalmasságot biztosít a dátum- és időértékek formázásához a ToString túlterhelési lehetőségei révén. Az alapértelmezett DateTime.ToString() metódus egy dátum- és időérték sztring-ábrázolását adja vissza az aktuális kultúra rövid és hosszú időmintájának használatával. Az alábbi példa az alapértelmezett DateTime.ToString() módszert használja. Megjeleníti a dátumot és az időt az aktuális kultúra rövid és hosszú időmintájának használatával. A en-US kultúra az a számítógép jelenlegi kultúrája, amelyen a példát futtatták.

var date1 = new DateTime(2008, 3, 1, 7, 0, 0);
Console.WriteLine(date1.ToString());
// For en-US culture, displays 3/1/2008 7:00:00 AM

let date1 = DateTime(2008, 3, 1, 7, 0, 0)
printfn $"{date1.ToString()}"
// For en-US culture, displays 3/1/2008 7:00:00 AM

Dim date1 As Date = #3/1/2008 7:00AM#
Console.WriteLine(date1.ToString())
' For en-US culture, displays 3/1/2008 7:00:00 AM

Előfordulhat, hogy a dátumokat egy adott kultúrában kell formáznia, hogy támogassa azokat a webes forgatókönyveket, amelyekben a kiszolgáló más kultúrában van, mint az ügyfél. A DateTime.ToString(IFormatProvider) segítségével megadhatja a kultúrát, hogy létrehozhassa a rövid dátum és a hosszú idő megjelenítését egy adott kultúrában. Az alábbi példa a DateTime.ToString(IFormatProvider) fr-FR kultúra rövid és hosszú időmintájának használatával jeleníti meg a dátumot és az időt.

var date1 = new DateTime(2008, 3, 1, 7, 0, 0);
Console.WriteLine(date1.ToString(System.Globalization.CultureInfo.CreateSpecificCulture("fr-FR")));
// Displays 01/03/2008 07:00:00

let date1 = DateTime(2008, 3, 1, 7, 0, 0)
printfn $"""{date1.ToString(System.Globalization.CultureInfo.CreateSpecificCulture "fr-FR")}"""
// Displays 01/03/2008 07:00:00

Dim date1 As Date = #3/1/2008 7:00AM#
Console.WriteLine(date1.ToString(System.Globalization.CultureInfo.CreateSpecificCulture("fr-FR")))
' Displays 01/03/2008 07:00:00

Más alkalmazásokhoz különböző sztring-ábrázolásokra lehet szükség egy dátumhoz. A DateTime.ToString(String) metódus egy szabványos vagy egyéni formátumkijelölő által definiált sztringképet adja vissza az aktuális kultúra formázási konvencióinak használatával. Az alábbi példa a DateTime.ToString(String) metódus használatával jeleníti meg a en-US kultúra teljes dátum- és időmintáját, a jelenlegi kultúrát azon a számítógépen, amelyen a példát futtatták.

var date1 = new DateTime(2008, 3, 1, 7, 0, 0);
Console.WriteLine(date1.ToString("F"));
// Displays Saturday, March 01, 2008 7:00:00 AM

let date1 = DateTime(2008, 3, 1, 7, 0, 0)
printfn $"""{date1.ToString "F"}"""
// Displays Saturday, March 01, 2008 7:00:00 AM

Dim date1 As Date = #3/1/2008 7:00AM#
Console.WriteLine(date1.ToString("F"))
' Displays Saturday, March 01, 2008 7:00:00 AM

Végül megadhatja a kultúrát és a formátumot is a DateTime.ToString(String, IFormatProvider) metódus használatával. Az alábbi példa a DateTime.ToString(String, IFormatProvider) metódus használatával jeleníti meg a fr-FR kultúra teljes dátum- és időmintáját.

var date1 = new DateTime(2008, 3, 1, 7, 0, 0);
Console.WriteLine(date1.ToString("F", new System.Globalization.CultureInfo("fr-FR")));
// Displays samedi 1 mars 2008 07:00:00

let date1 = DateTime(2008, 3, 1, 7, 0, 0)
printfn $"""{date1.ToString("F", new System.Globalization.CultureInfo "fr-FR")}"""
// Displays samedi 1 mars 2008 07:00:00

Dim date1 As Date = #3/1/2008 7:00AM#
Console.WriteLine(date1.ToString("F", New System.Globalization.CultureInfo("fr-FR")))
' Displays samedi 1 mars 2008 07:00:00

A DateTime.ToString(String) túlterhelés egyéni formátumsztringgel is használható különböző formátumok beállításához. Az alábbi példa bemutatja, hogyan formázhat sztringeket a webszolgáltatásokhoz gyakran használt ISO 8601 szabványformátummal. Az Iso 8601 formátum nem rendelkezik megfelelő szabványos formátumsztringgel.

var date1 = new DateTime(2008, 3, 1, 7, 0, 0, DateTimeKind.Utc);
Console.WriteLine(date1.ToString("yyyy-MM-ddTHH:mm:sszzz", System.Globalization.CultureInfo.InvariantCulture));
// Displays 2008-03-01T07:00:00+00:00

let date1 = DateTime(2008, 3, 1, 7, 0, 0, DateTimeKind.Utc)
printfn $"""{date1.ToString("yyyy-MM-ddTHH:mm:sszzz", System.Globalization.CultureInfo.InvariantCulture)}"""
// Displays 2008-03-01T07:00:00+00:00

Dim date1 As DateTime = New DateTime(2008, 3, 1, 7, 0, 0, DateTimeKind.Utc)
Console.WriteLine(date1.ToString("yyyy-MM-ddTHH:mm:sszzz", System.Globalization.CultureInfo.InvariantCulture))
' Displays 2008-03-01T07:00:00+00:00

A formázási DateTime értékekkel kapcsolatos további információkért lásd: Standard dátum- és időformátum sztringek , valamint egyéni dátum- és időformátum-sztringek.

Dátum/idő értékek elemzése sztringekből

A karakterláncként megadott dátumot és időt egy DateTime értékké alakítja át. A dátum- és idősztringek általában két különböző felhasználási módot használnak az alkalmazásokban:

• A dátum és az idő sokféle formában jelenik meg, és tükrözi a jelenlegi vagy egy adott kultúra konvencióit. Egy alkalmazás például lehetővé teszi, hogy egy olyan felhasználó, akinek jelenlegi kultúrája en-US, egy dátumértéket például "12/15/2013" vagy "2013. december 15." formátumban adjon meg. Lehetővé teszi egy felhasználó számára, akinek a jelenlegi kultúrája en-gb, hogy egy dátumértéket "15/12/2013" vagy "2013. december 15." formában adjon meg.

• A dátum és az idő előre definiált formátumban jelenik meg. Egy alkalmazás például "20130103" dátumként szerializálja a dátumot attól függetlenül, hogy melyik kultúrán fut az alkalmazás. Előfordulhat, hogy egy alkalmazás dátumokat igényel az aktuális kultúra rövid dátumformátumában.

A Parse vagy TryParse metódus használatával egy sztringet a kulturális környezet által használt gyakori dátum- és időformátumok egyikéből DateTime értékké konvertálhat. Az alábbi példa bemutatja, hogyan konvertálhatja át a TryParse dátumsztringeket különböző kultúraspecifikus formátumokban a(z) DateTime értékké. A jelenlegi kultúrát angolra (Egyesült Királyság) módosítja, és meghívja a GetDateTimeFormats() metódust dátum- és idősztringek tömbjének létrehozására. Ezután átadja a tömb minden elemét a TryParse metódusnak. A példa kimenete azt mutatja, hogy az elemzési módszer sikeresen konvertálta a kultúraspecifikus dátum- és idősztringeket.

System.Threading.Thread.CurrentThread.CurrentCulture =
    System.Globalization.CultureInfo.CreateSpecificCulture("en-GB");

var date1 = new DateTime(2013, 6, 1, 12, 32, 30);
var badFormats = new List<String>();

Console.WriteLine($"{"Date String",-37} {"Date",-19}\n");
foreach (var dateString in date1.GetDateTimeFormats())
{
    DateTime parsedDate;
    if (DateTime.TryParse(dateString, out parsedDate))
        Console.WriteLine($"{dateString,-37} {DateTime.Parse(dateString),-19}");
    else
        badFormats.Add(dateString);
}

// Display strings that could not be parsed.
if (badFormats.Count > 0)
{
    Console.WriteLine("\nStrings that could not be parsed: ");
    foreach (var badFormat in badFormats)
        Console.WriteLine($"   {badFormat}");
}
// Press "Run" to see the output.

System.Threading.Thread.CurrentThread.CurrentCulture <-
    System.Globalization.CultureInfo.CreateSpecificCulture "en-GB"

let date1 = DateTime(2013, 6, 1, 12, 32, 30)
let badFormats = ResizeArray<String>()

printfn "%-37s %-19s\n" "Date String" "Date"
for dateString in date1.GetDateTimeFormats() do
    match DateTime.TryParse dateString with
    | true, parsedDate ->
        printfn $"%-37s{dateString} %-19O{parsedDate}\n" 
    | _ ->
        badFormats.Add dateString

// Display strings that could not be parsed.
if badFormats.Count > 0 then
    printfn "\nStrings that could not be parsed: "
    for badFormat in badFormats do
        printfn $"   {badFormat}"
// Press "Run" to see the output.

Thread.CurrentThread.CurrentCulture = CultureInfo.CreateSpecificCulture("en-GB")

Dim date1 As New DateTime(2013, 6, 1, 12, 32, 30)
Dim badFormats As New List(Of String)

Console.WriteLine($"{"Date String",-37} {"Date",-19}")
Console.WriteLine()
For Each dateString As String In date1.GetDateTimeFormats()
    Dim parsedDate As DateTime
    If DateTime.TryParse(dateString, parsedDate) Then
        Console.WriteLine($"{dateString,-37} {DateTime.Parse(dateString),-19:g}")
    Else
        badFormats.Add(dateString)
    End If
Next

' Display strings that could not be parsed.
If badFormats.Count > 0 Then
    Console.WriteLine()
    Console.WriteLine("Strings that could not be parsed: ")
    For Each badFormat In badFormats
        Console.WriteLine($"   {badFormat}")
    Next
End If
' The example displays the following output:
'       Date String                           Date               
'       
'       01/06/2013                            01/06/2013 00:00:00
'       01/06/13                              01/06/2013 00:00:00
'       1/6/13                                01/06/2013 00:00:00
'       1.6.13                                01/06/2013 00:00:00
'       2013-06-01                            01/06/2013 00:00:00
'       01 June 2013                          01/06/2013 00:00:00
'       1 June 2013                           01/06/2013 00:00:00
'       01 June 2013 12:32                    01/06/2013 12:32:00
'       01 June 2013 12:32                    01/06/2013 12:32:00
'       01 June 2013 12:32 PM                 01/06/2013 12:32:00
'       01 June 2013 12:32 PM                 01/06/2013 12:32:00
'       1 June 2013 12:32                     01/06/2013 12:32:00
'       1 June 2013 12:32                     01/06/2013 12:32:00
'       1 June 2013 12:32 PM                  01/06/2013 12:32:00
'       1 June 2013 12:32 PM                  01/06/2013 12:32:00
'       01 June 2013 12:32:30                 01/06/2013 12:32:30
'       01 June 2013 12:32:30                 01/06/2013 12:32:30
'       01 June 2013 12:32:30 PM              01/06/2013 12:32:30
'       01 June 2013 12:32:30 PM              01/06/2013 12:32:30
'       1 June 2013 12:32:30                  01/06/2013 12:32:30
'       1 June 2013 12:32:30                  01/06/2013 12:32:30
'       1 June 2013 12:32:30 PM               01/06/2013 12:32:30
'       1 June 2013 12:32:30 PM               01/06/2013 12:32:30
'       01/06/2013 12:32                      01/06/2013 12:32:00
'       01/06/2013 12:32                      01/06/2013 12:32:00
'       01/06/2013 12:32 PM                   01/06/2013 12:32:00
'       01/06/2013 12:32 PM                   01/06/2013 12:32:00
'       01/06/13 12:32                        01/06/2013 12:32:00
'       01/06/13 12:32                        01/06/2013 12:32:00
'       01/06/13 12:32 PM                     01/06/2013 12:32:00
'       01/06/13 12:32 PM                     01/06/2013 12:32:00
'       1/6/13 12:32                          01/06/2013 12:32:00
'       1/6/13 12:32                          01/06/2013 12:32:00
'       1/6/13 12:32 PM                       01/06/2013 12:32:00
'       1/6/13 12:32 PM                       01/06/2013 12:32:00
'       1.6.13 12:32                          01/06/2013 12:32:00
'       1.6.13 12:32                          01/06/2013 12:32:00
'       1.6.13 12:32 PM                       01/06/2013 12:32:00
'       1.6.13 12:32 PM                       01/06/2013 12:32:00
'       2013-06-01 12:32                      01/06/2013 12:32:00
'       2013-06-01 12:32                      01/06/2013 12:32:00
'       2013-06-01 12:32 PM                   01/06/2013 12:32:00
'       2013-06-01 12:32 PM                   01/06/2013 12:32:00
'       01/06/2013 12:32:30                   01/06/2013 12:32:30
'       01/06/2013 12:32:30                   01/06/2013 12:32:30
'       01/06/2013 12:32:30 PM                01/06/2013 12:32:30
'       01/06/2013 12:32:30 PM                01/06/2013 12:32:30
'       01/06/13 12:32:30                     01/06/2013 12:32:30
'       01/06/13 12:32:30                     01/06/2013 12:32:30
'       01/06/13 12:32:30 PM                  01/06/2013 12:32:30
'       01/06/13 12:32:30 PM                  01/06/2013 12:32:30
'       1/6/13 12:32:30                       01/06/2013 12:32:30
'       1/6/13 12:32:30                       01/06/2013 12:32:30
'       1/6/13 12:32:30 PM                    01/06/2013 12:32:30
'       1/6/13 12:32:30 PM                    01/06/2013 12:32:30
'       1.6.13 12:32:30                       01/06/2013 12:32:30
'       1.6.13 12:32:30                       01/06/2013 12:32:30
'       1.6.13 12:32:30 PM                    01/06/2013 12:32:30
'       1.6.13 12:32:30 PM                    01/06/2013 12:32:30
'       2013-06-01 12:32:30                   01/06/2013 12:32:30
'       2013-06-01 12:32:30                   01/06/2013 12:32:30
'       2013-06-01 12:32:30 PM                01/06/2013 12:32:30
'       2013-06-01 12:32:30 PM                01/06/2013 12:32:30
'       01 June                               01/06/2013 00:00:00
'       01 June                               01/06/2013 00:00:00
'       2013-06-01T12:32:30.0000000           01/06/2013 12:32:30
'       2013-06-01T12:32:30.0000000           01/06/2013 12:32:30
'       Sat, 01 Jun 2013 12:32:30 GMT         01/06/2013 05:32:30
'       Sat, 01 Jun 2013 12:32:30 GMT         01/06/2013 05:32:30
'       2013-06-01T12:32:30                   01/06/2013 12:32:30
'       12:32                                 22/04/2013 12:32:00
'       12:32                                 22/04/2013 12:32:00
'       12:32 PM                              22/04/2013 12:32:00
'       12:32 PM                              22/04/2013 12:32:00
'       12:32:30                              22/04/2013 12:32:30
'       12:32:30                              22/04/2013 12:32:30
'       12:32:30 PM                           22/04/2013 12:32:30
'       12:32:30 PM                           22/04/2013 12:32:30
'       2013-06-01 12:32:30Z                  01/06/2013 05:32:30
'       01 June 2013 19:32:30                 01/06/2013 19:32:30
'       01 June 2013 19:32:30                 01/06/2013 19:32:30
'       01 June 2013 07:32:30 PM              01/06/2013 19:32:30
'       01 June 2013 7:32:30 PM               01/06/2013 19:32:30
'       1 June 2013 19:32:30                  01/06/2013 19:32:30
'       1 June 2013 19:32:30                  01/06/2013 19:32:30
'       1 June 2013 07:32:30 PM               01/06/2013 19:32:30
'       1 June 2013 7:32:30 PM                01/06/2013 19:32:30
'       June 2013                             01/06/2013 00:00:00
'       June 2013                             01/06/2013 00:00:00

A ParseExact és TryParseExact metódusokkal olyan sztringeket alakíthat át, amelyeknek meg kell egyezniük egy adott formátummal vagy formátumokkal DateTime értékre. Az elemzési módszer paramétereként megadhat egy vagy több dátum- és időformátum-sztringet. Az alábbi példa a TryParseExact(String, String[], IFormatProvider, DateTimeStyles, DateTime) módszert/metódust használja olyan szövegek konvertálására, amelyeknek "yyyyMMdd" vagy "HHmmss" formátumúaknak kell lenniük, DateTime értékekké.

string[] formats = { "yyyyMMdd", "HHmmss" };
string[] dateStrings = { "20130816", "20131608", "  20130816   ",
                   "115216", "521116", "  115216  " };
DateTime parsedDate;

foreach (var dateString in dateStrings)
{
    if (DateTime.TryParseExact(dateString, formats, null,
                               System.Globalization.DateTimeStyles.AllowWhiteSpaces |
                               System.Globalization.DateTimeStyles.AdjustToUniversal,
                               out parsedDate))
        Console.WriteLine($"{dateString} --> {parsedDate:g}");
    else
        Console.WriteLine($"Cannot convert {dateString}");
}
// The example displays the following output:
//       20130816 --> 8/16/2013 12:00 AM
//       Cannot convert 20131608
//         20130816    --> 8/16/2013 12:00 AM
//       115216 --> 4/22/2013 11:52 AM
//       Cannot convert 521116
//         115216   --> 4/22/2013 11:52 AM

let formats = [| "yyyyMMdd"; "HHmmss" |]
let dateStrings = 
    [ "20130816"; "20131608"; "  20130816   "
      "115216"; "521116"; "  115216  " ]

for dateString in dateStrings do
    match DateTime.TryParseExact(dateString, formats, null,
                                System.Globalization.DateTimeStyles.AllowWhiteSpaces |||
                                System.Globalization.DateTimeStyles.AdjustToUniversal) with
    | true, parsedDate ->
        printfn $"{dateString} --> {parsedDate:g}"
    | _ ->
        printfn $"Cannot convert {dateString}"

// The example displays the following output:
//       20130816 --> 8/16/2013 12:00 AM
//       Cannot convert 20131608
//         20130816    --> 8/16/2013 12:00 AM
//       115216 --> 4/22/2013 11:52 AM
//       Cannot convert 521116
//         115216   --> 4/22/2013 11:52 AM

Dim formats() As String = {"yyyyMMdd", "HHmmss"}
Dim dateStrings() As String = {"20130816", "20131608",
                              "  20130816   ", "115216",
                              "521116", "  115216  "}
Dim parsedDate As DateTime

For Each dateString As String In dateStrings
    If DateTime.TryParseExact(dateString, formats, Nothing,
                           DateTimeStyles.AllowWhiteSpaces Or
                           DateTimeStyles.AdjustToUniversal,
                           parsedDate) Then
        Console.WriteLine($"{dateString} --> {parsedDate:g}")
    Else
        Console.WriteLine($"Cannot convert {dateString}")
    End If
Next
' The example displays the following output:
'       20130816 --> 8/16/2013 12:00 AM
'       Cannot convert 20131608
'         20130816    --> 8/16/2013 12:00 AM
'       115216 --> 4/22/2013 11:52 AM
'       Cannot convert 521116
'         115216   --> 4/22/2013 11:52 AM

Az egyik gyakori felhasználási mód ParseExact a webszolgáltatásból származó karakterlánc konvertálása, általában ISO 8601 szabványformátumba. Az alábbi kód megmutatja a helyes karakterlánc formátumot, amelyet használni kell:

var iso8601String = "20080501T08:30:52Z";
DateTime dateISO8602 = DateTime.ParseExact(iso8601String, "yyyyMMddTHH:mm:ssZ",
    System.Globalization.CultureInfo.InvariantCulture);
Console.WriteLine($"{iso8601String} --> {dateISO8602:g}");

let iso8601String = "20080501T08:30:52Z"
let dateISO8602 = DateTime.ParseExact(iso8601String, "yyyyMMddTHH:mm:ssZ", System.Globalization.CultureInfo.InvariantCulture)

printfn $"{iso8601String} --> {dateISO8602:g}"

Dim iso8601String As String = "20080501T08:30:52Z"
Dim dateISO8602 As DateTime = DateTime.ParseExact(iso8601String, "yyyyMMddTHH:mm:ssZ", CultureInfo.InvariantCulture)
Console.WriteLine($"{iso8601String} --> {dateISO8602:g}")

Ha egy sztring nem elemezhető, a Parse és ParseExact metódusok kivételt vetnek ki. A TryParse metódusok olyan TryParseExactBoolean értéket adnak vissza, amely jelzi, hogy az átalakítás sikeres volt vagy sikertelen volt. Azokat a TryParse módszereket vagy TryParseExact módszereket kell használnia, ahol a teljesítmény fontos. A dátum- és idősztringek elemzési művelete általában magas hibaarányú, és a kivételkezelés költséges. Ezeket a metódusokat akkor használja, ha a sztringeket a felhasználók bemenetként használják, vagy ismeretlen forrásból származnak.

A dátum- és időértékek elemzésével kapcsolatos további információkért lásd: Dátum- és idősztringek elemzése.

DateTime értékek

A típus időértékeinek DateTime leírását gyakran a koordinált egyetemes idő (UTC) szabvány használatával fejezik ki. Az összehangolt egyetemes idő a greenwichi középidő (GMT) nemzetközileg elismert neve. A koordinált világidő a nulla fokos hosszúságban mért idő, az UTC kiindulópontja. A nyári időszámítás nem érvényes az UTC-hez.

A helyi idő egy adott időzónához viszonyítva van. Az időzóna időzóna-eltolással van társítva. Az időzóna eltolása az időzóna eltolódása, amely órákban van megadva az UTC kiindulási pontjától. Emellett a helyi időt is befolyásolja a nyári időszámítás, amely hozzáad vagy kivon egy időintervallum-beállítást. A helyi idő kiszámítása úgy történik, hogy hozzáadja az időzóna eltolását az UTC-hez, és szükség esetén módosítja a nyári időszámítást. Az időzóna eltolása az UTC kiindulási pontján nulla.

Az UTC-idő alkalmas számításokhoz, összehasonlításokhoz és dátumok és idő fájlokban való tárolásához. A helyi idő megfelelő az asztali alkalmazások felhasználói felületén való megjelenítéshez. Az időzóna-érzékeny alkalmazásoknak (például számos webalkalmazásnak) számos más időzónával is együtt kell működnie.

Ha egy KindDateTime objektum tulajdonsága, DateTimeKind.Unspecified, akkor nincs meghatározva, hogy a megadott idő helyi idő, UTC idő, vagy más időzóna idő-e.

Dátum és idő felbontás

A Ticks tulajdonság a dátum- és időértékeket egy másodperc tízmilliomodik egységében fejezi ki. A Millisecond tulajdonság egy dátum- és időértékben a másodperc ezred részét adja vissza. Az DateTime.Now tulajdonság többszöri meghívása az eltelt idő mérésére a rendszeridőtől függ. A Windows 7 és Windows 8 rendszerek rendszeróráinak felbontása körülbelül 15 ezredmásodperc. Ez a megoldás 100 ezredmásodpercnél rövidebb kis időintervallumokat érint.

Az alábbi példa az aktuális dátum- és időértékek a rendszeróra felbontásától való függőségét szemlélteti. A példában a külső hurok 20-szor ismétlődik, egy belső hurok pedig a külső hurok késleltetésére szolgál. Ha a külső hurokszámláló értéke 10, a Thread.Sleep metódus hívása öt ezredmásodperc késleltetést vezet be. Az alábbi példa azt mutatja be, hogy a tulajdonság által visszaadott ezredmásodpercek száma csak a DateTime.Now.Milliseconds hívás után változik Thread.Sleep.

string output = "";
for (int ctr = 0; ctr <= 20; ctr++)
{
    output += String.Format($"{DateTime.Now.Millisecond}\n");
    // Introduce a delay loop.
    for (int delay = 0; delay <= 1000; delay++)
    { }

    if (ctr == 10)
    {
        output += "Thread.Sleep called...\n";
        System.Threading.Thread.Sleep(5);
    }
}
Console.WriteLine(output);
// Press "Run" to see the output.

let mutable output = ""
for i = 0 to 20 do
    output <- output + $"{DateTime.Now.Millisecond}\n"
    // Introduce a delay loop.
    for _ = 0 to 1000 do ()

    if i = 10 then
        output <- output + "Thread.Sleep called...\n"
        System.Threading.Thread.Sleep 5

printfn $"{output}"
// Press "Run" to see the output.

Dim output As String = ""
For ctr As Integer = 0 To 20
    output += Date.Now.Millisecond.ToString() + vbCrLf
    ' Introduce a delay loop.
    For delay As Integer = 0 To 1000
    Next

    If ctr = 10 Then
        output += "Thread.Sleep called..." + vbCrLf
        Thread.Sleep(5)
    End If
Next
Console.WriteLine(output)
' The example displays output like the following:
'       111
'       111
'       111
'       111
'       111
'       111
'       111
'       111
'       111
'       111
'       111
'       Thread.Sleep called...
'       143
'       143
'       143
'       143
'       143
'       143
'       143
'       143
'       143
'       143

DateTime-műveletek

Az olyan szerkezetet DateTime használó számítások, mint például Add vagy Subtract, nem módosítják a struktúra értékét. Ehelyett a számítás egy új DateTime struktúrát ad vissza, amelynek az értéke a számítás eredménye.

Az időzónák közötti átváltási műveletek (például AZ UTC és a helyi idő, vagy egy időzóna és egy másik időzóna között) figyelembe veszik a nyári időszámítást, de az aritmetikai és összehasonlító műveletek nem.

Maga a DateTime struktúra korlátozott támogatást nyújt az egyik időzónából a másikba való konvertáláshoz. A módszerrel az ToLocalTime UTC-t helyi idő szerint alakíthatja át, vagy használhatja a ToUniversalTime metódust a helyi időről UTC-vé való konvertálásra. Az TimeZoneInfo osztályban azonban elérhető az időzóna-átalakítási módszerek teljes készlete. Ezekkel a módszerekkel a világ bármely időzónájában lévő időt bármely más időzónában lévő időpontra konvertálhatja.

Az objektumok számításai DateTime és összehasonlítása csak akkor értelmezhető, ha az objektumok ugyanabban az időzónában lévő időpontokat jelölnek. Egy objektummal TimeZoneInfo egy DateTime érték időzónáját jelölheti, bár a kettő lazán van összekapcsolva. Az DateTime objektumok nem rendelkeznek olyan tulajdonságokkal, amelyek olyan objektumot adnának vissza, amely az adott dátum- és időérték időzónáját jelöli. A Kind tulajdonság azt jelzi, hogy az DateTime UTC-t, a helyi időt vagy a meghatározatlan időpontot jelöli-e. Az időzóna-tudatos alkalmazásokban külső mechanizmusra kell támaszkodnia annak meghatározásához, hogy milyen időzónában jött létre egy DateTime objektum. Használhat olyan struktúrát, amely az DateTime értéket és az TimeZoneInfo érték időzónáját képviselő DateTime objektumot is körbefuttatja. Az UTC számításban és az értékekkel való DateTime összehasonlításban való használatáról további információt az Aritmetikai műveletek végrehajtása dátumokkal és időpontokkal című témakörben talál.

Minden DateTime tag implicit módon a Gergely-naptárt használja a művelet végrehajtásához. A kivételek olyan metódusok, amelyek implicit módon megadják a naptárt. Ezek közé tartoznak a naptárt meghatározó konstruktorok, valamint az olyan metódusok, melyek paramétere a IFormatProvider, mint például a System.Globalization.DateTimeFormatInfo.

A típus tagjai által végzett műveletek figyelembe veszik az DateTime olyan részleteket, mint a szökőévek és az egy hónap napjainak száma.

DateTime értékek és naptárak

A .NET-osztálytár számos naptárosztályt tartalmaz, amelyek mindegyike az Calendar osztályból származik. Ezek a következők:

• Az ChineseLunisolarCalendar osztály.
• Az EastAsianLunisolarCalendar osztály.
• Az GregorianCalendar osztály.
• Az HebrewCalendar osztály.
• Az HijriCalendar osztály.
• Az JapaneseCalendar osztály.
• Az JapaneseLunisolarCalendar osztály.
• Az JulianCalendar osztály.
• Az KoreanCalendar osztály.
• Az KoreanLunisolarCalendar osztály.
• Az PersianCalendar osztály.
• Az TaiwanCalendar osztály.
• Az TaiwanLunisolarCalendar osztály.
• Az ThaiBuddhistCalendar osztály.
• Az UmAlQuraCalendar osztály.

Minden kultúra az írásvédett CultureInfo.Calendar tulajdonságával meghatározott alapértelmezett naptárt használ. Minden kultúra támogathat egy vagy több naptárat, amelyeket a csak olvasható CultureInfo.OptionalCalendars tulajdonság határoz meg. Az adott CultureInfo objektum által jelenleg használt naptárat a tulajdonsága DateTimeFormatInfo.Calendar határozza meg. A tömbben CultureInfo.OptionalCalendars található naptárak egyikének kell lennie.

A kultúra aktuális naptára az adott kultúra összes formázási műveletében használatos. A thai buddhista kultúra alapértelmezett naptára például a thai buddhista korszak naptára, amelyet az ThaiBuddhistCalendar osztály jelöl. Ha egy CultureInfo thai buddhista kultúrát jelképező objektumot használ egy dátum- és időformázási műveletben, a thai buddhista korszak naptárát használja alapértelmezés szerint. A Gergely-naptár csak akkor használatos, ha a kultúra tulajdonsága DateTimeFormatInfo.Calendar megváltozik, ahogy az alábbi példa is mutatja:

var thTH = new System.Globalization.CultureInfo("th-TH");
var value = new DateTime(2016, 5, 28);

Console.WriteLine(value.ToString(thTH));

thTH.DateTimeFormat.Calendar = new System.Globalization.GregorianCalendar();
Console.WriteLine(value.ToString(thTH));
// The example displays the following output:
//       28/5/2559 0:00:00
//       28/5/2016 0:00:00

let thTH = System.Globalization.CultureInfo "th-TH"
let value = DateTime(2016, 5, 28)

printfn $"{value.ToString thTH}"

thTH.DateTimeFormat.Calendar <- System.Globalization.GregorianCalendar()

printfn $"{value.ToString thTH}"

// The example displays the following output:
//       28/5/2559 0:00:00
//       28/5/2016 0:00:00

Dim thTH As New CultureInfo("th-TH")
Dim value As New DateTime(2016, 5, 28)

Console.WriteLine(value.ToString(thTH))

thTH.DateTimeFormat.Calendar = New GregorianCalendar()
Console.WriteLine(value.ToString(thTH))
' The example displays the following output:
'       28/5/2559 0:00:00
'       28/5/2016 0:00:00

A kultúra aktuális naptára az adott kultúra összes elemzési műveletében is használatos, ahogy az alábbi példa is mutatja.

var thTH = new System.Globalization.CultureInfo("th-TH");
var value = DateTime.Parse("28/05/2559", thTH);
Console.WriteLine(value.ToString(thTH));

thTH.DateTimeFormat.Calendar = new System.Globalization.GregorianCalendar();
Console.WriteLine(value.ToString(thTH));
// The example displays the following output:
//       28/5/2559 0:00:00
//       28/5/2016 0:00:00

let thTH = System.Globalization.CultureInfo "th-TH"
let value = DateTime.Parse("28/05/2559", thTH)
printfn $"{value.ToString thTH}"

thTH.DateTimeFormat.Calendar <- System.Globalization.GregorianCalendar()
printfn $"{value.ToString thTH}"

// The example displays the following output:
//       28/5/2559 0:00:00
//       28/5/2016 0:00:00

Private Sub ThaiBuddhistEraParse()
    Dim thTH As New CultureInfo("th-TH")
    Dim value As DateTime = DateTime.Parse("28/5/2559", thTH)
    Console.WriteLine(value.ToString(thTH))

    thTH.DateTimeFormat.Calendar = New GregorianCalendar()
    Console.WriteLine(value.ToString(thTH))
    ' The example displays the following output:
    '       28/5/2559 0:00:00
    '       28/5/2016 0:00:00
End Sub

Az év, hónap és nap számát tartalmazó dátum- és időelemek felhasználásával példányosíthat egy DateTime értéket egy olyan DateTime-konstruktor meghívásával, amely tartalmazza a calendar paramétert, és átadja neki azt a Calendar objektumot, amely az adott naptárt jelképezi. Az alábbi példa a naptár dátum- és időelemeit ThaiBuddhistCalendar használja.

var thTH = new System.Globalization.CultureInfo("th-TH");
var dat = new DateTime(2559, 5, 28, thTH.DateTimeFormat.Calendar);
Console.WriteLine($"Thai Buddhist era date: {dat.ToString("d", thTH)}");
Console.WriteLine($"Gregorian date:   {dat:d}");
// The example displays the following output:
//       Thai Buddhist Era Date:  28/5/2559
//       Gregorian Date:     28/05/2016

let thTH = System.Globalization.CultureInfo "th-TH"
let dat = DateTime(2559, 5, 28, thTH.DateTimeFormat.Calendar)

printfn $"""Thai Buddhist era date: {dat.ToString("d", thTH)}"""
printfn $"Gregorian date:   {dat:d}"

// The example displays the following output:
//       Thai Buddhist Era Date:  28/5/2559
//       Gregorian Date:     28/05/2016

Dim thTH As New CultureInfo("th-TH")
Dim dat As New DateTime(2559, 5, 28, thTH.DateTimeFormat.Calendar)
Console.WriteLine($"Thai Buddhist Era date: {dat.ToString("d", thTH)}")
Console.WriteLine($"Gregorian date:   {dat:d}")
' The example displays the following output:
'       Thai Buddhist Era Date:  28/5/2559
'       Gregorian Date:     28/05/2016

DateTime a paramétert calendar nem tartalmazó konstruktorok feltételezik, hogy a dátum- és időelemek mértékegységként vannak kifejezve a Gergely-naptárban.

Minden más DateTime tulajdonság és metódus a Gergely-naptárt használja. A tulajdonság például a DateTime.Year Gergely-naptárban adja vissza az évet, a DateTime.IsLeapYear(Int32) metódus pedig feltételezi, hogy a year paraméter egy év a Gergely-naptárban. A Gergely-naptárt használó összes DateTime tagnak van egy adott naptárt használó osztályának Calendar megfelelő tagja. A metódus például Calendar.GetYear egy adott naptárban adja vissza az évet, a Calendar.IsLeapYear metódus pedig egy adott naptár évszámaként értelmezi a year paramétert. Az alábbi példa az DateTime és a ThaiBuddhistCalendar osztály megfelelő tagjainak használatát mutatja be.

var thTH = new System.Globalization.CultureInfo("th-TH");
var cal = thTH.DateTimeFormat.Calendar;
var dat = new DateTime(2559, 5, 28, cal);
Console.WriteLine("Using the Thai Buddhist Era calendar:");
Console.WriteLine($"Date: {dat.ToString("d", thTH)}");
Console.WriteLine($"Year: {cal.GetYear(dat)}");
Console.WriteLine($"Leap year: {cal.IsLeapYear(cal.GetYear(dat))}\n");

Console.WriteLine("Using the Gregorian calendar:");
Console.WriteLine($"Date: {dat:d}");
Console.WriteLine($"Year: {dat.Year}");
Console.WriteLine($"Leap year: {DateTime.IsLeapYear(dat.Year)}");
// The example displays the following output:
//       Using the Thai Buddhist Era calendar
//       Date :   28/5/2559
//       Year: 2559
//       Leap year :   True
//
//       Using the Gregorian calendar
//       Date :   28/05/2016
//       Year: 2016
//       Leap year :   True

let thTH = System.Globalization.CultureInfo "th-TH"
let cal = thTH.DateTimeFormat.Calendar
let dat = DateTime(2559, 5, 28, cal)
printfn "Using the Thai Buddhist Era calendar:"
printfn $"""Date: {dat.ToString("d", thTH)}"""
printfn $"Year: {cal.GetYear dat}"
printfn $"Leap year: {cal.IsLeapYear(cal.GetYear dat)}\n"

printfn "Using the Gregorian calendar:"
printfn $"Date: {dat:d}"
printfn $"Year: {dat.Year}"
printfn $"Leap year: {DateTime.IsLeapYear dat.Year}"

// The example displays the following output:
//       Using the Thai Buddhist Era calendar
//       Date :   28/5/2559
//       Year: 2559
//       Leap year :   True
//
//       Using the Gregorian calendar
//       Date :   28/05/2016
//       Year: 2016
//       Leap year :   True

Dim thTH As New CultureInfo("th-TH")
Dim cal As Calendar = thTH.DateTimeFormat.Calendar
Dim dat As New DateTime(2559, 5, 28, cal)
Console.WriteLine("Using the Thai Buddhist Era calendar:")
Console.WriteLine($"Date: {dat.ToString("d", thTH)}")
Console.WriteLine($"Year: {cal.GetYear(dat)}")
Console.WriteLine($"Leap year: {cal.IsLeapYear(cal.GetYear(dat))}")
Console.WriteLine()

Console.WriteLine("Using the Gregorian calendar:")
Console.WriteLine($"Date: {dat:d}")
Console.WriteLine($"Year: {dat.Year}")
Console.WriteLine($"Leap year: {DateTime.IsLeapYear(dat.Year)}")
' The example displays the following output:
'       Using the Thai Buddhist Era calendar
'       Date :   28/5/2559
'       Year: 2559
'       Leap year :   True
'
'       Using the Gregorian calendar
'       Date :   28/05/2016
'       Year: 2016
'       Leap year :   True

A DateTime szerkezet tartalmaz egy tulajdonságot DayOfWeek , amely a hét napját adja vissza a Gergely-naptárban. Nem tartalmaz olyan tagot, amely lehetővé teszi az év hetének számát lekérni. Az év hetének lekéréséhez hívja meg az egyes naptár metódusát Calendar.GetWeekOfYear . Az alábbi példa egy illusztrációt tartalmaz.

var thTH = new System.Globalization.CultureInfo("th-TH");
var thCalendar = thTH.DateTimeFormat.Calendar;
var dat = new DateTime(1395, 8, 18, thCalendar);
Console.WriteLine("Using the Thai Buddhist Era calendar:");
Console.WriteLine($"Date: {dat.ToString("d", thTH)}");
Console.WriteLine($"Day of Week: {thCalendar.GetDayOfWeek(dat)}");
Console.WriteLine($"Week of year: {thCalendar.GetWeekOfYear(dat, System.Globalization.CalendarWeekRule.FirstDay, DayOfWeek.Sunday)}\n");

var greg = new System.Globalization.GregorianCalendar();
Console.WriteLine("Using the Gregorian calendar:");
Console.WriteLine($"Date: {dat:d}");
Console.WriteLine($"Day of Week: {dat.DayOfWeek}");
Console.WriteLine($"Week of year: {greg.GetWeekOfYear(dat, System.Globalization.CalendarWeekRule.FirstDay,DayOfWeek.Sunday)}");
// The example displays the following output:
//       Using the Thai Buddhist Era calendar
//       Date :  18/8/1395
//       Day of Week: Sunday
//       Week of year: 34
//
//       Using the Gregorian calendar
//       Date :  18/08/0852
//       Day of Week: Sunday
//       Week of year: 34

let thTH = System.Globalization.CultureInfo "th-TH"
let thCalendar = thTH.DateTimeFormat.Calendar
let dat = DateTime(1395, 8, 18, thCalendar)
printfn "Using the Thai Buddhist Era calendar:"
printfn $"""Date: {dat.ToString("d", thTH)}"""
printfn $"Day of Week: {thCalendar.GetDayOfWeek dat}"
printfn $"Week of year: {thCalendar.GetWeekOfYear(dat, System.Globalization.CalendarWeekRule.FirstDay, DayOfWeek.Sunday)}\n"

let greg = System.Globalization.GregorianCalendar()
printfn "Using the Gregorian calendar:"
printfn $"Date: {dat:d}"
printfn $"Day of Week: {dat.DayOfWeek}"
printfn $"Week of year: {greg.GetWeekOfYear(dat, System.Globalization.CalendarWeekRule.FirstDay, DayOfWeek.Sunday)}"

// The example displays the following output:
//       Using the Thai Buddhist Era calendar
//       Date :  18/8/1395
//       Day of Week: Sunday
//       Week of year: 34
//
//       Using the Gregorian calendar
//       Date :  18/08/0852
//       Day of Week: Sunday
//       Week of year: 34

Dim thTH As New CultureInfo("th-TH")
Dim thCalendar As Calendar = thTH.DateTimeFormat.Calendar
Dim dat As New DateTime(1395, 8, 18, thCalendar)
Console.WriteLine("Using the Thai Buddhist Era calendar:")
Console.WriteLine($"Date: {dat.ToString("d", thTH)}")
Console.WriteLine($"Day of Week: {thCalendar.GetDayOfWeek(dat)}")
Console.WriteLine($"Week of year: {thCalendar.GetWeekOfYear(dat, CalendarWeekRule.FirstDay, DayOfWeek.Sunday)}")
Console.WriteLine()

Dim greg As Calendar = New GregorianCalendar()
Console.WriteLine("Using the Gregorian calendar:")
Console.WriteLine($"Date: {dat:d}")
Console.WriteLine($"Day of Week: {dat.DayOfWeek}")
Console.WriteLine($"Week of year: {greg.GetWeekOfYear(dat, CalendarWeekRule.FirstDay, DayOfWeek.Sunday)}")
' The example displays the following output:
'       Using the Thai Buddhist Era calendar
'       Date :  18/8/1395
'       Day of Week: Sunday
'       Week of year: 34
'       
'       Using the Gregorian calendar
'       Date :  18/08/0852
'       Day of Week: Sunday
'       Week of year: 34

A dátumokkal és naptárakkal kapcsolatos további információkért lásd: Naptárak használata.

DateTime-értékek megőrzése

Az értékeket a következő módokon őrizheti meg DateTime :

• Alakítsa át őket karakterláncokká, és tartsa meg a karakterláncokat.
• Konvertálja őket 64 bites egész számmá (a Ticks tulajdonság értéke), és őrizze meg az egész számokat.
• Szerializálja a DateTime értékeket.

Gondoskodnia kell arról, hogy az DateTime értékeket visszaállító rutin ne veszítsen el adatokat, vagy kivételt állítson be, függetlenül attól, hogy melyik technikát választja. DateTime értékeknek oda-vissza kell utazniuk. Vagyis az eredeti és a visszaállított értéknek meg kell egyeznie. Ha az eredeti DateTime érték egyetlen időpillanatot jelöl, azonos időpontot kell azonosítania a visszaállításkor.

Értékek mentése karakterláncként

A sztringként megőrzött értékek sikeres visszaállításához DateTime kövesse az alábbi szabályokat:

• Amikor a sztringet visszaállítja, ugyanazokat a feltételezéseket vegye figyelembe a kultúraspecifikus formázásról, mint amikor azt mentette. Annak érdekében, hogy egy sztring visszaállítható legyen egy olyan rendszeren, amelynek jelenlegi kultúrája eltér a mentett rendszer kultúrájától, hívja meg a ToString túlterhelést a sztring mentéséhez az invariáns kultúra konvencióinak használatával. A sztring visszaállításához hívja meg a Parse(String, IFormatProvider, DateTimeStyles) vagy TryParse(String, IFormatProvider, DateTimeStyles, DateTime) túlterhelést az invariáns kultúra konvencióinak használatával. Soha ne használja azokat a ToString(), Parse(String)vagy TryParse(String, DateTime) túlterheléseket, amelyek a jelenlegi kultúra konvencióit használják.

• Ha a dátum egyetlen időpontot jelöl, győződjön meg arról, hogy a visszaállításkor ugyanazt a pillanatot jelöli, még egy másik időzónában is. Konvertálja az DateTime értéket egyezményes világidővé (UTC) a mentés előtt, vagy használja a DateTimeOffset-t.

A leggyakoribb hiba az, amikor az DateTime értékeket mint sztringek próbáljuk megőrizni, hogy az alapértelmezett vagy az aktuális kultúra formázási konvencióira támaszkodunk. Problémák merülnek fel, ha a karakterláncok mentésekor és visszaállításakor az aktuális kultúra eltérő. Az alábbi példa ezeket a problémákat szemlélteti. Öt dátumot ment a jelenlegi kultúra formázási konvencióit használva, amely ebben az esetben az angol (Egyesült Államok). Egy másik kultúra formázási konvencióit használva állítja vissza a dátumokat, amely ebben az esetben az angol (Egyesült Királyság). Mivel a két kultúra formázási konvenciói eltérőek, a dátumok közül kettő nem állítható vissza, a fennmaradó három dátum pedig helytelenül lesz értelmezve. Ha az eredeti dátum- és időértékek egyetlen pillanatot jelölnek az időben, a visszaállított időpontok helytelenek, mert az időzóna adatai elvesznek.

public static void PersistAsLocalStrings()
{
    SaveLocalDatesAsString();
    RestoreLocalDatesFromString();
}

private static void SaveLocalDatesAsString()
{
    DateTime[] dates = [ new DateTime(2014, 6, 14, 6, 32, 0),
                   new DateTime(2014, 7, 10, 23, 49, 0),
                   new DateTime(2015, 1, 10, 1, 16, 0),
                   new DateTime(2014, 12, 20, 21, 45, 0),
                   new DateTime(2014, 6, 2, 15, 14, 0) ];
    string? output = null;

    Console.WriteLine($"Current Time Zone: {TimeZoneInfo.Local.DisplayName}");
    Console.WriteLine($"The dates on an {Thread.CurrentThread.CurrentCulture.Name} system:");
    for (int ctr = 0; ctr < dates.Length; ctr++)
    {
        Console.WriteLine(dates[ctr].ToString("f"));
        output += dates[ctr].ToString() + (ctr != dates.Length - 1 ? "|" : "");
    }
    var sw = new StreamWriter(filenameTxt);
    sw.Write(output);
    sw.Close();
    Console.WriteLine("Saved dates...");
}

private static void RestoreLocalDatesFromString()
{
    TimeZoneInfo.ClearCachedData();
    Console.WriteLine($"Current Time Zone: {TimeZoneInfo.Local.DisplayName}");
    Thread.CurrentThread.CurrentCulture = CultureInfo.CreateSpecificCulture("en-GB");
    StreamReader sr = new StreamReader(filenameTxt);
    string[] inputValues = sr.ReadToEnd().Split(new char[] { '|' },
                                                StringSplitOptions.RemoveEmptyEntries);
    sr.Close();
    Console.WriteLine($"The dates on an {Thread.CurrentThread.CurrentCulture.Name} system:");
    foreach (var inputValue in inputValues)
    {
        DateTime dateValue;
        if (DateTime.TryParse(inputValue, out dateValue))
        {
            Console.WriteLine($"'{inputValue}' --> {dateValue:f}");
        }
        else
        {
            Console.WriteLine($"Cannot parse '{inputValue}'");
        }
    }
    Console.WriteLine("Restored dates...");
}
// When saved on an en-US system, the example displays the following output:
//       Current Time Zone: (UTC-08:00) Pacific Time (US & Canada)
//       The dates on an en-US system:
//       Saturday, June 14, 2014 6:32 AM
//       Thursday, July 10, 2014 11:49 PM
//       Saturday, January 10, 2015 1:16 AM
//       Saturday, December 20, 2014 9:45 PM
//       Monday, June 02, 2014 3:14 PM
//       Saved dates...
//
// When restored on an en-GB system, the example displays the following output:
//       Current Time Zone: (UTC) Dublin, Edinburgh, Lisbon, London
//       The dates on an en-GB system:
//       Cannot parse //6/14/2014 6:32:00 AM//
//       //7/10/2014 11:49:00 PM// --> 07 October 2014 23:49
//       //1/10/2015 1:16:00 AM// --> 01 October 2015 01:16
//       Cannot parse //12/20/2014 9:45:00 PM//
//       //6/2/2014 3:14:00 PM// --> 06 February 2014 15:14
//       Restored dates...

let saveLocalDatesAsString () =
    let dates = 
        [ DateTime(2014, 6, 14, 6, 32, 0)
          DateTime(2014, 7, 10, 23, 49, 0)
          DateTime(2015, 1, 10, 1, 16, 0)
          DateTime(2014, 12, 20, 21, 45, 0)
          DateTime(2014, 6, 2, 15, 14, 0) ]

    printfn $"Current Time Zone: {TimeZoneInfo.Local.DisplayName}"
    printfn $"The dates on an {Thread.CurrentThread.CurrentCulture.Name} system:"

    let output =
        [ for date in dates do
            printfn $"{date}"
            string date ]
        |> String.concat "|"

    use sw = new StreamWriter(filenameTxt)
    sw.Write output
    printfn "Saved dates..."

let restoreLocalDatesFromString () =
    TimeZoneInfo.ClearCachedData()
    printfn $"Current Time Zone: {TimeZoneInfo.Local.DisplayName}"
    Thread.CurrentThread.CurrentCulture <- CultureInfo.CreateSpecificCulture "en-GB"

    use sr = new StreamReader(filenameTxt)
    let inputValues = 
        sr.ReadToEnd().Split('|', StringSplitOptions.RemoveEmptyEntries)

    printfn $"The dates on an {Thread.CurrentThread.CurrentCulture.Name} system:"

    for inputValue in inputValues do
        match DateTime.TryParse inputValue with
        | true, dateValue ->
            printfn $"'{inputValue}' --> {dateValue:f}"
        | _ ->
            printfn $"Cannot parse '{inputValue}'"

    printfn "Restored dates..."

let persistAsLocalStrings () =
    saveLocalDatesAsString ()
    restoreLocalDatesFromString ()

// When saved on an en-US system, the example displays the following output:
//       Current Time Zone: (UTC-08:00) Pacific Time (US & Canada)
//       The dates on an en-US system:
//       Saturday, June 14, 2014 6:32 AM
//       Thursday, July 10, 2014 11:49 PM
//       Saturday, January 10, 2015 1:16 AM
//       Saturday, December 20, 2014 9:45 PM
//       Monday, June 02, 2014 3:14 PM
//       Saved dates...
//
// When restored on an en-GB system, the example displays the following output:
//       Current Time Zone: (UTC) Dublin, Edinburgh, Lisbon, London
//       The dates on an en-GB system:
//       Cannot parse //6/14/2014 6:32:00 AM//
//       //7/10/2014 11:49:00 PM// --> 07 October 2014 23:49
//       //1/10/2015 1:16:00 AM// --> 01 October 2015 01:16
//       Cannot parse //12/20/2014 9:45:00 PM//
//       //6/2/2014 3:14:00 PM// --> 06 February 2014 15:14
//       Restored dates...

A DateTime értékek sikeres oda-vissza konvertálásához kövesse az alábbi lépéseket:

1. Ha az értékek egyetlen időpillanatot jelölnek, a metódus meghívásával ToUniversalTime alakítsa át őket a helyi időről UTC-vé.
2. A dátumokat azok szöveges ábrázolásává alakíthatja a ToString(String, IFormatProvider) vagy String.Format(IFormatProvider, String, Object[]) túlterhelés meghívásával. Az invariáns kultúra formázási konvencióit azzal adja meg, hogy CultureInfo.InvariantCulture paramétert provider argumentumként használja. Adja meg, hogy az értéknek az "O" vagy az "R" szabványos formátumsztring használatával kell-e kerekítettnek lennie.

Ha adatvesztés nélkül szeretné visszaállítani a megőrzött DateTime értékeket, kövesse az alábbi lépéseket:

1. Elemezze az adatokat a ParseExact vagy TryParseExact túlterheléses meghívásával. Adja meg a CultureInfo.InvariantCulture-t argumentumként, és használja ugyanazt a szabványos formátumsztringet, amelyet az provider konvertálása során az format argumentumhoz használt. Adja meg az DateTimeStyles.RoundtripKind értéket az styles argumentumban.
2. Ha az DateTime értékek egyetlen pillanatot jelölnek az időben, hívja meg a metódust az ToLocalTime elemzési dátum UTC-ről helyi időre való konvertálásához.

Az alábbi példa az invariáns kultúrát és az "O" szabványos formátumsztringet használja annak biztosítására, hogy DateTime a mentett és visszaállított értékek a forrás- és célrendszerek rendszerétől, kultúrájától vagy időzónájától függetlenül azonos időpontot képviseljenek.

public static void PersistAsInvariantStrings()
{
    SaveDatesAsInvariantStrings();
    RestoreDatesAsInvariantStrings();
}

private static void SaveDatesAsInvariantStrings()
{
    DateTime[] dates = [ new DateTime(2014, 6, 14, 6, 32, 0),
                   new DateTime(2014, 7, 10, 23, 49, 0),
                   new DateTime(2015, 1, 10, 1, 16, 0),
                   new DateTime(2014, 12, 20, 21, 45, 0),
                   new DateTime(2014, 6, 2, 15, 14, 0) ];
    string? output = null;

    Console.WriteLine($"Current Time Zone: {TimeZoneInfo.Local.DisplayName}");
    Console.WriteLine($"The dates on an {Thread.CurrentThread.CurrentCulture.Name} system:");
    for (int ctr = 0; ctr < dates.Length; ctr++)
    {
        Console.WriteLine(dates[ctr].ToString("f"));
        output += dates[ctr].ToUniversalTime().ToString("O", CultureInfo.InvariantCulture)
                  + (ctr != dates.Length - 1 ? "|" : "");
    }
    var sw = new StreamWriter(filenameTxt);
    sw.Write(output);
    sw.Close();
    Console.WriteLine("Saved dates...");
}

private static void RestoreDatesAsInvariantStrings()
{
    TimeZoneInfo.ClearCachedData();
    Console.WriteLine($"Current Time Zone: {TimeZoneInfo.Local.DisplayName}");
    Thread.CurrentThread.CurrentCulture = CultureInfo.CreateSpecificCulture("en-GB");
    StreamReader sr = new StreamReader(filenameTxt);
    string[] inputValues = sr.ReadToEnd().Split(new char[] { '|' },
                                                StringSplitOptions.RemoveEmptyEntries);
    sr.Close();
    Console.WriteLine($"The dates on an {Thread.CurrentThread.CurrentCulture.Name} system:");
    foreach (var inputValue in inputValues)
    {
        DateTime dateValue;
        if (DateTime.TryParseExact(inputValue, "O", CultureInfo.InvariantCulture,
                              DateTimeStyles.RoundtripKind, out dateValue))
        {
            Console.WriteLine($"'{inputValue}' --> {dateValue.ToLocalTime():f}");
        }
        else
        {
            Console.WriteLine($"Cannot parse '{inputValue}'");
        }
    }
    Console.WriteLine("Restored dates...");
}
// When saved on an en-US system, the example displays the following output:
//       Current Time Zone: (UTC-08:00) Pacific Time (US & Canada)
//       The dates on an en-US system:
//       Saturday, June 14, 2014 6:32 AM
//       Thursday, July 10, 2014 11:49 PM
//       Saturday, January 10, 2015 1:16 AM
//       Saturday, December 20, 2014 9:45 PM
//       Monday, June 02, 2014 3:14 PM
//       Saved dates...
//
// When restored on an en-GB system, the example displays the following output:
//       Current Time Zone: (UTC) Dublin, Edinburgh, Lisbon, London
//       The dates on an en-GB system:
//       '2014-06-14T13:32:00.0000000Z' --> 14 June 2014 14:32
//       '2014-07-11T06:49:00.0000000Z' --> 11 July 2014 07:49
//       '2015-01-10T09:16:00.0000000Z' --> 10 January 2015 09:16
//       '2014-12-21T05:45:00.0000000Z' --> 21 December 2014 05:45
//       '2014-06-02T22:14:00.0000000Z' --> 02 June 2014 23:14
//       Restored dates...

let saveDatesAsInvariantStrings () =
    let dates = 
        [ DateTime(2014, 6, 14, 6, 32, 0)
          DateTime(2014, 7, 10, 23, 49, 0)
          DateTime(2015, 1, 10, 1, 16, 0)
          DateTime(2014, 12, 20, 21, 45, 0)
          DateTime(2014, 6, 2, 15, 14, 0) ]

    printfn $"Current Time Zone: {TimeZoneInfo.Local.DisplayName}"
    printfn $"The dates on an {Thread.CurrentThread.CurrentCulture.Name} system:"

    let output =
        [ for date in dates do
            printfn $"{date:f}"
            date.ToUniversalTime().ToString("O", CultureInfo.InvariantCulture) ]
        |> String.concat "|"

    use sw = new StreamWriter(filenameTxt)
    sw.Write output
    printfn "Saved dates..."

let restoreDatesAsInvariantStrings () =
    TimeZoneInfo.ClearCachedData()
    printfn $"Current Time Zone: {TimeZoneInfo.Local.DisplayName}"
    Thread.CurrentThread.CurrentCulture <- CultureInfo.CreateSpecificCulture "en-GB"
    
    use sr = new StreamReader(filenameTxt)
    let inputValues = 
        sr.ReadToEnd().Split('|', StringSplitOptions.RemoveEmptyEntries)

    printfn $"The dates on an {Thread.CurrentThread.CurrentCulture.Name} system:"

    for inputValue in inputValues do
        match DateTime.TryParseExact(inputValue, "O", CultureInfo.InvariantCulture, DateTimeStyles.RoundtripKind) with
        | true, dateValue ->
            printfn $"'{inputValue}' --> {dateValue.ToLocalTime():f}"
        | _ ->
            printfn $"Cannot parse '{inputValue}'"

    printfn "Restored dates..."

let persistAsInvariantStrings () =
    saveDatesAsInvariantStrings ()
    restoreDatesAsInvariantStrings ()

// When saved on an en-US system, the example displays the following output:
//       Current Time Zone: (UTC-08:00) Pacific Time (US & Canada)
//       The dates on an en-US system:
//       Saturday, June 14, 2014 6:32 AM
//       Thursday, July 10, 2014 11:49 PM
//       Saturday, January 10, 2015 1:16 AM
//       Saturday, December 20, 2014 9:45 PM
//       Monday, June 02, 2014 3:14 PM
//       Saved dates...
//
// When restored on an en-GB system, the example displays the following output:
//       Current Time Zone: (UTC) Dublin, Edinburgh, Lisbon, London
//       The dates on an en-GB system:
//       '2014-06-14T13:32:00.0000000Z' --> 14 June 2014 14:32
//       '2014-07-11T06:49:00.0000000Z' --> 11 July 2014 07:49
//       '2015-01-10T09:16:00.0000000Z' --> 10 January 2015 09:16
//       '2014-12-21T05:45:00.0000000Z' --> 21 December 2014 05:45
//       '2014-06-02T22:14:00.0000000Z' --> 02 June 2014 23:14
//       Restored dates...

Értékek tárolása egész számként

A dátumot és az időt egy Int64 értékként őrizheti meg, amely tikkszámot jelöl. Ebben az esetben nem kell figyelembe vennie azon rendszerek kultúráját, amelyeken az DateTime értékek megmaradnak és visszaállíthatók.

Az DateTime érték mentése egész számként:

1. Ha az DateTime értékek egyetlen pillanatot jelölnek az időben, konvertálja őket UTC-vé a ToUniversalTime metódus meghívásával.
2. Szerezze meg a tick-ek számát, amelyet a DateTime érték képvisel a Ticks tulajdonságából.

Egész számként megőrzött érték visszaállítása DateTime :

1. Példányosítson egy új DateTime objektumot a Int64 értéknek a DateTime(Int64) konstruktorhoz való átadásával.
2. Ha az DateTime érték egyetlen időpontot jelöl, konvertálja utc-ről helyi időpontra a ToLocalTime metódus meghívásával.

Az alábbi példa egy értéktömböt DateTime őriz meg egész számként az egyesült államokbeli csendes-óceáni időzónában lévő rendszereken. Az UTC-zónában lévő rendszeren állítja vissza. Az egész számokat tartalmazó fájl tartalmaz egy Int32 értéket, amely az őket közvetlenül követő Int64 értékek teljes számát jelzi.

public static void PersistAsIntegers()
{
    SaveDatesAsInts();
    RestoreDatesAsInts();
}

private static void SaveDatesAsInts()
{
    DateTime[] dates = [ new DateTime(2014, 6, 14, 6, 32, 0),
                   new DateTime(2014, 7, 10, 23, 49, 0),
                   new DateTime(2015, 1, 10, 1, 16, 0),
                   new DateTime(2014, 12, 20, 21, 45, 0),
                   new DateTime(2014, 6, 2, 15, 14, 0) ];

    Console.WriteLine($"Current Time Zone: {TimeZoneInfo.Local.DisplayName}");
    Console.WriteLine($"The dates on an {Thread.CurrentThread.CurrentCulture.Name} system:");
    var ticks = new long[dates.Length];
    for (int ctr = 0; ctr < dates.Length; ctr++)
    {
        Console.WriteLine(dates[ctr].ToString("f"));
        ticks[ctr] = dates[ctr].ToUniversalTime().Ticks;
    }
    var fs = new FileStream(filenameInts, FileMode.Create);
    var bw = new BinaryWriter(fs);
    bw.Write(ticks.Length);
    foreach (var tick in ticks)
        bw.Write(tick);

    bw.Close();
    Console.WriteLine("Saved dates...");
}

private static void RestoreDatesAsInts()
{
    TimeZoneInfo.ClearCachedData();
    Console.WriteLine($"Current Time Zone: {TimeZoneInfo.Local.DisplayName}");
    Thread.CurrentThread.CurrentCulture = CultureInfo.CreateSpecificCulture("en-GB");
    FileStream fs = new FileStream(filenameInts, FileMode.Open);
    BinaryReader br = new BinaryReader(fs);
    int items;
    DateTime[] dates;

    try
    {
        items = br.ReadInt32();
        dates = new DateTime[items];

        for (int ctr = 0; ctr < items; ctr++)
        {
            long ticks = br.ReadInt64();
            dates[ctr] = new DateTime(ticks).ToLocalTime();
        }
    }
    catch (EndOfStreamException)
    {
        Console.WriteLine("File corruption detected. Unable to restore data...");
        return;
    }
    catch (IOException)
    {
        Console.WriteLine("Unspecified I/O error. Unable to restore data...");
        return;
    }
    // Thrown during array initialization.
    catch (OutOfMemoryException)
    {
        Console.WriteLine("File corruption detected. Unable to restore data...");
        return;
    }
    finally
    {
        br.Close();
    }

    Console.WriteLine($"The dates on an {Thread.CurrentThread.CurrentCulture.Name} system:");
    foreach (var value in dates)
        Console.WriteLine(value.ToString("f"));

    Console.WriteLine("Restored dates...");
}
// When saved on an en-US system, the example displays the following output:
//       Current Time Zone: (UTC-08:00) Pacific Time (US & Canada)
//       The dates on an en-US system:
//       Saturday, June 14, 2014 6:32 AM
//       Thursday, July 10, 2014 11:49 PM
//       Saturday, January 10, 2015 1:16 AM
//       Saturday, December 20, 2014 9:45 PM
//       Monday, June 02, 2014 3:14 PM
//       Saved dates...
//
// When restored on an en-GB system, the example displays the following output:
//       Current Time Zone: (UTC) Dublin, Edinburgh, Lisbon, London
//       The dates on an en-GB system:
//       14 June 2014 14:32
//       11 July 2014 07:49
//       10 January 2015 09:16
//       21 December 2014 05:45
//       02 June 2014 23:14
//       Restored dates...

let saveDatesAsInts () =
    let dates = 
        [ DateTime(2014, 6, 14, 6, 32, 0)
          DateTime(2014, 7, 10, 23, 49, 0)
          DateTime(2015, 1, 10, 1, 16, 0)
          DateTime(2014, 12, 20, 21, 45, 0)
          DateTime(2014, 6, 2, 15, 14, 0) ]

    printfn $"Current Time Zone: {TimeZoneInfo.Local.DisplayName}"
    printfn $"The dates on an {Thread.CurrentThread.CurrentCulture.Name} system:"
    let ticks =
        [| for date in dates do
            printfn $"{date:f}"
            date.ToUniversalTime().Ticks |]
    use fs = new FileStream(filenameInts, FileMode.Create)
    use bw = new BinaryWriter(fs)
    bw.Write ticks.Length

    for tick in ticks do
        bw.Write tick

    printfn "Saved dates..."

let restoreDatesAsInts () =
    TimeZoneInfo.ClearCachedData()
    printfn $"Current Time Zone: {TimeZoneInfo.Local.DisplayName}"
    Thread.CurrentThread.CurrentCulture <- CultureInfo.CreateSpecificCulture "en-GB"
    use fs = new FileStream(filenameInts, FileMode.Open)
    use br = new BinaryReader(fs)

    try
        let items = br.ReadInt32()
        let dates =
            [| for _ in 0..items do
                let ticks = br.ReadInt64()
                DateTime(ticks).ToLocalTime() |]

        printfn $"The dates on an {Thread.CurrentThread.CurrentCulture.Name} system:"
        for value in dates do
            printfn $"{value:f}"
    with 
    | :? EndOfStreamException ->
        printfn "File corruption detected. Unable to restore data..."
    | :? IOException ->
        printfn "Unspecified I/O error. Unable to restore data..."
    // Thrown during array initialization.
    | :? OutOfMemoryException ->
        printfn"File corruption detected. Unable to restore data..."

    printfn "Restored dates..."

let persistAsIntegers () =
    saveDatesAsInts ()
    restoreDatesAsInts ()

// When saved on an en-US system, the example displays the following output:
//       Current Time Zone: (UTC-08:00) Pacific Time (US & Canada)
//       The dates on an en-US system:
//       Saturday, June 14, 2014 6:32 AM
//       Thursday, July 10, 2014 11:49 PM
//       Saturday, January 10, 2015 1:16 AM
//       Saturday, December 20, 2014 9:45 PM
//       Monday, June 02, 2014 3:14 PM
//       Saved dates...
//
// When restored on an en-GB system, the example displays the following output:
//       Current Time Zone: (UTC) Dublin, Edinburgh, Lisbon, London
//       The dates on an en-GB system:
//       14 June 2014 14:32
//       11 July 2014 07:49
//       10 January 2015 09:16
//       21 December 2014 05:45
//       02 June 2014 23:14
//       Restored dates...

DateTime-értékek szerializálása

Az értékeket szerializálással megőrizheti DateTime egy streamben vagy fájlban, majd deszerializálással visszaállíthatja őket. DateTime az adatok szerializálva vannak bizonyos meghatározott objektumformátumban. Az objektumok a deszerializálásukkor lesznek visszaállítva. A szerializálás és deszerializálás folyamatát egy formázó, például JsonSerializer vagy XmlSerializer, kezeli. A szerializálásról és a .NET által támogatott szerializálási típusokról további információt a Szerializálás című témakörben talál.

Az alábbi példa a XmlSerializer osztályt használja a DateTime értékek szerializálására és deszerializálására. Az értékek a huszonegyedik század összes szökőévi napját képviselik. A kimenet akkor adja meg az eredményt, ha a példa egy olyan rendszeren fut, amelynek jelenlegi kultúrája angol (Egyesült Királyság). Mivel magát az DateTime objektumot deszerializálta, a kódnak nem kell kezelnie a kulturális különbségeket a dátum- és időformátumokban.

public static void PersistAsXML()
{
    // Serialize the data.
    var leapYears = new List<DateTime>();
    for (int year = 2000; year <= 2100; year += 4)
    {
        if (DateTime.IsLeapYear(year))
            leapYears.Add(new DateTime(year, 2, 29));
    }
    DateTime[] dateArray = leapYears.ToArray();

    var serializer = new XmlSerializer(dateArray.GetType());
    TextWriter sw = new StreamWriter(filenameXml);

    try
    {
        serializer.Serialize(sw, dateArray);
    }
    catch (InvalidOperationException e)
    {
        Console.WriteLine(e.InnerException?.Message);
    }
    finally
    {
        if (sw != null) sw.Close();
    }

    // Deserialize the data.
    DateTime[]? deserializedDates;
    using (var fs = new FileStream(filenameXml, FileMode.Open))
    {
        deserializedDates = (DateTime[]?)serializer.Deserialize(fs);
    }

    // Display the dates.
    Console.WriteLine($"Leap year days from 2000-2100 on an {Thread.CurrentThread.CurrentCulture.Name} system:");
    int nItems = 0;
    if (deserializedDates is not null)
    {
        foreach (var dat in deserializedDates)
        {
            Console.Write($"   {dat:d}     ");
            nItems++;
            if (nItems % 5 == 0)
                Console.WriteLine();
        }
    }
}
// The example displays the following output:
//    Leap year days from 2000-2100 on an en-GB system:
//       29/02/2000       29/02/2004       29/02/2008       29/02/2012       29/02/2016
//       29/02/2020       29/02/2024       29/02/2028       29/02/2032       29/02/2036
//       29/02/2040       29/02/2044       29/02/2048       29/02/2052       29/02/2056
//       29/02/2060       29/02/2064       29/02/2068       29/02/2072       29/02/2076
//       29/02/2080       29/02/2084       29/02/2088       29/02/2092       29/02/2096

let persistAsXML () =
    // Serialize the data.
    let leapYears =
        [| for year in 2000..4..2100 do
            if DateTime.IsLeapYear year then
                DateTime(year, 2, 29) |]

    let serializer = XmlSerializer(leapYears.GetType())
    use sw = new StreamWriter(filenameXml)

    try
        serializer.Serialize(sw, leapYears)
    with :? InvalidOperationException as e ->
        printfn $"{e.InnerException.Message}"

    // Deserialize the data.
    use fs = new FileStream(filenameXml, FileMode.Open)
        
    let deserializedDates = serializer.Deserialize fs :?> DateTime []

    // Display the dates.
    printfn $"Leap year days from 2000-2100 on an {Thread.CurrentThread.CurrentCulture.Name} system:"
    
    let mutable nItems = 0
    for dat in deserializedDates do
        printf $"   {dat:d}     "
        nItems <- nItems + 1
        if nItems % 5 = 0 then
            printfn ""

// The example displays the following output:
//    Leap year days from 2000-2100 on an en-GB system:
//       29/02/2000       29/02/2004       29/02/2008       29/02/2012       29/02/2016
//       29/02/2020       29/02/2024       29/02/2028       29/02/2032       29/02/2036
//       29/02/2040       29/02/2044       29/02/2048       29/02/2052       29/02/2056
//       29/02/2060       29/02/2064       29/02/2068       29/02/2072       29/02/2076
//       29/02/2080       29/02/2084       29/02/2088       29/02/2092       29/02/2096

Az előző példa nem tartalmaz időadatokat. A DateTime érték egy adott időpontot jelöl, és helyi időként van kifejezve. A ToUniversalTime metódus meghívásával alakítsa át helyi időről UTC-re, mielőtt szerializálja. A deszerializálás után hívja meg a ToLocalTime metódust, hogy az UTC-időt helyi időre alakítsa át.

DateTime és TimeSpan

Az DateTime és TimeSpan az értéktípusok abban különböznek, hogy egy DateTime pillanatnyi időt jelöl, míg egy időintervallumot TimeSpan . Az egyik példányt kivonhatja a másikból, hogy egy olyan objektumot kapjon DateTime, amely a közöttük lévő időintervallumot jelöli. Vagy hozzáadhat egy pozitív TimeSpan értéket az aktuális DateTime értékhez, hogy egy jövőbeli dátumot képviselő DateTime értéket kapjon.

Egy időintervallumot hozzáadhat vagy kivonhat egy DateTime objektumból. Az időintervallumok lehetnek negatívak vagy pozitívak, és mértékegységekben, például kullancsokban, másodpercekben vagy objektumként TimeSpan is kifejezhetők.

Az egyenlőség összehasonlítása tűréshatáron belül

Az DateTime értékek egyenlőségi összehasonlítása pontos. Egyenlőnek kell tekinteni, hogy két értéket azonos számú kullancsmal kell kifejezni. Ez a pontosság sok alkalmazás esetében gyakran szükségtelen vagy helytelen. Gyakran érdemes tesztelni DateTime , hogy az objektumok nagyjából azonosak-e.

Az alábbi példa bemutatja, hogyan hasonlíthatók össze nagyjából egyenértékű DateTime értékek. A különbség kisebb margóját fogadja el, amikor egyenlőnek nyilvánítja őket.

public static bool RoughlyEquals(DateTime time, DateTime timeWithWindow, int windowInSeconds, int frequencyInSeconds)
{
    long delta = (long)((TimeSpan)(timeWithWindow - time)).TotalSeconds % frequencyInSeconds;
    delta = delta > windowInSeconds ? frequencyInSeconds - delta : delta;
    return Math.Abs(delta) < windowInSeconds;
}

public static void TestRoughlyEquals()
{
    int window = 10;
    int freq = 60 * 60 * 2; // 2 hours;

    DateTime d1 = DateTime.Now;

    DateTime d2 = d1.AddSeconds(2 * window);
    DateTime d3 = d1.AddSeconds(-2 * window);
    DateTime d4 = d1.AddSeconds(window / 2);
    DateTime d5 = d1.AddSeconds(-window / 2);

    DateTime d6 = (d1.AddHours(2)).AddSeconds(2 * window);
    DateTime d7 = (d1.AddHours(2)).AddSeconds(-2 * window);
    DateTime d8 = (d1.AddHours(2)).AddSeconds(window / 2);
    DateTime d9 = (d1.AddHours(2)).AddSeconds(-window / 2);

    Console.WriteLine($"d1 ({d1}) ~= d1 ({d1}): {RoughlyEquals(d1, d1, window, freq)}");
    Console.WriteLine($"d1 ({d1}) ~= d2 ({d2}): {RoughlyEquals(d1, d2, window, freq)}");
    Console.WriteLine($"d1 ({d1}) ~= d3 ({d3}): {RoughlyEquals(d1, d3, window, freq)}");
    Console.WriteLine($"d1 ({d1}) ~= d4 ({d4}): {RoughlyEquals(d1, d4, window, freq)}");
    Console.WriteLine($"d1 ({d1}) ~= d5 ({d5}): {RoughlyEquals(d1, d5, window, freq)}");

    Console.WriteLine($"d1 ({d1}) ~= d6 ({d6}): {RoughlyEquals(d1, d6, window, freq)}");
    Console.WriteLine($"d1 ({d1}) ~= d7 ({d7}): {RoughlyEquals(d1, d7, window, freq)}");
    Console.WriteLine($"d1 ({d1}) ~= d8 ({d8}): {RoughlyEquals(d1, d8, window, freq)}");
    Console.WriteLine($"d1 ({d1}) ~= d9 ({d9}): {RoughlyEquals(d1, d9, window, freq)}");
}
// The example displays output similar to the following:
//    d1 (1/28/2010 9:01:26 PM) ~= d1 (1/28/2010 9:01:26 PM): True
//    d1 (1/28/2010 9:01:26 PM) ~= d2 (1/28/2010 9:01:46 PM): False
//    d1 (1/28/2010 9:01:26 PM) ~= d3 (1/28/2010 9:01:06 PM): False
//    d1 (1/28/2010 9:01:26 PM) ~= d4 (1/28/2010 9:01:31 PM): True
//    d1 (1/28/2010 9:01:26 PM) ~= d5 (1/28/2010 9:01:21 PM): True
//    d1 (1/28/2010 9:01:26 PM) ~= d6 (1/28/2010 11:01:46 PM): False
//    d1 (1/28/2010 9:01:26 PM) ~= d7 (1/28/2010 11:01:06 PM): False
//    d1 (1/28/2010 9:01:26 PM) ~= d8 (1/28/2010 11:01:31 PM): True
//    d1 (1/28/2010 9:01:26 PM) ~= d9 (1/28/2010 11:01:21 PM): True

let roughlyEquals (time: DateTime) (timeWithWindow: DateTime) windowInSeconds frequencyInSeconds =
    let delta = 
        int64 (timeWithWindow - time).TotalSeconds % frequencyInSeconds
    
    let delta = if delta > windowInSeconds then frequencyInSeconds - delta else delta
    abs delta < windowInSeconds

let testRoughlyEquals () =
    let window = 10
    let window' = 10.
    let freq = 60 * 60 * 2 // 2 hours

    let d1 = DateTime.Now

    let d2 = d1.AddSeconds(2. * window')
    let d3 = d1.AddSeconds(-2. * window')
    let d4 = d1.AddSeconds(window' / 2.)
    let d5 = d1.AddSeconds(-window' / 2.)

    let d6 = (d1.AddHours 2).AddSeconds(2. * window')
    let d7 = (d1.AddHours 2).AddSeconds(-2. * window')
    let d8 = (d1.AddHours 2).AddSeconds(window' / 2.)
    let d9 = (d1.AddHours 2).AddSeconds(-window' / 2.)

    printfn $"d1 ({d1}) ~= d1 ({d1}): {roughlyEquals d1 d1 window freq}"
    printfn $"d1 ({d1}) ~= d2 ({d2}): {roughlyEquals d1 d2 window freq}"
    printfn $"d1 ({d1}) ~= d3 ({d3}): {roughlyEquals d1 d3 window freq}"
    printfn $"d1 ({d1}) ~= d4 ({d4}): {roughlyEquals d1 d4 window freq}"
    printfn $"d1 ({d1}) ~= d5 ({d5}): {roughlyEquals d1 d5 window freq}"

    printfn $"d1 ({d1}) ~= d6 ({d6}): {roughlyEquals d1 d6 window freq}"
    printfn $"d1 ({d1}) ~= d7 ({d7}): {roughlyEquals d1 d7 window freq}"
    printfn $"d1 ({d1}) ~= d8 ({d8}): {roughlyEquals d1 d8 window freq}"
    printfn $"d1 ({d1}) ~= d9 ({d9}): {roughlyEquals d1 d9 window freq}"

// The example displays output similar to the following:
//    d1 (1/28/2010 9:01:26 PM) ~= d1 (1/28/2010 9:01:26 PM): True
//    d1 (1/28/2010 9:01:26 PM) ~= d2 (1/28/2010 9:01:46 PM): False
//    d1 (1/28/2010 9:01:26 PM) ~= d3 (1/28/2010 9:01:06 PM): False
//    d1 (1/28/2010 9:01:26 PM) ~= d4 (1/28/2010 9:01:31 PM): True
//    d1 (1/28/2010 9:01:26 PM) ~= d5 (1/28/2010 9:01:21 PM): True
//    d1 (1/28/2010 9:01:26 PM) ~= d6 (1/28/2010 11:01:46 PM): False
//    d1 (1/28/2010 9:01:26 PM) ~= d7 (1/28/2010 11:01:06 PM): False
//    d1 (1/28/2010 9:01:26 PM) ~= d8 (1/28/2010 11:01:31 PM): True
//    d1 (1/28/2010 9:01:26 PM) ~= d9 (1/28/2010 11:01:21 PM): True

Public Shared Function RoughlyEquals(time As DateTime, timeWithWindow As DateTime,
                             windowInSeconds As Integer,
                             frequencyInSeconds As Integer) As Boolean
    Dim delta As Long = (timeWithWindow.Subtract(time)).TotalSeconds _
                                            Mod frequencyInSeconds

    If delta > windowInSeconds Then
        delta = frequencyInSeconds - delta
    End If

    Return Math.Abs(delta) < windowInSeconds
End Function

Public Shared Sub TestRoughlyEquals()
    Dim window As Integer = 10
    Dim freq As Integer = 60 * 60 * 2 ' 2 hours;
    Dim d1 As DateTime = DateTime.Now

    Dim d2 As DateTime = d1.AddSeconds(2 * window)
    Dim d3 As DateTime = d1.AddSeconds(-2 * window)
    Dim d4 As DateTime = d1.AddSeconds(window / 2)
    Dim d5 As DateTime = d1.AddSeconds(-window / 2)

    Dim d6 As DateTime = d1.AddHours(2).AddSeconds(2 * window)
    Dim d7 As DateTime = d1.AddHours(2).AddSeconds(-2 * window)
    Dim d8 As DateTime = d1.AddHours(2).AddSeconds(window / 2)
    Dim d9 As DateTime = d1.AddHours(2).AddSeconds(-window / 2)

    Console.WriteLine($"d1 ({d1}) ~= d1 ({d1}): {RoughlyEquals(d1, d1, window, freq)}")
    Console.WriteLine($"d1 ({d1}) ~= d2 ({d2}): {RoughlyEquals(d1, d2, window, freq)}")
    Console.WriteLine($"d1 ({d1}) ~= d3 ({d3}): {RoughlyEquals(d1, d3, window, freq)}")
    Console.WriteLine($"d1 ({d1}) ~= d4 ({d4}): {RoughlyEquals(d1, d4, window, freq)}")
    Console.WriteLine($"d1 ({d1}) ~= d5 ({d5}): {RoughlyEquals(d1, d5, window, freq)}")

    Console.WriteLine($"d1 ({d1}) ~= d6 ({d6}): {RoughlyEquals(d1, d6, window, freq)}")
    Console.WriteLine($"d1 ({d1}) ~= d7 ({d7}): {RoughlyEquals(d1, d7, window, freq)}")
    Console.WriteLine($"d1 ({d1}) ~= d8 ({d8}): {RoughlyEquals(d1, d8, window, freq)}")
    Console.WriteLine($"d1 ({d1}) ~= d9 ({d9}): {RoughlyEquals(d1, d9, window, freq)}")
End Sub
' The example displays output similar to the following:
'    d1 (1/28/2010 9:01:26 PM) ~= d1 (1/28/2010 9:01:26 PM): True
'    d1 (1/28/2010 9:01:26 PM) ~= d2 (1/28/2010 9:01:46 PM): False
'    d1 (1/28/2010 9:01:26 PM) ~= d3 (1/28/2010 9:01:06 PM): False
'    d1 (1/28/2010 9:01:26 PM) ~= d4 (1/28/2010 9:01:31 PM): True
'    d1 (1/28/2010 9:01:26 PM) ~= d5 (1/28/2010 9:01:21 PM): True
'    d1 (1/28/2010 9:01:26 PM) ~= d6 (1/28/2010 11:01:46 PM): False
'    d1 (1/28/2010 9:01:26 PM) ~= d7 (1/28/2010 11:01:06 PM): False
'    d1 (1/28/2010 9:01:26 PM) ~= d8 (1/28/2010 11:01:31 PM): True
'    d1 (1/28/2010 9:01:26 PM) ~= d9 (1/28/2010 11:01:21 PM): True

szempontok a COM interophoz

Egy DateTime értéket, amelyet átvisszük egy COM-alkalmazásba, majd visszavisszük egy felügyelt alkalmazásba, a fordított úton való átadásként emlegetjük. A DateTime csak időt megadó érték azonban nem az elvárható módon járja körbe az utazást.

Ha csak egy időpontot ad meg, például 15:00-kor, a végső dátum és idő 1899. december 30., 15:00 óra lesz, a 0001. január 1., 15:00 óra helyett. A .NET és a COM alapértelmezett dátumot feltételez, ha csak egy időpont van megadva. A COM rendszer azonban 1899. december 30-i alapdátumot feltételez, míg a .NET 0001. január 1-jei alapdátumot feltételez.

Ha csak egy idő van átadva a .NET-ről a COM-nak, speciális feldolgozás történik, amely az időt a COM által használt formátumra alakítja át. Ha csak egy időpontot ad át a COM-ból a .NET-nek, nem végeznek különleges feldolgozást, mert az 1899. december 30-án vagy azt megelőzően érvényes dátumokat és időpontokat rontaná. Ha egy dátum a COM-ból indul, a .NET és a COM megőrzi a dátumot.

A .NET és a COM viselkedése azt jelenti, hogy ha az alkalmazás körbejár egy DateTime, amely csak egy időpontot határoz meg, az alkalmazásnak emlékeznie kell a hibás dátum módosítására vagy figyelmen kívül hagyására a végső DateTime objektumban.

Szálbiztonság

Az ilyen típusú tagok szálbiztosak. Azok a tagok, amelyek úgy tűnik, hogy módosítják a példány állapotát, valójában egy új példányt ad vissza, amely inicializálva van az új értékkel. Mint minden más típus esetén, az ilyen típusú példányt tartalmazó megosztott változókra való olvasást és írást zárolással kell védeni a szálbiztonság érdekében.

Lásd még

• DateTimeOffset
• TimeSpan
• Calendar
• GetUtcOffset(DateTime)
• TimeZoneInfo
• A DateTime, DateTimeOffset, TimeSpan és TimeZoneInfo közötti választás
• Naptárak használata
• minta: .NET Core WinForms Formatting Utility (C#)
• minta: .NET Core WinForms Formatting Utility (Visual Basic)