DateTimeOffset.TryParseExact Methode

Definitie

Naamruimte:
System
Assembly's:
mscorlib.dll, System.Runtime.dll
Assembly:
mscorlib.dll
Assembly:
System.Runtime.dll
Assembly:
netstandard.dll

Converteert de opgegeven tekenreeksweergave van een datum en tijd naar het DateTimeOffset equivalent ervan. De indeling van de tekenreeksweergave moet exact overeenkomen met een opgegeven indeling.

Overloads

Name Description
TryParseExact(String, String[], IFormatProvider, DateTimeStyles, DateTimeOffset)

Converteert de opgegeven tekenreeksweergave van een datum en tijd naar DateTimeOffset het equivalent ervan met behulp van de opgegeven matrix met notaties, cultuurspecifieke notatiegegevens en stijl. De indeling van de tekenreeksweergave moet exact overeenkomen met een van de opgegeven notaties.
TryParseExact(ReadOnlySpan<Char>, ReadOnlySpan<Char>, IFormatProvider, DateTimeStyles, DateTimeOffset)

Converteert de weergave van een datum en tijd in een tekenbereik naar het DateTimeOffset equivalent ervan met behulp van de opgegeven notatie, cultuurspecifieke notatie-informatie en -stijl. De notatie van de datum- en tijdweergave moet exact overeenkomen met de opgegeven notatie.
TryParseExact(ReadOnlySpan<Char>, String[], IFormatProvider, DateTimeStyles, DateTimeOffset)

Converteert de weergave van een datum en tijd in een tekenbereik naar het DateTimeOffset equivalent ervan met behulp van de opgegeven notaties, cultuurspecifieke notatiegegevens en stijl. De notatie van de datum- en tijdweergave moet exact overeenkomen met een van de opgegeven notaties.
TryParseExact(String, String, IFormatProvider, DateTimeStyles, DateTimeOffset)

Converteert de opgegeven tekenreeksweergave van een datum en tijd naar DateTimeOffset het equivalent ervan met behulp van de opgegeven notatie, cultuurspecifieke notatiegegevens en stijl. De indeling van de tekenreeksweergave moet exact overeenkomen met de opgegeven indeling.

TryParseExact(String, String[], IFormatProvider, DateTimeStyles, DateTimeOffset)

Converteert de opgegeven tekenreeksweergave van een datum en tijd naar DateTimeOffset het equivalent ervan met behulp van de opgegeven matrix met notaties, cultuurspecifieke notatiegegevens en stijl. De indeling van de tekenreeksweergave moet exact overeenkomen met een van de opgegeven notaties.

public:
 static bool TryParseExact(System::String ^ input, cli::array <System::String ^> ^ formats, IFormatProvider ^ formatProvider, System::Globalization::DateTimeStyles styles, [Runtime::InteropServices::Out] DateTimeOffset % result);
public static bool TryParseExact(string input, string[] formats, IFormatProvider formatProvider, System.Globalization.DateTimeStyles styles, out DateTimeOffset result);
static member TryParseExact : string * string[] * IFormatProvider * System.Globalization.DateTimeStyles * DateTimeOffset -> bool
Public Shared Function TryParseExact (input As String, formats As String(), formatProvider As IFormatProvider, styles As DateTimeStyles, ByRef result As DateTimeOffset) As Boolean

Parameters

input
String

Een tekenreeks die een datum en tijd bevat die moet worden geconverteerd.

formats
String[]

Een matrix die de verwachte notaties van input.

formatProvider
IFormatProvider

Een object dat cultuurspecifieke opmaakinformatie over inputlevert.

styles
DateTimeStyles

Een bitsgewijze combinatie van opsommingswaarden die de toegestane notatie van invoer aangeeft. Een typische waarde die moet worden opgegeven, is None.

result
DateTimeOffset

Wanneer de methode retourneert, bevat het DateTimeOffset equivalent van de datum en tijd van input, als de conversie is geslaagd, of DateTimeOffset.MinValue, als de conversie is mislukt. De conversie mislukt als de input tekenreeks geen geldige tekenreeksweergave van een datum en tijd bevat, of niet de datum en tijd bevat in de verwachte indeling die is gedefinieerd door formats, of als formats dat is null. Deze parameter wordt niet-geïnitialiseerd doorgegeven.

Retouren

Boolean

trueals de input parameter is geconverteerd; anders. false

Uitzonderingen

ArgumentException

styles bevat een niet-gedefinieerde DateTimeStyles waarde.

– of –

NoCurrentDateDefault wordt niet ondersteund.

– of –

styles omvat wederzijds exclusieve DateTimeStyles waarden.

Voorbeelden

In het volgende voorbeeld worden meerdere invoerindelingen gedefinieerd voor de tekenreeksweergave van een datum- en tijd- en offsetwaarde en wordt de tekenreeks die door de gebruiker is ingevoerd, doorgegeven aan de TryParseExact(String, String[], IFormatProvider, DateTimeStyles, DateTimeOffset) methode.

TextReader conIn = Console.In;
TextWriter conOut = Console.Out;
int tries = 0;
string input = String.Empty;

string[] formats = new string[] {"M/dd/yyyy HH:m zzz", "MM/dd/yyyy HH:m zzz",
                                 "M/d/yyyy HH:m zzz", "MM/d/yyyy HH:m zzz",
                                 "M/dd/yy HH:m zzz", "MM/dd/yy HH:m zzz",
                                 "M/d/yy HH:m zzz", "MM/d/yy HH:m zzz",
                                 "M/dd/yyyy H:m zzz", "MM/dd/yyyy H:m zzz",
                                 "M/d/yyyy H:m zzz", "MM/d/yyyy H:m zzz",
                                 "M/dd/yy H:m zzz", "MM/dd/yy H:m zzz",
                                 "M/d/yy H:m zzz", "MM/d/yy H:m zzz",
                                 "M/dd/yyyy HH:mm zzz", "MM/dd/yyyy HH:mm zzz",
                                 "M/d/yyyy HH:mm zzz", "MM/d/yyyy HH:mm zzz",
                                 "M/dd/yy HH:mm zzz", "MM/dd/yy HH:mm zzz",
                                 "M/d/yy HH:mm zzz", "MM/d/yy HH:mm zzz",
                                 "M/dd/yyyy H:mm zzz", "MM/dd/yyyy H:mm zzz",
                                 "M/d/yyyy H:mm zzz", "MM/d/yyyy H:mm zzz",
                                 "M/dd/yy H:mm zzz", "MM/dd/yy H:mm zzz",
                                 "M/d/yy H:mm zzz", "MM/d/yy H:mm zzz"};
IFormatProvider provider = CultureInfo.InvariantCulture.DateTimeFormat;
DateTimeOffset result;

do {
   conOut.WriteLine("Enter a date, time, and offset (MM/DD/YYYY HH:MM +/-HH:MM),");
   conOut.Write("Then press Enter: ");
   input = conIn.ReadLine();
   conOut.WriteLine();
   if (DateTimeOffset.TryParseExact(input, formats, provider,
                                   DateTimeStyles.AllowWhiteSpaces,
                                   out result))
   {
      break;
   }
   else
   {
      Console.WriteLine("Unable to parse {0}.", input);
      tries++;
   }
} while (tries < 3);
if (tries >= 3)
   Console.WriteLine("Exiting application without parsing {0}", input);
else
   Console.WriteLine("{0} was converted to {1}", input, result.ToString());
// Some successful sample interactions with the user might appear as follows:
//    Enter a date, time, and offset (MM/DD/YYYY HH:MM +/-HH:MM),
//    Then press Enter: 12/08/2007 6:54 -6:00
//
//    12/08/2007 6:54 -6:00 was converted to 12/8/2007 6:54:00 AM -06:00
//
//    Enter a date, time, and offset (MM/DD/YYYY HH:MM +/-HH:MM),
//    Then press Enter: 12/8/2007 06:54 -06:00
//
//    12/8/2007 06:54 -06:00 was converted to 12/8/2007 6:54:00 AM -06:00
//
//    Enter a date, time, and offset (MM/DD/YYYY HH:MM +/-HH:MM),
//    Then press Enter: 12/5/07 6:54 -6:00
//
//    12/5/07 6:54 -6:00 was converted to 12/5/2007 6:54:00 AM -06:00

let mutable result = None    
let mutable tries = 0
let mutable input = ""

let formats = 
    [| "M/dd/yyyy HH:m zzz"; "MM/dd/yyyy HH:m zzz"
       "M/d/yyyy HH:m zzz"; "MM/d/yyyy HH:m zzz"
       "M/dd/yy HH:m zzz"; "MM/dd/yy HH:m zzz"
       "M/d/yy HH:m zzz"; "MM/d/yy HH:m zzz"
       "M/dd/yyyy H:m zzz"; "MM/dd/yyyy H:m zzz"
       "M/d/yyyy H:m zzz"; "MM/d/yyyy H:m zzz"
       "M/dd/yy H:m zzz"; "MM/dd/yy H:m zzz"
       "M/d/yy H:m zzz"; "MM/d/yy H:m zzz"
       "M/dd/yyyy HH:mm zzz"; "MM/dd/yyyy HH:mm zzz"
       "M/d/yyyy HH:mm zzz"; "MM/d/yyyy HH:mm zzz"
       "M/dd/yy HH:mm zzz"; "MM/dd/yy HH:mm zzz"
       "M/d/yy HH:mm zzz"; "MM/d/yy HH:mm zzz"
       "M/dd/yyyy H:mm zzz"; "MM/dd/yyyy H:mm zzz"
       "M/d/yyyy H:mm zzz"; "MM/d/yyyy H:mm zzz"
       "M/dd/yy H:mm zzz"; "MM/dd/yy H:mm zzz"
       "M/d/yy H:mm zzz"; "MM/d/yy H:mm zzz" |]
let provider = CultureInfo.InvariantCulture.DateTimeFormat

while tries < 3 && result.IsNone do
    printfn "Enter a date, time, and offset (MM/DD/YYYY HH:MM +/-HH:MM),"
    printf "Then press Enter: "
    input <- stdin.ReadLine()
    printfn ""
    match DateTimeOffset.TryParseExact(input, formats, provider, DateTimeStyles.AllowWhiteSpaces) with
    | true, dto ->
        result <- Some dto
    | _ ->
        printfn $"Unable to parse {input}."
    tries <- tries + 1

match result with
| Some result ->
    printfn $"{input} was converted to {result}"
| None ->
    printfn $"Exiting application without parsing {input}"

// Some successful sample interactions with the user might appear as follows:
//    Enter a date, time, and offset (MM/DD/YYYY HH:MM +/-HH:MM),
//    Then press Enter: 12/08/2007 6:54 -6:00
//
//    12/08/2007 6:54 -6:00 was converted to 12/8/2007 6:54:00 AM -06:00
//
//    Enter a date, time, and offset (MM/DD/YYYY HH:MM +/-HH:MM),
//    Then press Enter: 12/8/2007 06:54 -06:00
//
//    12/8/2007 06:54 -06:00 was converted to 12/8/2007 6:54:00 AM -06:00
//
//    Enter a date, time, and offset (MM/DD/YYYY HH:MM +/-HH:MM),
//    Then press Enter: 12/5/07 6:54 -6:00
//
//    12/5/07 6:54 -6:00 was converted to 12/5/2007 6:54:00 AM -06:00

 Dim conIn As TextReader = Console.In
 Dim conOut As TextWriter = Console.Out
 Dim tries As Integer = 0
 Dim input As String = String.Empty
 Dim formats() As String = {"M/dd/yyyy HH:m zzz", "MM/dd/yyyy HH:m zzz", _
                            "M/d/yyyy HH:m zzz", "MM/d/yyyy HH:m zzz", _
                            "M/dd/yy HH:m zzz", "MM/dd/yy HH:m zzz", _
                            "M/d/yy HH:m zzz", "MM/d/yy HH:m zzz", _                                 
                            "M/dd/yyyy H:m zzz", "MM/dd/yyyy H:m zzz", _
                            "M/d/yyyy H:m zzz", "MM/d/yyyy H:m zzz", _
                            "M/dd/yy H:m zzz", "MM/dd/yy H:m zzz", _
                            "M/d/yy H:m zzz", "MM/d/yy H:m zzz", _                               
                            "M/dd/yyyy HH:mm zzz", "MM/dd/yyyy HH:mm zzz", _
                            "M/d/yyyy HH:mm zzz", "MM/d/yyyy HH:mm zzz", _
                            "M/dd/yy HH:mm zzz", "MM/dd/yy HH:mm zzz", _
                            "M/d/yy HH:mm zzz", "MM/d/yy HH:mm zzz", _                                 
                            "M/dd/yyyy H:mm zzz", "MM/dd/yyyy H:mm zzz", _
                            "M/d/yyyy H:mm zzz", "MM/d/yyyy H:mm zzz", _
                            "M/dd/yy H:mm zzz", "MM/dd/yy H:mm zzz", _
                            "M/d/yy H:mm zzz", "MM/d/yy H:mm zzz"}   
 Dim provider As IFormatProvider = CultureInfo.InvariantCulture.DateTimeFormat
 Dim result As DateTimeOffset

 Do 
    conOut.WriteLine("Enter a date, time, and offset (MM/DD/YYYY HH:MM +/-HH:MM),")
    conOut.Write("Then press Enter: ")
    input = conIn.ReadLine()
    conOut.WriteLine() 
    If DateTimeOffset.TryParseExact(input, formats, provider, _
                                    DateTimeStyles.AllowWhiteSpaces, _
                                    result) Then
       Exit Do
    Else
       Console.WriteLine("Unable to parse {0}.", input)      
       tries += 1
    End If
 Loop While tries < 3
 If tries >= 3 Then
    Console.WriteLine("Exiting application without parsing {0}", input)
 Else
    Console.WriteLine("{0} was converted to {1}", input, result.ToString())                                                     
 End If 
 ' Some successful sample interactions with the user might appear as follows:
 '    Enter a date, time, and offset (MM/DD/YYYY HH:MM +/-HH:MM),
 '    Then press Enter: 12/08/2007 6:54 -6:00
 '    
 '    12/08/2007 6:54 -6:00 was converted to 12/8/2007 6:54:00 AM -06:00         
 '    
 '    Enter a date, time, and offset (MM/DD/YYYY HH:MM +/-HH:MM),
 '    Then press Enter: 12/8/2007 06:54 -06:00
 '    
 '    12/8/2007 06:54 -06:00 was converted to 12/8/2007 6:54:00 AM -06:00
 '    
 '    Enter a date, time, and offset (MM/DD/YYYY HH:MM +/-HH:MM),
 '    Then press Enter: 12/5/07 6:54 -6:00
 '    
 '    12/5/07 6:54 -6:00 was converted to 12/5/2007 6:54:00 AM -06:00

Opmerkingen

De TryParseExact(String, String[], IFormatProvider, DateTimeStyles, DateTimeOffset) methode parseert de tekenreeksweergave van een datum die overeenkomt met een van de patronen die aan de formats matrix zijn toegewezen. Als de input tekenreeks niet overeenkomt met een van deze patronen met variaties die zijn gedefinieerd door de styles parameter, mislukt de parseringsbewerking en retourneert falsede methode. Afgezien van het vergelijken met input meerdere tekenreeksen die indelingsaanduidingen bevatten, gedraagt deze overbelasting zich identiek aan de DateTimeOffset.ParseExact(String, String[], IFormatProvider, DateTimeStyles) methode.

De formats parameter is een tekenreeksmatrix waarvan de elementen één standaardnotatieaanduiding of een of meer aangepaste notatieaanduidingen bevatten die het mogelijke patroon definiëren input. Zie Standaardtekenreeksen voor datum- en tijdnotatie en aangepaste datum- en tijdnotatietekenreeksen voor meer informatie over geldige opmaakcodes. Als het overeenkomende element in formats de z, zzof zzz aangepaste notatieaanduidingen bevat om aan te geven dat een offset aanwezig moet zijn input, moet die offset een negatief teken of een positief teken bevatten. Als het teken ontbreekt, mislukt de parseringsbewerking en retourneert falsede methode.

Important

Door de formats parameter van deze overbelasting te gebruiken om meerdere indelingen op te geven, kan de frustratie die veel gebruikers ervaren, verminderen wanneer ze datums en tijden invoeren. Met name de mogelijkheid om meerdere invoerpatronen te definiëren, kan een toepassing datum- en tijdweergaven verwerken die voorloopnullen in maanden, dagen, uren, minuten en seconden kunnen bevatten of ontbreken. In het voorbeeld ziet u hier een afbeelding van.

Als voor het overeenkomende element een formats datum maar geen tijd is vereist input , krijgt het resulterende DateTimeOffset object een tijd van middernacht (0:00:00). Als voor het overeenkomende element is formats vereist dat invoer een tijd bevat maar geen datum, wordt de huidige datum op het lokale systeem toegewezen aan het resulterende DateTimeOffset object. Als het overeenkomende element in formats geen offset vereist input , is de verschuiving van het resulterende DateTimeOffset object afhankelijk van de waarde van de styles parameter. Als styles dit is opgenomen AssumeLocal, wordt de verschuiving van de lokale tijdzone toegewezen aan het DateTimeOffset object. Als styles dit is opgenomen AssumeUniversal, wordt de UTC-offset (Coordinated Universal Time) of +00:00 toegewezen aan het DateTimeOffset object. Als geen van beide waarden is opgegeven, wordt de verschuiving van de lokale tijdzone gebruikt.

De specifieke datum- en tijdsymbolen en tekenreeksen die worden input gebruikt, worden gedefinieerd door de formatProvider parameter. Hetzelfde geldt voor het exacte patroon van input als het overeenkomende element formats een standaardnotatieaanduidingstekenreeks is. De formatProvider parameter kan een van de volgende zijn:

Als formatprovider dat het is null, wordt het CultureInfo object dat overeenkomt met de huidige cultuur gebruikt.

De styles parameter bepaalt of witruimte is toegestaan in de invoertekenreeks, geeft aan hoe tekenreeksen zonder een expliciet offsetonderdeel worden geparseerd en ondersteuning biedt voor UTC-conversie als onderdeel van de parseringsbewerking. Alle leden van de DateTimeStyles opsomming worden ondersteund, behalve NoCurrentDateDefault. De volgende tabel bevat het effect van elk ondersteund lid.

DateTimeStyles lid Behavior
AdjustToUniversal Parseert en converteert input deze indien nodig naar UTC. Het is gelijk aan het parseren van een tekenreeks en het aanroepen van de DateTimeOffset.ToUniversalTime methode van het geretourneerde DateTimeOffset object.
AssumeLocal Als het overeenkomende element niet formats vereist dat een input offsetwaarde bevat, krijgt het geretourneerde DateTimeOffset object de offset van de lokale tijdzone. Dit is de standaardwaarde.
AssumeUniversal Als het overeenkomende element niet formats vereist dat input een offsetwaarde bevat, krijgt het geretourneerde DateTimeOffset object de UTC-offset (+00:00).
AllowInnerWhite Hiermee kunt input u binnenste witruimte opnemen die niet is opgegeven door de elementen in formats. Extra witruimte kan worden weergegeven tussen datum- en tijdonderdelen en binnen afzonderlijke onderdelen (met uitzondering van de offset) en wordt genegeerd bij het parseren van de tekenreeks.
AllowLeadingWhite Staat input toe om voorloopspaties op te nemen die niet zijn opgegeven door de elementen in formats. Deze worden genegeerd bij het parseren van de tekenreeks.
AllowTrailingWhite Hiermee kunt input u volgspaties opnemen die niet zijn opgegeven door de elementen in formats. Deze worden genegeerd bij het parseren van de tekenreeks.
AllowWhiteSpaces Hiermee kunt input u voorloop-, volg- en binnenste spaties opnemen die niet zijn opgegeven door de elementen in formats. Alle extra spatietekens die niet zijn opgegeven in het overeenkomende element, formats worden genegeerd bij het parseren van de tekenreeks.
None Geeft aan dat er geen extra witruimte is toegestaan in input. Witruimte moet exact worden weergegeven zoals is opgegeven in een bepaald element voor formats een geslaagde overeenkomst. Dit is het standaardgedrag.
RoundtripKind Heeft geen effect omdat de DateTimeOffset structuur geen eigenschap bevat Kind .

Notities voor bellers

In het .NET Framework 4 retourneert de TryParseExactfalse als de tekenreeks die moet worden geparseerd een uuronderdeel en een AM/PM-ontwerpfunctie bevat die niet in overeenstemming zijn. In het .NET Framework 3.5 en eerdere versies wordt de AM/PM-ontwerpator genegeerd.

Van toepassing op

TryParseExact(ReadOnlySpan<Char>, ReadOnlySpan<Char>, IFormatProvider, DateTimeStyles, DateTimeOffset)

Converteert de weergave van een datum en tijd in een tekenbereik naar het DateTimeOffset equivalent ervan met behulp van de opgegeven notatie, cultuurspecifieke notatie-informatie en -stijl. De notatie van de datum- en tijdweergave moet exact overeenkomen met de opgegeven notatie.

public:
 static bool TryParseExact(ReadOnlySpan<char> input, ReadOnlySpan<char> format, IFormatProvider ^ formatProvider, System::Globalization::DateTimeStyles styles, [Runtime::InteropServices::Out] DateTimeOffset % result);
public static bool TryParseExact(ReadOnlySpan<char> input, ReadOnlySpan<char> format, IFormatProvider formatProvider, System.Globalization.DateTimeStyles styles, out DateTimeOffset result);
static member TryParseExact : ReadOnlySpan<char> * ReadOnlySpan<char> * IFormatProvider * System.Globalization.DateTimeStyles * DateTimeOffset -> bool
Public Shared Function TryParseExact (input As ReadOnlySpan(Of Char), format As ReadOnlySpan(Of Char), formatProvider As IFormatProvider, styles As DateTimeStyles, ByRef result As DateTimeOffset) As Boolean

Parameters

input
ReadOnlySpan<Char>

Een bereik met de tekens die een datum en tijd vertegenwoordigen die moeten worden geconverteerd.

format
ReadOnlySpan<Char>

Een indelingsaanduiding waarmee de vereiste indeling van input.

formatProvider
IFormatProvider

Een object dat cultuurspecifieke opmaakinformatie over inputlevert.

styles
DateTimeStyles

Een bitsgewijze combinatie van opsommingswaarden die de toegestane notatie van input. Een typische waarde die moet worden opgegeven, is None.

result
DateTimeOffset

Wanneer de methode wordt geretourneerd, bevat het DateTimeOffset equivalent van de datum en tijd van input, als de conversie is geslaagd, of DateTimeOffset.MinValue als de conversie is mislukt. De conversie mislukt als de

Retouren

Boolean

trueals de input parameter is geconverteerd; anders. false

Uitzonderingen

ArgumentException

styles bevat een niet-gedefinieerde DateTimeStyles waarde. -of- NoCurrentDateDefault wordt niet ondersteund. -of- styles omvat wederzijds exclusieve DateTimeStyles waarden.

Opmerkingen

Deze overbelasting lijkt op de DateTimeOffset.ParseExact(ReadOnlySpan<Char>, ReadOnlySpan<Char>, IFormatProvider, DateTimeStyles) methode, behalve dat deze methode geen uitzondering genereert als de conversie mislukt. Hiermee wordt de weergave van een datum en tijd geparseerd die exact moet overeenkomen met het patroon dat is opgegeven door de format parameter. Als input dit patroon niet overeenkomt met een aantal mogelijke variaties in witruimte die door de styles parameter zijn gedefinieerd, mislukt de parseringsbewerking en retourneert falsede methode.

De format parameter is een tekenbereik dat één standaardnotatieaanduiding of een of meer aangepaste notatieaanduidingen bevat die het vereiste patroon definiëren input. Zie Standaardtekenreeksen voor datum- en tijdnotatie en aangepaste datum- en tijdnotatietekenreeksen voor meer informatie over geldige opmaakcodes. Als format de zaanduidingen voor , zzof zzz aangepaste notaties zijn opgenomen om aan te geven dat een offset aanwezig inputmoet zijn, moet die offset een negatief teken of een positief teken bevatten. Als het teken ontbreekt, mislukt de parseringsbewerking en retourneert falsede methode.

Als format dit een datum bevat input , maar geen tijd, krijgt het resulterende DateTimeOffset object een tijd van middernacht (0:00:00). Als format dit een tijd bevat input , maar geen datum, wordt de DateTimeOffset huidige datum toegewezen aan het lokale systeem. Als format er geen offset is vereist input , is de verschuiving van het resulterende DateTimeOffset object afhankelijk van de waarde van de styles parameter. Als styles dit is opgenomen AssumeLocal, wordt de verschuiving van de lokale tijdzone toegewezen aan het DateTimeOffset object. Als styles dit is opgenomen AssumeUniversal, wordt de UTC-offset (Coordinated Universal Time) of +00:00 toegewezen aan het DateTimeOffset object. Als geen van beide waarden is opgegeven, wordt de verschuiving van de lokale tijdzone gebruikt.

De specifieke datum- en tijdsymbolen en tekenreeksen die worden input gebruikt, worden gedefinieerd door de formatProvider parameter. Hetzelfde geldt voor het exacte patroon van input als format dit een standaardnotatieaanduidingstekenreeks is. De formatProvider parameter kan een van de volgende zijn:

  • Een CultureInfo object dat de cultuur vertegenwoordigt op basis waarvan input deze wordt geïnterpreteerd. Het DateTimeFormatInfo object dat door de CultureInfo.DateTimeFormat eigenschap wordt geretourneerd, definieert de symbolen en standaardindelingen die zijn toegestaan in input.

  • Een DateTimeFormatInfo object dat de notatie van datum- en tijdgegevens definieert.

Als formatprovider dat het is null, wordt het CultureInfo object dat overeenkomt met de huidige cultuur gebruikt.

De styles parameter bepaalt of witruimte is toegestaan in de invoertekenreeks, geeft aan hoe tekenreeksen zonder een expliciet offsetonderdeel worden geparseerd en ondersteuning biedt voor UTC-conversie als onderdeel van de parseringsbewerking. Alle leden van de DateTimeStyles opsomming worden ondersteund, behalve NoCurrentDateDefault. De volgende tabel bevat het effect van elk ondersteund lid.

DateTimeStyles lid Behavior
AdjustToUniversal Parseert en converteert input deze indien nodig naar UTC. Het is gelijk aan het parseren van een datum- en tijdweergave en het aanroepen van de DateTimeOffset.ToUniversalTime methode van het geretourneerde DateTimeOffset object.
AssumeLocal Als format er geen offsetwaarde is vereist input , krijgt het geretourneerde DateTimeOffset object de offset van de lokale tijdzone. Dit is het standaardgedrag.
AssumeUniversal Als format er geen offsetwaarde is vereist input , krijgt het geretourneerde DateTimeOffset object de UTC-offset (+00:00).
AllowInnerWhite Hiermee kunt input u binnenste witruimte opnemen die niet is opgegeven met opmaak. Extra witruimte kan worden weergegeven tussen datum- en tijdonderdelen en binnen afzonderlijke onderdelen, behalve de offset, en wordt genegeerd bij het parseren van de tekenreeks.
AllowLeadingWhite Staat input toe om voorloopspaties op te nemen die niet zijn opgegeven door format. Deze worden genegeerd bij het parseren van de tekenreeks.
AllowTrailingWhite Hiermee kunt input u volgspaties opnemen die niet zijn opgegeven door format. Deze worden genegeerd bij het parseren van de tekenreeks.
AllowWhiteSpaces Hiermee kunt input u voorloop-, volg- en binnenste spaties opnemen die niet zijn opgegeven door format. Alle extra spatietekens die niet zijn opgegeven in format , worden genegeerd bij het parseren van de tekenreeks.
None Geeft aan dat er geen extra witruimte is toegestaan in input. Witruimte moet exact worden weergegeven zoals opgegeven in format. Dit is het standaardgedrag.
RoundtripKind Heeft geen effect, omdat de DateTimeOffset structuur geen eigenschap bevat Kind .

Van toepassing op

TryParseExact(ReadOnlySpan<Char>, String[], IFormatProvider, DateTimeStyles, DateTimeOffset)

Converteert de weergave van een datum en tijd in een tekenbereik naar het DateTimeOffset equivalent ervan met behulp van de opgegeven notaties, cultuurspecifieke notatiegegevens en stijl. De notatie van de datum- en tijdweergave moet exact overeenkomen met een van de opgegeven notaties.

public:
 static bool TryParseExact(ReadOnlySpan<char> input, cli::array <System::String ^> ^ formats, IFormatProvider ^ formatProvider, System::Globalization::DateTimeStyles styles, [Runtime::InteropServices::Out] DateTimeOffset % result);
public static bool TryParseExact(ReadOnlySpan<char> input, string[] formats, IFormatProvider formatProvider, System.Globalization.DateTimeStyles styles, out DateTimeOffset result);
static member TryParseExact : ReadOnlySpan<char> * string[] * IFormatProvider * System.Globalization.DateTimeStyles * DateTimeOffset -> bool
Public Shared Function TryParseExact (input As ReadOnlySpan(Of Char), formats As String(), formatProvider As IFormatProvider, styles As DateTimeStyles, ByRef result As DateTimeOffset) As Boolean

Parameters

input
ReadOnlySpan<Char>

Een bereik met de tekens die een datum en tijd vertegenwoordigen die moeten worden geconverteerd.

formats
String[]

Een matrix met standaard- of aangepaste notatietekenreeksen die de acceptabele notaties van input.

formatProvider
IFormatProvider

Een object dat cultuurspecifieke opmaakinformatie over inputlevert.

styles
DateTimeStyles

Een bitsgewijze combinatie van opsommingswaarden die de toegestane notatie van input. Een typische waarde die moet worden opgegeven, is None.

result
DateTimeOffset

Wanneer de methode wordt geretourneerd, bevat het DateTimeOffset equivalent van de datum en tijd van input, als de conversie is geslaagd, of DateTimeOffset.MinValue als de conversie is mislukt. De conversie mislukt als de

Retouren

Boolean

trueals de input parameter is geconverteerd; anders. false

Uitzonderingen

ArgumentException

styles bevat een niet-gedefinieerde DateTimeStyles waarde. -of- NoCurrentDateDefault wordt niet ondersteund. -of- styles omvat wederzijds exclusieve DateTimeStyles waarden.

Opmerkingen

Deze methode parseert de tekenreeksweergave van een datum die overeenkomt met een van de patronen die aan de formats matrix zijn toegewezen. Als input een van deze patronen niet overeenkomt met variaties die zijn gedefinieerd door de styles parameter, mislukt de parseringsbewerking en retourneert falsede methode. Afgezien van het vergelijken met input meerdere tekenreeksen die indelingsaanduidingen bevatten, gedraagt deze overbelasting zich identiek aan de DateTimeOffset.ParseExact(ReadOnlySpan<Char>, String[], IFormatProvider, DateTimeStyles) methode.

De formats parameter is een tekenreeksmatrix waarvan de elementen één standaardnotatieaanduiding of een of meer aangepaste notatieaanduidingen bevatten die het mogelijke patroon definiëren input. Zie Standaardtekenreeksen voor datum- en tijdnotatie en aangepaste datum- en tijdnotatietekenreeksen voor meer informatie over geldige opmaakcodes. Als het overeenkomende element in formats de z, zzof zzz aangepaste notatieaanduidingen bevat om aan te geven dat een offset aanwezig moet zijn input, moet die offset een negatief teken of een positief teken bevatten. Als het teken ontbreekt, mislukt de parseringsbewerking en retourneert falsede methode.

Important

Door de formats parameter van deze overbelasting te gebruiken om meerdere indelingen op te geven, kan de frustratie die veel gebruikers ervaren, verminderen wanneer ze datums en tijden invoeren. Met name de mogelijkheid om meerdere invoerpatronen te definiëren, kan een toepassing datum- en tijdweergaven verwerken die voorloopnullen in maanden, dagen, uren, minuten en seconden kunnen bevatten of ontbreken. In het voorbeeld ziet u hier een afbeelding van.

Als voor het overeenkomende element een formats datum maar geen tijd is vereist input , krijgt het resulterende DateTimeOffset object een tijd van middernacht (0:00:00). Als voor het overeenkomende element is formats vereist dat invoer een tijd bevat maar geen datum, wordt de huidige datum op het lokale systeem toegewezen aan het resulterende DateTimeOffset object. Als het overeenkomende element in formats geen offset vereist input , is de verschuiving van het resulterende DateTimeOffset object afhankelijk van de waarde van de styles parameter. Als styles dit is opgenomen DateTimeStyles.AssumeLocal, wordt de verschuiving van de lokale tijdzone toegewezen aan het DateTimeOffset object. Als styles dit is opgenomen DateTimeStyles.AssumeUniversal, wordt de UTC-offset (Coordinated Universal Time) of +00:00 toegewezen aan het DateTimeOffset object. Als geen van beide waarden is opgegeven, wordt de verschuiving van de lokale tijdzone gebruikt.

De specifieke datum- en tijdsymbolen die in input worden gebruikt, worden gedefinieerd door de formatProvider parameter. Hetzelfde geldt voor het exacte patroon van input als het overeenkomende element formats een standaardnotatieaanduidingstekenreeks is. De formatProvider parameter kan een van de volgende zijn:

Als formatprovider dat het is null, wordt het CultureInfo object dat overeenkomt met de huidige cultuur gebruikt.

De styles parameter bepaalt of witruimte is toegestaan in de invoertekenreeks, geeft aan hoe tekenreeksen zonder een expliciet offsetonderdeel worden geparseerd en ondersteuning biedt voor UTC-conversie als onderdeel van de parseringsbewerking. Alle leden van de DateTimeStyles opsomming worden ondersteund, behalve NoCurrentDateDefault. De volgende tabel bevat het effect van elk ondersteund lid.

DateTimeStyles lid Behavior
AdjustToUniversal Parseert en converteert input deze indien nodig naar UTC. Het is gelijk aan het parseren van een tekenreeks en het aanroepen van de DateTimeOffset.ToUniversalTime methode van het geretourneerde DateTimeOffset object.
AssumeLocal Als het overeenkomende element niet formats vereist dat een input offsetwaarde bevat, krijgt het geretourneerde DateTimeOffset object de offset van de lokale tijdzone. Dit is de standaardwaarde.
AssumeUniversal Als het overeenkomende element niet formats vereist dat input een offsetwaarde bevat, krijgt het geretourneerde DateTimeOffset object de UTC-offset (+00:00).
AllowInnerWhite Hiermee kunt input u binnenste witruimte opnemen die niet is opgegeven door de elementen in formats. Extra witruimte kan worden weergegeven tussen datum- en tijdonderdelen en binnen afzonderlijke onderdelen (met uitzondering van de offset) en wordt genegeerd bij het parseren van de tekenreeks.
AllowLeadingWhite Staat input toe om voorloopspaties op te nemen die niet zijn opgegeven door de elementen in formats. Deze worden genegeerd bij het parseren van de tekenreeks.
AllowTrailingWhite Hiermee kunt input u volgspaties opnemen die niet zijn opgegeven door de elementen in formats. Deze worden genegeerd bij het parseren van de tekenreeks.
AllowWhiteSpaces Hiermee kunt input u voorloop-, volg- en binnenste spaties opnemen die niet zijn opgegeven door de elementen in formats. Alle extra spatietekens die niet zijn opgegeven in het overeenkomende element, formats worden genegeerd bij het parseren van de tekenreeks.
None Geeft aan dat er geen extra witruimte is toegestaan in input. Witruimte moet exact worden weergegeven zoals is opgegeven in een bepaald element voor formats een geslaagde overeenkomst. Dit is het standaardgedrag.
RoundtripKind Heeft geen effect omdat de DateTimeOffset structuur geen eigenschap bevat Kind .

Van toepassing op

TryParseExact(String, String, IFormatProvider, DateTimeStyles, DateTimeOffset)

Converteert de opgegeven tekenreeksweergave van een datum en tijd naar DateTimeOffset het equivalent ervan met behulp van de opgegeven notatie, cultuurspecifieke notatiegegevens en stijl. De indeling van de tekenreeksweergave moet exact overeenkomen met de opgegeven indeling.

public:
 static bool TryParseExact(System::String ^ input, System::String ^ format, IFormatProvider ^ formatProvider, System::Globalization::DateTimeStyles styles, [Runtime::InteropServices::Out] DateTimeOffset % result);
public static bool TryParseExact(string input, string format, IFormatProvider formatProvider, System.Globalization.DateTimeStyles styles, out DateTimeOffset result);
static member TryParseExact : string * string * IFormatProvider * System.Globalization.DateTimeStyles * DateTimeOffset -> bool
Public Shared Function TryParseExact (input As String, format As String, formatProvider As IFormatProvider, styles As DateTimeStyles, ByRef result As DateTimeOffset) As Boolean

Parameters

input
String

Een tekenreeks die een datum en tijd bevat die moet worden geconverteerd.

format
String

Een indelingsaanduiding waarmee de vereiste indeling van input.

formatProvider
IFormatProvider

Een object dat cultuurspecifieke opmaakinformatie over inputlevert.

styles
DateTimeStyles

Een bitsgewijze combinatie van opsommingswaarden die de toegestane notatie van invoer aangeeft. Een typische waarde die moet worden opgegeven, is None.

result
DateTimeOffset

Wanneer de methode retourneert, bevat het DateTimeOffset equivalent van de datum en tijd van input, als de conversie is geslaagd, of DateTimeOffset.MinValue, als de conversie is mislukt. De conversie mislukt als de input parameter een nullgeldige tekenreeksweergave van een datum en tijd bevat in de verwachte indeling die is gedefinieerd door format en provider. Deze parameter wordt niet-geïnitialiseerd doorgegeven.

Retouren

Boolean

trueals de input parameter is geconverteerd; anders. false

Uitzonderingen

ArgumentException

styles bevat een niet-gedefinieerde DateTimeStyles waarde.

– of –

NoCurrentDateDefault wordt niet ondersteund.

– of –

styles omvat wederzijds exclusieve DateTimeStyles waarden.

Voorbeelden

In het volgende voorbeeld wordt de TryParseExact(String, String, IFormatProvider, DateTimeStyles, DateTimeOffset) methode gebruikt met standaard- en aangepaste notatieaanduidingen, de invariante cultuur en verschillende DateTimeStyles waarden om verschillende datum- en tijdtekenreeksen te parseren.

string dateString, format;
DateTimeOffset result;
IFormatProvider provider = CultureInfo.InvariantCulture;

// Parse date-only value with invariant culture and assume time is UTC.
dateString = "06/15/2008";
format = "d";
if (DateTimeOffset.TryParseExact(dateString, format, provider,
                                 DateTimeStyles.AssumeUniversal,
                                 out result))
   Console.WriteLine("'{0}' converts to {1}.", dateString, result.ToString());
else
   Console.WriteLine("'{0}' is not in the correct format.", dateString);

// Parse date-only value with leading white space.
// Should return False because only trailing white space is
// specified in method call.
dateString = " 06/15/2008";
if (DateTimeOffset.TryParseExact(dateString, format, provider,
                                 DateTimeStyles.AllowTrailingWhite,
                                 out result))
   Console.WriteLine("'{0}' converts to {1}.", dateString, result.ToString());
else
   Console.WriteLine("'{0}' is not in the correct format.", dateString);

// Parse date and time value, and allow all white space.
dateString = " 06/15/   2008  15:15    -05:00";
format = "MM/dd/yyyy H:mm zzz";
if (DateTimeOffset.TryParseExact(dateString, format, provider,
                                 DateTimeStyles.AllowWhiteSpaces,
                                 out result))
   Console.WriteLine("'{0}' converts to {1}.", dateString, result.ToString());
else
   Console.WriteLine("'{0}' is not in the correct format.", dateString);

// Parse date and time and convert to UTC.
dateString = "  06/15/2008 15:15:30 -05:00";
format = "MM/dd/yyyy H:mm:ss zzz";
if (DateTimeOffset.TryParseExact(dateString, format, provider,
                                DateTimeStyles.AllowWhiteSpaces |
                                DateTimeStyles.AdjustToUniversal,
                                out result))
   Console.WriteLine("'{0}' converts to {1}.", dateString, result.ToString());
else
   Console.WriteLine("'{0}' is not in the correct format.", dateString);
// The example displays the following output:
//    '06/15/2008' converts to 6/15/2008 12:00:00 AM +00:00.
//    ' 06/15/2008' is not in the correct format.
//    ' 06/15/   2008  15:15    -05:00' converts to 6/15/2008 3:15:00 PM -05:00.
//    '  06/15/2008 15:15:30 -05:00' converts to 6/15/2008 8:15:30 PM +00:00.

let provider = CultureInfo.InvariantCulture

// Parse date-only value with invariant culture and assume time is UTC.
let dateString = "06/15/2008"
let format = "d"
match DateTimeOffset.TryParseExact(dateString, format, provider, DateTimeStyles.AssumeUniversal) with
| true, result ->
    printfn $"'{dateString}' converts to {result}."
| _ ->
    printfn $"'{dateString}' is not in the correct format."

// Parse date-only value with leading white space.
// Should return False because only trailing white space is
// specified in method call.
let dateString = " 06/15/2008"
match DateTimeOffset.TryParseExact(dateString, format, provider, DateTimeStyles.AllowTrailingWhite) with
| true, result ->
    printfn $"'{dateString}' converts to {result}."
| _ ->
    printfn $"'{dateString}' is not in the correct format."

// Parse date and time value, and allow all white space.
let dateString = " 06/15/   2008  15:15    -05:00"
let format = "MM/dd/yyyy H:mm zzz"
match DateTimeOffset.TryParseExact(dateString, format, provider, DateTimeStyles.AllowWhiteSpaces) with
| true, result ->
    printfn $"'{dateString}' converts to {result}."
| _ ->
    printfn $"'{dateString}' is not in the correct format."

// Parse date and time and convert to UTC.
let dateString = "  06/15/2008 15:15:30 -05:00"
let format = "MM/dd/yyyy H:mm:ss zzz"
match DateTimeOffset.TryParseExact(dateString, format, provider, DateTimeStyles.AllowWhiteSpaces ||| DateTimeStyles.AdjustToUniversal) with
| true, result ->
    printfn $"'{dateString}' converts to {result}."
| _ ->
    printfn $"'{dateString}' is not in the correct format."

// The example displays the following output:
//    '06/15/2008' converts to 6/15/2008 12:00:00 AM +00:00.
//    ' 06/15/2008' is not in the correct format.
//    ' 06/15/   2008  15:15    -05:00' converts to 6/15/2008 3:15:00 PM -05:00.
//    '  06/15/2008 15:15:30 -05:00' converts to 6/15/2008 8:15:30 PM +00:00.

Dim dateString, format As String  
Dim result As DateTimeOffset
Dim provider As CultureInfo = CultureInfo.InvariantCulture

' Parse date-only value with invariant culture and assume time is UTC.
dateString = "06/15/2008"
format = "d"
If DateTimeOffset.TryParseExact(dateString, format, provider, _
                                   DateTimeStyles.AssumeUniversal, _
                                   result) Then
   Console.WriteLine("'{0}' converts to {1}.", dateString, result.ToString())
Else
   Console.WriteLine("'{0}' is not in the correct format.", dateString)
End If 

' Parse date-only value with leading white space.
' Should return False because only trailing white space is  
' specified in method call.
dateString = " 06/15/2008"
If DateTimeOffset.TryParseExact(dateString, format, provider, _
                                DateTimeStyles.AllowTrailingWhite, _
                                result) Then
   Console.WriteLine("'{0}' converts to {1}.", dateString, result.ToString())
Else
   Console.WriteLine("'{0}' is not in the correct format.", dateString)
End If 

' Parse date and time value, and allow all white space.
dateString = " 06/15/   2008  15:15    -05:00"
format = "MM/dd/yyyy H:mm zzz"
If DateTimeOffset.TryParseExact(dateString, format, provider, _
                                DateTimeStyles.AllowWhiteSpaces, _
                                result) Then
   Console.WriteLine("'{0}' converts to {1}.", dateString, result.ToString())
Else
   Console.WriteLine("'{0}' is not in the correct format.", dateString)
End If 

' Parse date and time and convert to UTC.
dateString = "  06/15/2008 15:15:30 -05:00"   
format = "MM/dd/yyyy H:mm:ss zzz"       
If DateTimeOffset.TryParseExact(dateString, format, provider, _
                                DateTimeStyles.AllowWhiteSpaces Or _
                                DateTimeStyles.AdjustToUniversal, _
                                result) Then
   Console.WriteLine("'{0}' converts to {1}.", dateString, result.ToString())
Else
   Console.WriteLine("'{0}' is not in the correct format.", dateString)
End If 
' The example displays the following output:
'    '06/15/2008' converts to 6/15/2008 12:00:00 AM +00:00.
'    ' 06/15/2008' is not in the correct format.
'    ' 06/15/   2008  15:15    -05:00' converts to 6/15/2008 3:15:00 PM -05:00.
'    '  06/15/2008 15:15:30 -05:00' converts to 6/15/2008 8:15:30 PM +00:00.

In het volgende voorbeeld worden verschillende DateTimeStyles waarden gebruikt om een matrix met tekenreeksen te parseren die naar verwachting voldoen aan ISO 8601. Zoals in de uitvoer van het voorbeeld wordt weergegeven, kunnen tekenreeksen die zich in de juiste indeling bevinden, niet parseren als:

Tekenreeksen die geen UTC-offset opgeven, worden verondersteld de offset van de lokale tijdzone te hebben (in dit geval -07:00, die de offset van de Pacific Daylight Time-zone weerspiegelt) tenzij de DateTimeStyles.AssumeUniversal vlag wordt opgegeven in de methode-aanroep. In dat geval wordt ervan uitgegaan dat ze Universal Coordinated Time zijn.

open System
open System.Globalization

let parseWithISO8601 dateStrings styles =
    printfn $"Parsing with {styles}:"
    for dateString in dateStrings do
        match DateTimeOffset.TryParseExact(dateString, "O", null, styles) with
        | true, date ->
            printfn $"""   {dateString,-35} --> {date.ToString "yyyy-MM-dd HH:mm:ss.FF zzz"}"""
        | _ ->
            printfn $"   Unable to convert '{dateString}'"

let dateStrings = 
    [ "2018-08-18T12:45:16.0000000Z"
      "2018/08/18T12:45:16.0000000Z"
      "2018-18-08T12:45:16.0000000Z"
      "2018-08-18T12:45:16.0000000"
      " 2018-08-18T12:45:16.0000000Z "
      "2018-08-18T12:45:16.0000000+02:00"
      "2018-08-18T12:45:16.0000000-07:00" ]

parseWithISO8601 dateStrings DateTimeStyles.None
printfn "\n-----\n"
parseWithISO8601 dateStrings DateTimeStyles.AllowWhiteSpaces
printfn "\n-----\n"
parseWithISO8601 dateStrings DateTimeStyles.AdjustToUniversal
printfn "\n-----\n"
parseWithISO8601 dateStrings DateTimeStyles.AssumeLocal
printfn "\n-----\n"
parseWithISO8601 dateStrings DateTimeStyles.AssumeUniversal

// The example displays the following output:
//      Parsing with None:
//         2018-08-18T12:45:16.0000000Z        --> 2018-08-18 12:45:16 +00:00
//         Unable to convert '2018/08/18T12:45:16.0000000Z'
//         Unable to convert '2018-18-08T12:45:16.0000000Z'
//         2018-08-18T12:45:16.0000000         --> 2018-08-18 12:45:16 -07:00
//         Unable to convert ' 2018-08-18T12:45:16.0000000Z '
//         2018-08-18T12:45:16.0000000+02:00   --> 2018-08-18 12:45:16 +02:00
//         2018-08-18T12:45:16.0000000-07:00   --> 2018-08-18 12:45:16 -07:00
//
//      -----
//
//      Parsing with AllowWhiteSpaces:
//         2018-08-18T12:45:16.0000000Z        --> 2018-08-18 12:45:16 +00:00
//         Unable to convert '2018/08/18T12:45:16.0000000Z'
//         Unable to convert '2018-18-08T12:45:16.0000000Z'
//         2018-08-18T12:45:16.0000000         --> 2018-08-18 12:45:16 -07:00
//          2018-08-18T12:45:16.0000000Z       --> 2018-08-18 12:45:16 +00:00
//         2018-08-18T12:45:16.0000000+02:00   --> 2018-08-18 12:45:16 +02:00
//         2018-08-18T12:45:16.0000000-07:00   --> 2018-08-18 12:45:16 -07:00
//
//      -----
//
//      Parsing with AdjustToUniversal:
//         2018-08-18T12:45:16.0000000Z        --> 2018-08-18 12:45:16 +00:00
//         Unable to convert '2018/08/18T12:45:16.0000000Z'
//         Unable to convert '2018-18-08T12:45:16.0000000Z'
//         2018-08-18T12:45:16.0000000         --> 2018-08-18 19:45:16 +00:00
//         Unable to convert ' 2018-08-18T12:45:16.0000000Z '
//         2018-08-18T12:45:16.0000000+02:00   --> 2018-08-18 10:45:16 +00:00
//         2018-08-18T12:45:16.0000000-07:00   --> 2018-08-18 19:45:16 +00:00
//
//      -----
//
//      Parsing with AssumeLocal:
//         2018-08-18T12:45:16.0000000Z        --> 2018-08-18 12:45:16 +00:00
//         Unable to convert '2018/08/18T12:45:16.0000000Z'
//         Unable to convert '2018-18-08T12:45:16.0000000Z'
//         2018-08-18T12:45:16.0000000         --> 2018-08-18 12:45:16 -07:00
//         Unable to convert ' 2018-08-18T12:45:16.0000000Z '
//         2018-08-18T12:45:16.0000000+02:00   --> 2018-08-18 12:45:16 +02:00
//         2018-08-18T12:45:16.0000000-07:00   --> 2018-08-18 12:45:16 -07:00
//
//      -----
//
//      Parsing with AssumeUniversal:
//         2018-08-18T12:45:16.0000000Z        --> 2018-08-18 12:45:16 +00:00
//         Unable to convert '2018/08/18T12:45:16.0000000Z'
//         Unable to convert '2018-18-08T12:45:16.0000000Z'
//         2018-08-18T12:45:16.0000000         --> 2018-08-18 12:45:16 +00:00
//         Unable to convert ' 2018-08-18T12:45:16.0000000Z '
//         2018-08-18T12:45:16.0000000+02:00   --> 2018-08-18 12:45:16 +02:00
//         2018-08-18T12:45:16.0000000-07:00   --> 2018-08-18 12:45:16 -07:00

using System;
using System.Globalization;

public class Example
{
   public static void Main()
   {
      string[] dateStrings = { "2018-08-18T12:45:16.0000000Z",
                               "2018/08/18T12:45:16.0000000Z",
                               "2018-18-08T12:45:16.0000000Z",
                               "2018-08-18T12:45:16.0000000",                               
                               " 2018-08-18T12:45:16.0000000Z ",
                               "2018-08-18T12:45:16.0000000+02:00",
                               "2018-08-18T12:45:16.0000000-07:00" }; 
      
      ParseWithISO8601(dateStrings, DateTimeStyles.None);
      Console.WriteLine("\n-----\n");
      ParseWithISO8601(dateStrings, DateTimeStyles.AllowWhiteSpaces);
      Console.WriteLine("\n-----\n");
      ParseWithISO8601(dateStrings, DateTimeStyles.AdjustToUniversal);
      Console.WriteLine("\n-----\n");
      ParseWithISO8601(dateStrings, DateTimeStyles.AssumeLocal);
      Console.WriteLine("\n-----\n");
      ParseWithISO8601(dateStrings, DateTimeStyles.AssumeUniversal);   }

   private static void ParseWithISO8601(string[] dateStrings, DateTimeStyles styles)
   {   
      Console.WriteLine($"Parsing with {styles}:");
      DateTimeOffset date;
      foreach (var dateString in dateStrings)
      {
         if (DateTimeOffset.TryParseExact(dateString, "O", null, styles, out date))
         {
            Console.WriteLine($"   {dateString,-35} --> {date:yyyy-MM-dd HH:mm:ss.FF zzz}");
         }
         else
         {
            Console.WriteLine($"   Unable to convert '{dateString}'");
         }   
      } 
   }
}
// The example displays the following output:
//      Parsing with None:
//         2018-08-18T12:45:16.0000000Z        --> 2018-08-18 12:45:16 +00:00
//         Unable to convert '2018/08/18T12:45:16.0000000Z'
//         Unable to convert '2018-18-08T12:45:16.0000000Z'
//         2018-08-18T12:45:16.0000000         --> 2018-08-18 12:45:16 -07:00
//         Unable to convert ' 2018-08-18T12:45:16.0000000Z '
//         2018-08-18T12:45:16.0000000+02:00   --> 2018-08-18 12:45:16 +02:00
//         2018-08-18T12:45:16.0000000-07:00   --> 2018-08-18 12:45:16 -07:00
//
//      -----
//
//      Parsing with AllowWhiteSpaces:
//         2018-08-18T12:45:16.0000000Z        --> 2018-08-18 12:45:16 +00:00
//         Unable to convert '2018/08/18T12:45:16.0000000Z'
//         Unable to convert '2018-18-08T12:45:16.0000000Z'
//         2018-08-18T12:45:16.0000000         --> 2018-08-18 12:45:16 -07:00
//          2018-08-18T12:45:16.0000000Z       --> 2018-08-18 12:45:16 +00:00
//         2018-08-18T12:45:16.0000000+02:00   --> 2018-08-18 12:45:16 +02:00
//         2018-08-18T12:45:16.0000000-07:00   --> 2018-08-18 12:45:16 -07:00
//
//      -----
//
//      Parsing with AdjustToUniversal:
//         2018-08-18T12:45:16.0000000Z        --> 2018-08-18 12:45:16 +00:00
//         Unable to convert '2018/08/18T12:45:16.0000000Z'
//         Unable to convert '2018-18-08T12:45:16.0000000Z'
//         2018-08-18T12:45:16.0000000         --> 2018-08-18 19:45:16 +00:00
//         Unable to convert ' 2018-08-18T12:45:16.0000000Z '
//         2018-08-18T12:45:16.0000000+02:00   --> 2018-08-18 10:45:16 +00:00
//         2018-08-18T12:45:16.0000000-07:00   --> 2018-08-18 19:45:16 +00:00
//
//      -----
//
//      Parsing with AssumeLocal:
//         2018-08-18T12:45:16.0000000Z        --> 2018-08-18 12:45:16 +00:00
//         Unable to convert '2018/08/18T12:45:16.0000000Z'
//         Unable to convert '2018-18-08T12:45:16.0000000Z'
//         2018-08-18T12:45:16.0000000         --> 2018-08-18 12:45:16 -07:00
//         Unable to convert ' 2018-08-18T12:45:16.0000000Z '
//         2018-08-18T12:45:16.0000000+02:00   --> 2018-08-18 12:45:16 +02:00
//         2018-08-18T12:45:16.0000000-07:00   --> 2018-08-18 12:45:16 -07:00
//
//      -----
//
//      Parsing with AssumeUniversal:
//         2018-08-18T12:45:16.0000000Z        --> 2018-08-18 12:45:16 +00:00
//         Unable to convert '2018/08/18T12:45:16.0000000Z'
//         Unable to convert '2018-18-08T12:45:16.0000000Z'
//         2018-08-18T12:45:16.0000000         --> 2018-08-18 12:45:16 +00:00
//         Unable to convert ' 2018-08-18T12:45:16.0000000Z '
//         2018-08-18T12:45:16.0000000+02:00   --> 2018-08-18 12:45:16 +02:00
//         2018-08-18T12:45:16.0000000-07:00   --> 2018-08-18 12:45:16 -07:00

Imports System.Globalization

Public Module Example
   Public Sub Main()
      Dim dateStrings() = { "2018-08-18T12:45:16.0000000Z",
                            "2018/08/18T12:45:16.0000000Z",
                            "2018-18-08T12:45:16.0000000Z",
                            "2018-08-18T12:45:16.0000000",                               
                            " 2018-08-18T12:45:16.0000000Z ",
                            "2018-08-18T12:45:16.0000000+02:00",
                            "2018-08-18T12:45:16.0000000-07:00" } 
      
      ParseWithISO8601(dateStrings, DateTimeStyles.None)
      Console.WriteLine($"{vbCrLf}-----{vbCrLf}")
      ParseWithISO8601(dateStrings, DateTimeStyles.AllowWhiteSpaces)
      Console.WriteLine($"{vbCrLf}-----{vbCrLf}")
      ParseWithISO8601(dateStrings, DateTimeStyles.AdjustToUniversal)
      Console.WriteLine($"{vbCrLf}-----{vbCrLf}")
      ParseWithISO8601(dateStrings, DateTimeStyles.AssumeLocal)
      Console.WriteLine($"{vbCrLf}-----{vbCrLf}")
      ParseWithISO8601(dateStrings, DateTimeStyles.AssumeUniversal)   
   End Sub

   Private Sub ParseWithISO8601(dateStrings() As String, styles As DateTimeStyles)
      Console.WriteLine($"Parsing with {styles}:")
      Dim dat As DateTimeOffset
      For Each dateStr In dateStrings
         If DateTimeOffset.TryParseExact(dateStr, "O", Nothing, styles, dat) Then
            Console.WriteLine($"   {dateStr,-35} --> {dat:yyyy-MM-dd HH:mm:ss.FF zzz}")
         Else
            Console.WriteLine($"   Unable to convert '{dateStr}'")
         End If   
      Next 
   End Sub
End Module
' The example displays the following output:
'      Parsing with None:
'         2018-08-18T12:45:16.0000000Z        --> 2018-08-18 12:45:16 +00:00
'         Unable to convert '2018/08/18T12:45:16.0000000Z'
'         Unable to convert '2018-18-08T12:45:16.0000000Z'
'         2018-08-18T12:45:16.0000000         --> 2018-08-18 12:45:16 -07:00
'         Unable to convert ' 2018-08-18T12:45:16.0000000Z '
'         2018-08-18T12:45:16.0000000+02:00   --> 2018-08-18 12:45:16 +02:00
'         2018-08-18T12:45:16.0000000-07:00   --> 2018-08-18 12:45:16 -07:00
'
'      -----
'
'      Parsing with AllowWhiteSpaces:
'         2018-08-18T12:45:16.0000000Z        --> 2018-08-18 12:45:16 +00:00
'         Unable to convert '2018/08/18T12:45:16.0000000Z'
'         Unable to convert '2018-18-08T12:45:16.0000000Z'
'         2018-08-18T12:45:16.0000000         --> 2018-08-18 12:45:16 -07:00
'          2018-08-18T12:45:16.0000000Z       --> 2018-08-18 12:45:16 +00:00
'         2018-08-18T12:45:16.0000000+02:00   --> 2018-08-18 12:45:16 +02:00
'         2018-08-18T12:45:16.0000000-07:00   --> 2018-08-18 12:45:16 -07:00
'
'      -----
'
'      Parsing with AdjustToUniversal:
'         2018-08-18T12:45:16.0000000Z        --> 2018-08-18 12:45:16 +00:00
'         Unable to convert '2018/08/18T12:45:16.0000000Z'
'         Unable to convert '2018-18-08T12:45:16.0000000Z'
'         2018-08-18T12:45:16.0000000         --> 2018-08-18 19:45:16 +00:00
'         Unable to convert ' 2018-08-18T12:45:16.0000000Z '
'         2018-08-18T12:45:16.0000000+02:00   --> 2018-08-18 10:45:16 +00:00
'         2018-08-18T12:45:16.0000000-07:00   --> 2018-08-18 19:45:16 +00:00
'
'      -----
'
'      Parsing with AssumeLocal:
'         2018-08-18T12:45:16.0000000Z        --> 2018-08-18 12:45:16 +00:00
'         Unable to convert '2018/08/18T12:45:16.0000000Z'
'         Unable to convert '2018-18-08T12:45:16.0000000Z'
'         2018-08-18T12:45:16.0000000         --> 2018-08-18 12:45:16 -07:00
'         Unable to convert ' 2018-08-18T12:45:16.0000000Z '
'         2018-08-18T12:45:16.0000000+02:00   --> 2018-08-18 12:45:16 +02:00
'         2018-08-18T12:45:16.0000000-07:00   --> 2018-08-18 12:45:16 -07:00
'
'      -----
'
'      Parsing with AssumeUniversal:
'         2018-08-18T12:45:16.0000000Z        --> 2018-08-18 12:45:16 +00:00
'         Unable to convert '2018/08/18T12:45:16.0000000Z'
'         Unable to convert '2018-18-08T12:45:16.0000000Z'
'         2018-08-18T12:45:16.0000000         --> 2018-08-18 12:45:16 +00:00
'         Unable to convert ' 2018-08-18T12:45:16.0000000Z '
'         2018-08-18T12:45:16.0000000+02:00   --> 2018-08-18 12:45:16 +02:00
'         2018-08-18T12:45:16.0000000-07:00   --> 2018-08-18 12:45:16 -07:00

Opmerkingen

Deze overbelasting van de TryParseExact(String, String, IFormatProvider, DateTimeStyles, DateTimeOffset) methode lijkt op de DateTimeOffset.ParseExact(String, String, IFormatProvider, DateTimeStyles) methode, behalve dat deze methode geen uitzondering genereert als de conversie mislukt. Hiermee wordt de tekenreeksweergave van een datum en tijd geparseerd die exact overeenkomen met het patroon dat is opgegeven door de format parameter. Als de input tekenreeks niet overeenkomt met dit patroon, met enkele mogelijke variaties in witruimte die door de styles parameter zijn gedefinieerd, mislukt de parseringsbewerking en retourneert falsede methode.

De format parameter is een tekenreeks die één standaardnotatieaanduiding of een of meer aangepaste notatieaanduidingen bevat die het vereiste patroon definiëren input. Zie Standaardtekenreeksen voor datum- en tijdnotatie en aangepaste datum- en tijdnotatietekenreeksen voor meer informatie over geldige opmaakcodes. Als format de zaanduidingen voor , zzof zzz aangepaste notaties zijn opgenomen om aan te geven dat een offset aanwezig inputmoet zijn, moet die offset een negatief teken of een positief teken bevatten. Als het teken ontbreekt, mislukt de parseringsbewerking en retourneert falsede methode.

Als format dit een datum bevat input , maar geen tijd, krijgt het resulterende DateTimeOffset object een tijd van middernacht (0:00:00). Als format dit een tijd bevat input , maar geen datum, wordt de DateTimeOffset huidige datum toegewezen aan het lokale systeem. Als format er geen offset is vereist input , is de verschuiving van het resulterende DateTimeOffset object afhankelijk van de waarde van de styles parameter. Als styles dit is opgenomen AssumeLocal, wordt de verschuiving van de lokale tijdzone toegewezen aan het DateTimeOffset object. Als styles dit is opgenomen AssumeUniversal, wordt de UTC-offset (Coordinated Universal Time) of +00:00 toegewezen aan het DateTimeOffset object. Als geen van beide waarden is opgegeven, wordt de verschuiving van de lokale tijdzone gebruikt.

De specifieke datum- en tijdsymbolen en tekenreeksen die worden input gebruikt, worden gedefinieerd door de formatProvider parameter. Hetzelfde geldt voor het exacte patroon van input als format dit een standaardnotatieaanduidingstekenreeks is. De formatProvider parameter kan een van de volgende zijn:

  • Een CultureInfo object dat de cultuur vertegenwoordigt op basis waarvan input deze wordt geïnterpreteerd. Het DateTimeFormatInfo object dat door de CultureInfo.DateTimeFormat eigenschap wordt geretourneerd, definieert de symbolen en standaardindelingen die zijn toegestaan in input.

  • Een DateTimeFormatInfo object dat de notatie van datum- en tijdgegevens definieert.

Als formatprovider dat het is null, wordt het CultureInfo object dat overeenkomt met de huidige cultuur gebruikt.

De styles parameter bepaalt of witruimte is toegestaan in de invoertekenreeks, geeft aan hoe tekenreeksen zonder een expliciet offsetonderdeel worden geparseerd en ondersteuning biedt voor UTC-conversie als onderdeel van de parseringsbewerking. Alle leden van de DateTimeStyles opsomming worden ondersteund, behalve NoCurrentDateDefault. De volgende tabel bevat het effect van elk ondersteund lid.

DateTimeStyles lid Behavior
AdjustToUniversal Parseert en converteert input deze indien nodig naar UTC. Het is gelijk aan het parseren van een tekenreeks en het aanroepen van de DateTimeOffset.ToUniversalTime methode van het geretourneerde DateTimeOffset object.
AssumeLocal Als format er geen offsetwaarde is vereist input , krijgt het geretourneerde DateTimeOffset object de offset van de lokale tijdzone. Dit is het standaardgedrag.
AssumeUniversal Als format er geen offsetwaarde is vereist input , krijgt het geretourneerde DateTimeOffset object de UTC-offset (+00:00).
AllowInnerWhite Hiermee kunt input u binnenste witruimte opnemen die niet is opgegeven met opmaak. Extra witruimte kan worden weergegeven tussen datum- en tijdonderdelen en binnen afzonderlijke onderdelen, behalve de offset, en wordt genegeerd bij het parseren van de tekenreeks.
AllowLeadingWhite Staat input toe om voorloopspaties op te nemen die niet zijn opgegeven door format. Deze worden genegeerd bij het parseren van de tekenreeks.
AllowTrailingWhite Hiermee kunt input u volgspaties opnemen die niet zijn opgegeven door format. Deze worden genegeerd bij het parseren van de tekenreeks.
AllowWhiteSpaces Hiermee kunt input u voorloop-, volg- en binnenste spaties opnemen die niet zijn opgegeven door format. Alle extra spatietekens die niet zijn opgegeven in format , worden genegeerd bij het parseren van de tekenreeks.
None Geeft aan dat er geen extra witruimte is toegestaan in input. Witruimte moet exact worden weergegeven zoals opgegeven in format. Dit is het standaardgedrag.
RoundtripKind Heeft geen effect, omdat de DateTimeOffset structuur geen eigenschap bevat Kind .

Notities voor bellers

In het .NET Framework 4 retourneert de TryParseExactfalse als de tekenreeks die moet worden geparseerd een uuronderdeel en een AM/PM-ontwerpfunctie bevat die niet in overeenstemming zijn. In het .NET Framework 3.5 en eerdere versies wordt de AM/PM-ontwerpator genegeerd.

Zie ook

Van toepassing op