Dátum- és idősztringek elemzése a .NET-ben

A .NET számos típust biztosít a dátum- és időadatok kezeléséhez, amelyek mindegyike különböző forgatókönyvekhez van optimalizálva:

DateTime – Egy dátumot és időt jelöl együtt, ideális, ha mindkét összetevőre vagy az örökölt kód használatakor van szüksége.
DateOnly (a .NET-keretrendszerben nem érhető el) – Csak olyan dátumot jelöl, amely nem tartalmaz időadatokat, ideális születésnapokhoz, évfordulókhoz vagy üzleti dátumokhoz.
TimeOnly (a .NET-keretrendszerben nem érhető el) – Csak dátuminformáció nélküli időpontot jelöl, ideális ütemezésekhez, riasztásokhoz vagy ismétlődő napi eseményekhez.

Minden típus olyan elemzési metódusokat biztosít, amelyek a sztringeket a saját objektumaikká alakítják, különböző rugalmassági szintekkel és az elemzési folyamat szabályozásával.

Általános elemzési fogalmak

Mindhárom dátum- és időtípus hasonló elemzési módszerekkel rendelkezik:

Parse és TryParse metódusok – Számos gyakori sztring-ábrázolás átalakítása az aktuális vagy megadott kultúrális beállítások alkalmazásával.
ParseExact és TryParseExact metódusok – Adott formátummintáknak megfelelő karakterláncok konvertálása, amely pontos vezérlést biztosít a várt formátumok felett, beleértve a kulturális beállításokat is.
Formátum karakterláncok – Minták definiálása elemzés céljából szabványos vagy egyedi formátumjelölők segítségével.

A különböző kultúrák különböző megrendeléseket használnak nap, hónap és év szerint. Egyes időábrázolások 24 órás órát használnak, mások az "AM" és a "PM" értéket adják meg. Az elemzési metódusok a kultúraspecifikus formázási szabályokkal kezelik ezeket a változatokat.

Az DateTimeFormatInfo objektum szabályozza a szöveg értelmezésének módját. A tulajdonságok a dátum- és időelválasztókat, a hónapok, napok, korok nevét, valamint az "AM" és a "PM" megjelölések formátumát írják le. A IFormatProvider paraméteren keresztül megadhatja a kultúrát egy CultureInfo objektum vagy egy DateTimeFormatInfo objektum használatával.

A formázási mintákkal kapcsolatos további információkért tekintse meg a szabványos dátum- és időformátum-sztringeket , valamint az egyéni dátum- és időformátum-sztringeket.

Fontos

DateOnly és TimeOnly a típusok nem érhetők el a .NET-keretrendszerhez.

Dátum és idő elemzése

DateTime a dátum- és időösszetevőket együtt jelöli. A stringek objektumoknak való DateTime elemzésekor több DateTime-specifikus szempontot is figyelembe kell venni:

Hiányzó információkezelés - DateTime alapértelmezéseket használ, ha a bemeneti sztringből hiányoznak alkatrészek.
Időzóna és UTC-eltolás támogatása - DateTime helyi, UTC vagy meghatározatlan időzónákat jelölhet.
Kombinált dátum- és időelemzés – Egyetlen művelet dátum- és időösszetevőit is kezelnie kell.

Hiányzó információkezelés

Előfordulhat, hogy a dátumot vagy időt ábrázoló szövegből hiányzik néhány információ. A legtöbben például azt feltételezik, hogy a "Március 12" dátum az aktuális évet jelöli. Hasonlóképpen, a "2018. március" a 2018. évi márciusi hónap. Az időt ábrázoló szöveg gyakran csak órákat, perceket és am/PM megjelölést tartalmaz. DateTime Az elemzési metódusok ésszerű alapértelmezett beállításokkal kezelik ezt a hiányzó információt:

Ha csak az idő jelenik meg, a dátumrész az aktuális dátumot használja.
Ha csak a dátum van jelen, az időrész éjfél.
Ha az év nincs megadva egy dátumban, a rendszer az aktuális évet használja.
Ha nincs megadva a hónap napja, a rendszer a hónap első napját használja.

Ha a dátum szerepel a láncban, akkor annak tartalmaznia kell a hónapot, valamint a napot vagy az évet is. Ha az időpont meg van adva, annak tartalmaznia kell az órát, és vagy a perceket, vagy az AM/PM jelölőt.

Az alapértelmezett értékek felülbírálásához megadhatja az NoCurrentDateDefault állandót. Ha ezt az állandót használja, a hiányzó év-, hónap- vagy naptulajdonságok az értékre 1lesznek állítva. Ezt a viselkedést az utolsó példa Parse szemlélteti.

UTC-eltolás és időzóna kezelése

A dátum és az idő összetevő mellett a dátum és az idő sztring-ábrázolása olyan eltolást is tartalmazhat, amely azt jelzi, hogy az idő mennyiben tér el az egyezményes világidőtől (UTC). A "2007.02.14. 5:32:00 -7:00" sztring például az UTC-nél hét órával korábbi időpontot határoz meg. Ha egy idő sztring-ábrázolása nem tartalmaz eltolást, az elemzés egy DateTime objektumot ad vissza, amelynek Kind tulajdonsága DateTimeKind.Unspecified-ra van állítva. Ha eltolás van megadva, az elemzés egy DateTime objektumot ad vissza, amelynek a(z) Kind tulajdonsága DateTimeKind.Local-re van állítva. Az érték a gép helyi időzónájához is igazodik. Ezt a viselkedést egy DateTimeStyles érték használatával módosíthatja az elemzési módszerrel.

Nem egyértelmű dátumkezelés

A formátumszolgáltató egy nem egyértelmű numerikus dátum értelmezésére is használható. Nem világos, hogy a "02/03/04" karakterlánc által képviselt dátum hónapja, napja és éve melyek. Az összetevőket a formátumszolgáltató hasonló dátumformátumainak sorrendje szerint értelmezi a rendszer.

DateTime.Parse

Az alábbi példa azt mutatja be, hogyan konvertálhat egy DateTime.Parse-t egy string-vé a DateTime metódus használatával. Ez a példa az aktuális szálhoz társított kultúrát használja. Ha az CultureInfo aktuális kulturális környezethez társított nem tudja elemezni a bemeneti sztringet, a rendszer egy FormatException értéket ad.

static void DateTimeParseExample()
{
    // Parse common date and time formats using current culture
    var dateTime1 = DateTime.Parse("1/15/2025 3:30 PM");
    var dateTime2 = DateTime.Parse("January 15, 2025");
    var dateTime3 = DateTime.Parse("15:30:45");

    Console.WriteLine($"Parsed: {dateTime1}");
    Console.WriteLine($"Parsed: {dateTime2}");
    Console.WriteLine($"Parsed: {dateTime3}");

    // Parse with specific culture
    var germanDate = DateTime.Parse("15.01.2025", new CultureInfo("de-DE"));
    Console.WriteLine($"German date parsed: {germanDate}");
}

Sub DateTimeParseExample()
    ' Parse common date and time formats using current culture
    Dim dateTime1 = DateTime.Parse("1/15/2025 3:30 PM")
    Dim dateTime2 = DateTime.Parse("January 15, 2025")
    Dim dateTime3 = DateTime.Parse("15:30:45")

    Console.WriteLine($"Parsed: {dateTime1}")
    Console.WriteLine($"Parsed: {dateTime2}")
    Console.WriteLine($"Parsed: {dateTime3}")

    ' Parse with specific culture
    Dim germanDate = DateTime.Parse("15.01.2025", New CultureInfo("de-DE"))
    Console.WriteLine($"German date parsed: {germanDate}")
End Sub

Explicit módon megadhatja azt a kultúrát is, amelynek formázási konvencióit sztring elemzésekor használja a rendszer. Megadhatja a tulajdonság által visszaadott standard DateTimeFormatInfo objektumok egyikét CultureInfo.DateTimeFormat . Az alábbi példa egy formátumszolgáltató használatával értelmez egy német karakterláncot egy DateTime-re. Létrehoz egy CultureInfo, ami a(z) de-DE kultúrát képviseli. Ez az CultureInfo objektum biztosítja az adott sztring sikeres elemzését. Ez a folyamat meggátolja bármilyen beállítás érvényesülését a CurrentCulture a(z) CurrentThread-ben.

static void DateTimeParseGermanExample()
{
    var cultureInfo = new CultureInfo("de-DE");
    string dateString = "12 Juni 2008";
    var dateTime = DateTime.Parse(dateString, cultureInfo);
    Console.WriteLine(dateTime);
    // The example displays the following output:
    //       6/12/2008 00:00:00
}

Sub DateTimeParseGermanExample()
    Dim MyCultureInfo As New CultureInfo("de-DE")
    Dim MyString As String = "12 Juni 2008"
    Dim MyDateTime As DateTime = DateTime.Parse(MyString, MyCultureInfo)
    Console.WriteLine(MyDateTime)
    ' The example displays the following output:
    '       6/12/2008 00:00:00
End Sub

A Parse metódus túlterhelését azonban használhatja egyéni formátumszolgáltatók megadására. A Parse metódus nem támogatja a nem szabványos formátumok elemzését. Ha nem szabványos formátumban szeretné elemezni a dátumot és az időt, használja inkább a metódust ParseExact .

Az alábbi példa az DateTimeStyles enumerálással határozza meg, hogy az aktuális dátum- és időinformációk ne legyenek hozzáadva a DateTime meghatározatlan mezőkhöz.

static void DateTimeParseNoDefaultExample()
{
    var cultureInfo = new CultureInfo("de-DE");
    string dateString = "12 Juni 2008";
    var dateTime = DateTime.Parse(dateString, cultureInfo,
                                    DateTimeStyles.NoCurrentDateDefault);
    Console.WriteLine(dateTime);
    // The example displays the following output if the current culture is en-US:
    //      6/12/2008 00:00:00
}

Sub DateTimeParseNoDefaultExample()
    Dim MyCultureInfo As New CultureInfo("de-DE")
    Dim MyString As String = "12 Juni 2008"
    Dim MyDateTime As DateTime = DateTime.Parse(MyString, MyCultureInfo,
                               DateTimeStyles.NoCurrentDateDefault)
    Console.WriteLine(MyDateTime)
    ' The example displays the following output if the current culture is en-US:
    '       6/12/2008 00:00:00
End Sub

DateTime.ParseExact

A DateTime.ParseExact metódus objektummá konvertál egy sztringet DateTime , ha az megfelel a megadott sztringminták egyikének. Ha a megadott űrlapok egyike sem egy sztringet ad át ehhez a metódushoz, a függvény egy FormatException karaktert ad vissza. Megadhatja a szabványos dátum- és időformátum-meghatározók egyikét, vagy az egyéni formátumjelölők kombinációját. Az egyéni formátumjelölők használatával egyéni felismerési sztringet hozhat létre. A kijelölők magyarázatát a standard dátum- és időformátum sztringjeiről , valamint az egyéni dátum- és időformátum-sztringekről szóló cikkekben talál.

A következő példában a DateTime.ParseExact metódus egy sztringobjektumot ad át az elemzéshez, majd egy formátumkijelölőt, majd egy CultureInfo objektumot. Ez a ParseExact módszer csak a hosszú dátummintát követő karakterláncokat elemezheti a en-US kultúrában.

static void DateTimeParseExactExample()
{
    // Parse exact format
    var exactDate = DateTime.ParseExact("2025-01-15T14:30:00", "yyyy-MM-ddTHH:mm:ss", CultureInfo.InvariantCulture);
    Console.WriteLine($"Exact parse: {exactDate}");

    // Parse with custom format
    var customDate = DateTime.ParseExact("15/Jan/2025 2:30 PM", "dd/MMM/yyyy h:mm tt", CultureInfo.InvariantCulture);
    Console.WriteLine($"Custom format: {customDate}");
}

Sub DateTimeParseExactExample()
    ' Parse exact format
    Dim exactDate = DateTime.ParseExact("2025-01-15T14:30:00", "yyyy-MM-ddTHH:mm:ss", CultureInfo.InvariantCulture)
    Console.WriteLine($"Exact parse: {exactDate}")

    ' Parse with custom format
    Dim customDate = DateTime.ParseExact("15/Jan/2025 2:30 PM", "dd/MMM/yyyy h:mm tt", CultureInfo.InvariantCulture)
    Console.WriteLine($"Custom format: {customDate}")
End Sub

A Parse és ParseExact metódusok minden egyes túlterhelése rendelkezik egy IFormatProvider paraméterrel, amely kultúraspecifikus információkat nyújt a karakterlánc formázásáról. Az IFormatProvider objektum egy CultureInfo olyan objektum, amely egy standard kultúrát vagy egy DateTimeFormatInfo , a CultureInfo.DateTimeFormat tulajdonság által visszaadott objektumot jelöl. ParseExact egy további sztring- vagy sztringtömb argumentumot is használ, amely egy vagy több egyéni dátum- és időformátumot határoz meg.

DateOnly feldolgozás

A DateOnly struktúra csak egy dátumot jelöl, amely nem tartalmaz időadatokat, így tökéletes választás olyan helyzetekhez, mint a születésnapok, évfordulók vagy üzleti dátumok. Mivel nincs időösszetevője, a nap elejétől a nap végéig egy dátumot jelöl.

DateOnly számos előnnyel rendelkezik a csak dátumalapú forgatókönyvekhez való használattal DateTime szemben:

A DateTime struktúra az előző vagy a következő napra kerülhet, ha egy időzóna eltolása történik. DateOnly nem lehet időzóna szerint áthelyezni, és mindig a beállított dátumot képviseli.
A szerializálás DateOnly kevesebb adatot tartalmaz, mint DateTimea .
Amikor a kód egy adatbázissal (például az SQL Serverrel) kommunikál, a rendszer általában a teljes dátumokat tárolja adattípusként date , ami nem tartalmaz időt. DateOnly jobban megfelel az adatbázis típusának.

DateOnly.Parse

A DateOnly.Parse metódus a gyakori dátumsztring-ábrázolásokat objektummá DateOnly alakítja. A metódus különböző formátumokat fogad el, és az aktuális vagy egy adott kultúrát használja elemzésre.

static void DateOnlyParseExample()
{
    // Parse common date formats
    var date1 = DateOnly.Parse("1/15/2025");
    var date2 = DateOnly.Parse("January 15, 2025", CultureInfo.InvariantCulture);
    var date3 = DateOnly.Parse("2025-01-15");

    Console.WriteLine($"Parsed date: {date1}");
    Console.WriteLine($"Parsed date: {date2.ToString("D")}"); // Long date format
    Console.WriteLine($"Parsed date: {date3.ToString("yyyy-MM-dd")}");

    // Parse with specific culture
    var germanDate = DateOnly.Parse("15.01.2025", new CultureInfo("de-DE"));
    Console.WriteLine($"German date: {germanDate}");
}

Sub DateOnlyParseExample()
    ' Parse common date formats
    Dim date1 = DateOnly.Parse("1/15/2025")
    Dim date2 = DateOnly.Parse("January 15, 2025", CultureInfo.InvariantCulture)
    Dim date3 = DateOnly.Parse("2025-01-15")

    Console.WriteLine($"Parsed date: {date1}")
    Console.WriteLine($"Parsed date: {date2.ToString("D")}") ' Long date format
    Console.WriteLine($"Parsed date: {date3.ToString("yyyy-MM-dd")}")

    ' Parse with specific culture
    Dim germanDate = DateOnly.Parse("15.01.2025", New CultureInfo("de-DE"))
    Console.WriteLine($"German date: {germanDate}")
End Sub

DateOnly.ParseExact

A DateOnly.ParseExact metódus pontos vezérlést biztosít a bemeneti sztring várt formátuma felett. Ezt a módszert akkor használja, ha ismeri a dátumsztring pontos formátumát, és szigorú elemzést szeretne biztosítani.

static void DateOnlyParseExactExample()
{
    // Parse exact format
    var exactDate = DateOnly.ParseExact("21 Oct 2015", "dd MMM yyyy", CultureInfo.InvariantCulture);
    Console.WriteLine($"Exact date: {exactDate}");

    // Parse ISO format
    var isoDate = DateOnly.ParseExact("2025-01-15", "yyyy-MM-dd", CultureInfo.InvariantCulture);
    Console.WriteLine($"ISO date: {isoDate}");

    // Parse with multiple possible formats
    string[] formats = { "MM/dd/yyyy", "M/d/yyyy", "dd/MM/yyyy" };
    var flexibleDate = DateOnly.ParseExact("1/15/2025", formats, CultureInfo.InvariantCulture, DateTimeStyles.None);
    Console.WriteLine($"Flexible parse: {flexibleDate}");
}

Sub DateOnlyParseExactExample()
    ' Parse exact format
    Dim exactDate = DateOnly.ParseExact("21 Oct 2015", "dd MMM yyyy", CultureInfo.InvariantCulture)
    Console.WriteLine($"Exact date: {exactDate}")

    ' Parse ISO format
    Dim isoDate = DateOnly.ParseExact("2025-01-15", "yyyy-MM-dd", CultureInfo.InvariantCulture)
    Console.WriteLine($"ISO date: {isoDate}")

    ' Parse with multiple possible formats
    Dim formats() As String = {"MM/dd/yyyy", "M/d/yyyy", "dd/MM/yyyy"}
    Dim flexibleDate = DateOnly.ParseExact("1/15/2025", formats, CultureInfo.InvariantCulture, DateTimeStyles.None)
    Console.WriteLine($"Flexible parse: {flexibleDate}")
End Sub

A ParseExact metódus egyetlen formátumsztringet vagy formátumsztring-tömböt fogad el, így több elfogadható formátumban is elemezheti a dátumokat.

TimeOnly elemzés

A TimeOnly struktúra egy napközbeni értéket jelöl, például egy napi ébresztőórát, vagy azt, hogy mikor ebédel minden nap. TimeOnly a 00:00:00.0000000 - 23:59:59.99999999 tartományra korlátozódik, amely egy adott napidő.

TimeOnly számos olyan problémát old meg, amely más típusú, csak időalapú forgatókönyvek használata esetén is fennállt:

TimeSpan az eltelt időt jelöli, és negatív vagy 24 órát meghaladó lehet, így nem alkalmas egy adott napidőre.
Az DateTime időpontként való használata tetszőleges dátum megadását igényli, ami váratlan viselkedést eredményezhet számítások elvégzésekor.
TimeOnly természetesen kezeli a 24 órás váltást az időértékek hozzáadásakor vagy kivonásakor.

TimeOnly.Parse

A TimeOnly.Parse metódus a közös idő sztring-ábrázolásait objektummá TimeOnly alakítja. A metódus különböző formátumokat fogad el, beleértve a 12 órás és a 24 órás jelölést.

static void TimeOnlyParseExample()
{
    // Parse common time formats
    var time1 = TimeOnly.Parse("14:30:15");
    var time2 = TimeOnly.Parse("2:30 PM", CultureInfo.InvariantCulture);
    var time3 = TimeOnly.Parse("17:45");

    Console.WriteLine($"Parsed time: {time1}");
    Console.WriteLine($"Parsed time: {time2.ToString("t")}"); // Short time format
    Console.WriteLine($"Parsed time: {time3.ToString("HH:mm")}");

    // Parse with milliseconds
    var preciseTime = TimeOnly.Parse("14:30:15.123");
    Console.WriteLine($"Precise time: {preciseTime.ToString("HH:mm:ss.fff")}");
}

Sub TimeOnlyParseExample()
    ' Parse common time formats
    Dim time1 = TimeOnly.Parse("14:30:15")
    Dim time2 = TimeOnly.Parse("2:30 PM", CultureInfo.InvariantCulture)
    Dim time3 = TimeOnly.Parse("17:45")

    Console.WriteLine($"Parsed time: {time1}")
    Console.WriteLine($"Parsed time: {time2.ToString("t")}") ' Short time format
    Console.WriteLine($"Parsed time: {time3.ToString("HH:mm")}")

    ' Parse with milliseconds
    Dim preciseTime = TimeOnly.Parse("14:30:15.123")
    Console.WriteLine($"Precise time: {preciseTime.ToString("HH:mm:ss.fff")}")
End Sub

TimeOnly.ParseExact

A TimeOnly.ParseExact metódus pontosan szabályozza a bemeneti idő sztringjének várt formátumát. Ezt a módszert akkor használja, ha ismeri a pontos formátumot, és szigorú elemzést szeretne biztosítani.

static void TimeOnlyParseExactExample()
{
    // Parse exact format
    var exactTime = TimeOnly.ParseExact("5:00 pm", "h:mm tt", CultureInfo.InvariantCulture);
    Console.WriteLine($"Exact time: {exactTime}");

    // Parse 24-hour format
    var militaryTime = TimeOnly.ParseExact("17:30:25", "HH:mm:ss", CultureInfo.InvariantCulture);
    Console.WriteLine($"Military time: {militaryTime}");

    // Parse with multiple possible formats
    string[] timeFormats = { "h:mm tt", "HH:mm", "H:mm" };
    var flexibleTime = TimeOnly.ParseExact("2:30 PM", timeFormats, CultureInfo.InvariantCulture, DateTimeStyles.None);
    Console.WriteLine($"Flexible time parse: {flexibleTime}");
}

Sub TimeOnlyParseExactExample()
    ' Parse exact format
    Dim exactTime = TimeOnly.ParseExact("5:00 pm", "h:mm tt", CultureInfo.InvariantCulture)
    Console.WriteLine($"Exact time: {exactTime}")

    ' Parse 24-hour format
    Dim militaryTime = TimeOnly.ParseExact("17:30:25", "HH:mm:ss", CultureInfo.InvariantCulture)
    Console.WriteLine($"Military time: {militaryTime}")

    ' Parse with multiple possible formats
    Dim timeFormats() As String = {"h:mm tt", "HH:mm", "H:mm"}
    Dim flexibleTime = TimeOnly.ParseExact("2:30 PM", timeFormats, CultureInfo.InvariantCulture, DateTimeStyles.None)
    Console.WriteLine($"Flexible time parse: {flexibleTime}")
End Sub

Lásd még

Visszajelzés

Hasznosnak találta ezt az oldalt?

Last updated on 2026-01-22