Delen via

Datum- en tijdtekenreeksen parseren in .NET

.NET biedt verschillende typen voor het werken met datum- en tijdgegevens, die elk zijn geoptimaliseerd voor verschillende scenario's:

  • DateTime - Vertegenwoordigt een datum en tijd samen, ideaal wanneer u beide onderdelen nodig hebt of wanneer u met verouderde code werkt.
  • DateOnly (niet beschikbaar in .NET Framework): vertegenwoordigt alleen een datum zonder tijdgegevens, perfect voor verjaardagen, verjaardagen of zakelijke datums.
  • TimeOnly (niet beschikbaar in .NET Framework): vertegenwoordigt alleen een tijd zonder datumgegevens, ideaal voor planningen, waarschuwingen of terugkerende dagelijkse gebeurtenissen.

Elk type biedt parseringsmethoden waarmee tekenreeksen worden geconverteerd naar hun respectieve objecten, met verschillende flexibiliteitsniveaus en controle over het parseringsproces.

Algemene parseringsconcepten

Alle drie de datum- en tijdtypen delen vergelijkbare parseringsmethoden:

  • Parse en TryParse methoden - Converteer veel algemene tekenreeksweergaven met behulp van de huidige cultuur of opgegeven cultuurinstellingen.
  • ParseExact en TryParseExact methoden : converteer tekenreeksen die voldoen aan specifieke indelingspatronen, waardoor nauwkeurige controle wordt geboden over verwachte indelingen, inclusief cultuurinstellingen.
  • Formatteerreeksen: definieer patronen voor het parseren met standaard- of aangepaste formatspecificaties.

Verschillende culturen gebruiken verschillende orders voor dag, maand en jaar. Sommige tijdweergaven gebruiken een 24-uurs klok, anderen geven 'AM' en 'PM' op. De parseringsmethoden verwerken deze variaties via cultuurspecifieke opmaakregels.

Het DateTimeFormatInfo object biedt controle over hoe tekst moet worden geïnterpreteerd. Eigenschappen beschrijven de datum- en tijdscheidingstekens, namen van maanden, dagen, eras en de notatie voor "AM" en "PM" aanduidingen. U kunt cultuur opgeven via de IFormatProvider parameter met behulp van een CultureInfo object of een DateTimeFormatInfo object.

Zie standaardtekenreeksen voor datum- en tijdnotatie en aangepaste datum- en tijdnotatietekenreeksen voor meer informatie over notatiepatronen.

Belangrijk

DateOnly en TimeOnly typen zijn niet beschikbaar voor .NET Framework.

Datum en tijd parseren

DateTime vertegenwoordigt zowel datum- als tijdonderdelen samen. Wanneer u tekenreeksen parseert aan DateTime objecten, moet u rekening houden met verschillende DateTime- specifieke aspecten:

  • Verwerking van ontbrekende gegevens - DateTime maakt gebruik van standaardinstellingen wanneer onderdelen ontbreken in de invoertekenreeks.
  • Ondersteuning voor - DateTime kan lokale, UTC- of niet-opgegeven tijdzones vertegenwoordigen.
  • Gecombineerde datum- en tijdparsering : moet zowel datum- als tijdonderdelen in één bewerking verwerken.

Verwerking van ontbrekende gegevens

In de tekst voor een datum of tijd ontbreken mogelijk bepaalde gegevens. De meeste mensen gaan er bijvoorbeeld van uit dat de datum '12 maart' het huidige jaar aangeeft. Op dezelfde manier vertegenwoordigt 'maart 2018' de maand maart in het jaar 2018. Tekst die de tijd vertegenwoordigt, bevat vaak slechts uren, minuten en een AM/PM-aanduiding. DateTime Methoden voor parseren verwerken deze ontbrekende informatie met behulp van redelijke standaardwaarden:

  • Wanneer alleen de tijd aanwezig is, gebruikt het datumgedeelte de huidige datum.
  • Wanneer alleen de datum aanwezig is, is het tijdgedeelte middernacht.
  • Wanneer het jaar niet is opgegeven in een datum, wordt het huidige jaar gebruikt.
  • Wanneer de dag van de maand niet is opgegeven, wordt de eerste dag van de maand gebruikt.

Als de datum aanwezig is in de tekenreeks, moet deze de maand en de dag of het jaar bevatten. Als de tijd wordt weergegeven, moet deze het uur bevatten, samen met de minuten of de AM/PM-aanduiding.

U kunt de NoCurrentDateDefault constante opgeven om deze standaardwaarden te overschrijven. Wanneer u die constante gebruikt, worden ontbrekende jaar-, maand- of dageigenschappen ingesteld op de waarde 1. In het laatste voorbeeld wordt Parse dit gedrag gedemonstreerd.

Verwerking van UTC-offset en tijdzone

Naast een datum- en tijdonderdeel kan de tekenreeksweergave van een datum en tijd een offset bevatten die aangeeft hoeveel tijd verschilt van Coordinated Universal Time (UTC). De tekenreeks 2-14-2007 5:32:00 -7:00 definieert bijvoorbeeld een tijd die zeven uur ouder is dan UTC. Als een offset wordt weggelaten uit de tekenreeksweergave van een tijd, retourneert parseren een DateTime object met de Kind eigenschap ingesteld op DateTimeKind.Unspecified. Als er een offset is opgegeven, retourneert parseren een DateTime object met de Kind eigenschap ingesteld op DateTimeKind.Local. De waarde wordt ook aangepast aan de lokale tijdzone van uw computer. U kunt dit gedrag wijzigen met behulp van een DateTimeStyles waarde met de parseringsmethode.

Niet-eenduidige verwerking van datums

De notatieprovider wordt ook gebruikt om een dubbelzinnige numerieke datum te interpreteren. Het is onduidelijk welke onderdelen van de datum die worden vertegenwoordigd door de tekenreeks '02/03/04' de maand, de dag en het jaar zijn. De onderdelen worden geïnterpreteerd volgens de volgorde van vergelijkbare datumnotaties in de formaatprovider.

DateTime.Parse

In het volgende voorbeeld ziet u het gebruik van de DateTime.Parse methode om een string te converteren naar een DateTime. In dit voorbeeld wordt de cultuur gebruikt die is gekoppeld aan de huidige thread. Als de CultureInfo gekoppelde aan de huidige cultuur de invoertekenreeks niet kan parseren, wordt er een FormatException gegenereerd.

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

U kunt ook expliciet de cultuur definiëren waarvan de opmaakconventies worden gebruikt wanneer u een tekenreeks parseert. U geeft een van de standaardobjecten DateTimeFormatInfo op die door de CultureInfo.DateTimeFormat eigenschap worden geretourneerd. In het volgende voorbeeld wordt een indelingsprovider gebruikt om een Duitse tekenreeks te parseren in een DateTime. Het creëert een CultureInfo representatie van de de-DE cultuur. Dit CultureInfo object zorgt ervoor dat deze specifieke tekenreeks succesvol wordt geparseerd. Dit proces voorkomt elke instelling in de CurrentCultureCurrentThread.

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

U kunt echter overbelastingen van de Parse methode gebruiken om providers voor aangepaste indelingen op te geven. De Parse methode biedt geen ondersteuning voor het parseren van niet-standaardindelingen. Als u een datum en tijd wilt parseren die zijn uitgedrukt in een niet-standaardnotatie, gebruikt u in plaats daarvan de ParseExact methode.

In het volgende voorbeeld wordt de DateTimeStyles opsomming gebruikt om op te geven dat de huidige datum- en tijdgegevens niet moeten worden toegevoegd aan de DateTime niet-opgegeven velden.

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

Met DateTime.ParseExact de methode wordt een tekenreeks geconverteerd naar een DateTime object als deze voldoet aan een van de opgegeven tekenreekspatronen. Wanneer een tekenreeks die geen van de opgegeven formulieren is, wordt doorgegeven aan deze methode, wordt er een FormatException gegenereerd. U kunt een van de standaardaanduidingen voor datum- en tijdnotatie of een combinatie van de aangepaste notatieaanduidingen opgeven. Met behulp van de aangepaste notatieaanduidingen kunt u een aangepaste herkenningstekenreeks maken. Zie de artikelen over standaardtekenreeksen voor datum- en tijdnotaties en aangepaste datum- en tijdnotatietekenreeksen voor een uitleg van de aanduidingen.

In het volgende voorbeeld wordt de DateTime.ParseExact methode doorgegeven aan een tekenreeksobject om te parseren, gevolgd door een notatieaanduiding, gevolgd door een CultureInfo object. Deze ParseExact methode kan alleen tekenreeksen parseren die het lange datumpatroon in de en-US cultuur volgen.

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

Elke overbelasting van de Parse en ParseExact methoden heeft ook een IFormatProvider parameter die cultuurspecifieke informatie biedt over de opmaak van de tekenreeks. Het IFormatProvider object is een CultureInfo object dat een standaardcultuur of een DateTimeFormatInfo object vertegenwoordigt dat door de CultureInfo.DateTimeFormat eigenschap wordt geretourneerd. ParseExact gebruikt ook een extra tekenreeks- of tekenreeksmatrixargument dat een of meer aangepaste datum- en tijdnotaties definieert.

De DateOnly parseren

De DateOnly structuur vertegenwoordigt alleen een datum zonder tijdgegevens, waardoor deze perfect is voor scenario's zoals verjaardagen, verjaardagen of zakelijke datums. Omdat het geen tijdcomponent heeft, vertegenwoordigt het een datum vanaf het begin van de dag tot het einde van de dag.

DateOnly heeft verschillende voordelen ten opzichte van het gebruik van DateTime in scenario's die alleen datums betreffen:

  • De DateTime-structuur kan door tijdzone-aanpassingen verschuiven naar de vorige of volgende dag. DateOnly kan niet worden verschoven door een tijdzone en vertegenwoordigt altijd de datum die is ingesteld.
  • Het serialiseren van een DateOnly bestand bevat minder gegevens dan DateTime.
  • Wanneer code communiceert met een database, zoals SQL Server, worden hele datums meestal opgeslagen als het date gegevenstype, dat geen tijd bevat. DateOnly komt beter overeen met het databasetype.

DateOnly.Parse

Met de DateOnly.Parse methode worden algemene datumtekenreeksweergaven geconverteerd naar een DateOnly object. De methode accepteert verschillende indelingen en gebruikt de huidige cultuur of een opgegeven cultuur voor parseren.

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

De DateOnly.ParseExact methode biedt nauwkeurige controle over de verwachte indeling van de invoertekenreeks. Gebruik deze methode wanneer u de exacte notatie van de datumtekenreeks kent en strikte parsering wilt garanderen.

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

De ParseExact methode accepteert een enkele opmaaktreek of een array van opmaaktrekken, zodat u datums kunt parseren die in meerdere acceptabele opmaakvormen kunnen worden weergegeven.

TimeOnly-analyse

De TimeOnly structuur vertegenwoordigt een tijd-van-dag-waarde, zoals een dagelijkse wekker of hoe laat u elke dag luncht. TimeOnly is beperkt tot het bereik van 00:00:00.0000000 - 23:59:59.999999999, een specifiek tijdstip van de dag.

TimeOnly Lost verschillende problemen op die bestonden bij het gebruik van andere typen voor alleen-tijdscenario's:

  • TimeSpan vertegenwoordigt verstreken tijd en kan negatief of langer zijn dan 24 uur, waardoor deze niet geschikt is voor een bepaald tijdstip van de dag.
  • Voor het gebruik DateTime van een tijd van de dag is een willekeurige datum vereist, wat kan leiden tot onverwacht gedrag bij het uitvoeren van berekeningen.
  • TimeOnly de rollover van 24 uur wordt natuurlijk verwerkt bij het toevoegen of aftrekken van tijdwaarden.

TimeOnly.Parse

De TimeOnly.Parse methode converteert algemene tijdreeksweergaven naar een TimeOnly object. De methode accepteert verschillende indelingen, waaronder 12-uurs- en 24-uursnotatie.

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

De TimeOnly.ParseExact methode biedt nauwkeurige controle over de verwachte indeling van de invoertijdtekenreeks. Gebruik deze methode wanneer u de exacte indeling kent en strikte parsering wilt garanderen.

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

Zie ook

  • Last updated on