DateTimeOffset.ParseExact Methode

Definitie

Naamruimte:: System

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

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

Assembly:: System.Runtime.dll

Assembly:: mscorlib.dll

Assembly:: netstandard.dll

Belangrijk

Bepaalde informatie heeft betrekking op een voorlopige productversie die aanzienlijk kan worden gewijzigd voordat deze wordt uitgebracht. Microsoft biedt geen enkele expliciete of impliciete garanties met betrekking tot de informatie die hier wordt verstrekt.

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
ParseExact(String, String[], IFormatProvider, DateTimeStyles)	Converteert de opgegeven tekenreeksweergave van een datum en tijd naar het DateTimeOffset equivalent ervan met behulp van de opgegeven notaties, cultuurspecifieke notatiegegevens en -stijl. De indeling van de tekenreeksweergave moet exact overeenkomen met een van de opgegeven notaties.
ParseExact(String, String, IFormatProvider, DateTimeStyles)	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.
ParseExact(String, String, IFormatProvider)	Converteert de opgegeven tekenreeksweergave van een datum en tijd naar het DateTimeOffset equivalent ervan met behulp van de opgegeven notatie en cultuurspecifieke notatiegegevens. De indeling van de tekenreeksweergave moet exact overeenkomen met de opgegeven indeling.
ParseExact(ReadOnlySpan<Char>, ReadOnlySpan<Char>, IFormatProvider, DateTimeStyles)	Converteert een tekenbereik dat een datum en tijd vertegenwoordigt naar het DateTimeOffset equivalent ervan met behulp van de opgegeven notatie, cultuurspecifieke notatiegegevens en -stijl. De notatie van de datum- en tijdweergave moet exact overeenkomen met de opgegeven notatie.
ParseExact(ReadOnlySpan<Char>, String[], IFormatProvider, DateTimeStyles)	Converteert een tekenbereik dat de tekenreeksweergave van een datum en tijd bevat 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.

ParseExact(String, String[], IFormatProvider, DateTimeStyles)

Bron:: DateTimeOffset.cs

Bron:: DateTimeOffset.cs

Bron:: DateTimeOffset.cs

Bron:: DateTimeOffset.cs

Bron:: DateTimeOffset.cs

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

public:
 static DateTimeOffset ParseExact(System::String ^ input, cli::array <System::String ^> ^ formats, IFormatProvider ^ formatProvider, System::Globalization::DateTimeStyles styles);

public static DateTimeOffset ParseExact(string input, string[] formats, IFormatProvider formatProvider, System.Globalization.DateTimeStyles styles);

public static DateTimeOffset ParseExact(string input, string[] formats, IFormatProvider? formatProvider, System.Globalization.DateTimeStyles styles);

static member ParseExact : string * string[] * IFormatProvider * System.Globalization.DateTimeStyles -> DateTimeOffset

Public Shared Function ParseExact (input As String, formats As String(), formatProvider As IFormatProvider, styles As DateTimeStyles) As DateTimeOffset

Parameters

input: String

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

formats: String[]

Een matrix van notatieaanduidingen die de verwachte notaties definiëren input.

formatProvider: IFormatProvider

Een object dat cultuurspecifieke opmaakinformatie over inputlevert.

styles: DateTimeStyles

Een bitsgewijze combinatie van opsommingswaarden die de toegestane notatie van input.

Retouren

DateTimeOffset

Een object dat gelijk is aan de datum en tijd die is opgenomen in de input parameter, zoals opgegeven door de formats, formatProvideren styles parameters.

Uitzonderingen

ArgumentException

De verschuiving is groter dan 14 uur of minder dan -14 uur.

– of –

styles bevat een niet-ondersteunde waarde.

– of –

De styles parameter bevat DateTimeStyles waarden die niet samen kunnen worden gebruikt.

ArgumentNullException

input is null.

FormatException

input is een lege tekenreeks ("").

– of –

input bevat geen geldige tekenreeksweergave van een datum en tijd.

– of –

Er is geen element van formats een geldige notatieaanduiding.

– of –

Het uuronderdeel en de AM/PM-ontwerpaar in input komen niet overeen.

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 DateTimeOffset.ParseExact(String, String[], IFormatProvider, DateTimeStyles) 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 = new 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();
   try
   {
      result = DateTimeOffset.ParseExact(input, formats, provider,
                                         DateTimeStyles.AllowWhiteSpaces);
      break;
   }
   catch (FormatException)
   {
      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 input = String.Empty
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

let mutable result = None
let mutable tries = 0
while tries < 3 && result.IsNone do
    printfn "Enter a date, time, and offset (MM/DD/YYYY HH:MM +/-HH:MM),"
    printf "Then press Enter: "
    let input = stdin.ReadLine()
    printfn ""
    try
        result <- 
            DateTimeOffset.ParseExact(input, formats, provider, DateTimeStyles.AllowWhiteSpaces) 
            |> Some
    with :? FormatException ->
        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() 
    Try
       result = DateTimeOffset.ParseExact(input, formats, provider, _
                                          DateTimeStyles.AllowWhiteSpaces)
       Exit Do
    Catch e As FormatException
       Console.WriteLine("Unable to parse {0}.", input)      
       tries += 1
    End Try
 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 DateTimeOffset.ParseExact(String, String[], IFormatProvider, DateTimeStyles) methode parseert de tekenreeksweergave van een datum die overeenkomt met een van de patronen die aan de formats parameter zijn toegewezen. Als de input tekenreeks niet overeenkomt met een van deze patronen met een van de variaties die door de styles parameter zijn gedefinieerd, genereert de methode een FormatException. Afgezien van het vergelijken met input meerdere opmaakpatronen, 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 van de input parameter definiëren. Wanneer de methode wordt aangeroepen, input moet deze overeenkomen met een van deze patronen. 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, genereert de methode een FormatException.

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 een formats tijd maar geen datum is vereist input , wordt aan het resulterende DateTimeOffset object de huidige datum op het lokale systeem toegewezen. 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 de exacte notatie van input, als het overeenkomende element formats een standaardnotatietekenreeks 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 opmaak 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	Gedrag
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	Staat `input` toe om binnenste witruimte op te nemen die niet is opgegeven door `format`. 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 `formats`. Deze worden genegeerd bij het parseren van de tekenreeks.
AllowTrailingWhite	Hiermee kunt `input` u volgspaties opnemen die niet zijn opgegeven door `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 `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 van `formats` een 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 genereert de methode ParseExact een FormatException als de tekenreeks die moet worden geparseerd een uuronderdeel en een AM/PM-ontwerpmachine 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

ParseExact(String, String, IFormatProvider, DateTimeStyles)

Bron:: DateTimeOffset.cs

Bron:: DateTimeOffset.cs

Bron:: DateTimeOffset.cs

Bron:: DateTimeOffset.cs

Bron:: DateTimeOffset.cs

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 DateTimeOffset ParseExact(System::String ^ input, System::String ^ format, IFormatProvider ^ formatProvider, System::Globalization::DateTimeStyles styles);

public static DateTimeOffset ParseExact(string input, string format, IFormatProvider formatProvider, System.Globalization.DateTimeStyles styles);

public static DateTimeOffset ParseExact(string input, string format, IFormatProvider? formatProvider, System.Globalization.DateTimeStyles styles);

static member ParseExact : string * string * IFormatProvider * System.Globalization.DateTimeStyles -> DateTimeOffset

Public Shared Function ParseExact (input As String, format As String, formatProvider As IFormatProvider, styles As DateTimeStyles) As DateTimeOffset

Parameters

input: String

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

format: String

Een indelingsaanduiding waarmee de verwachte 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.

Retouren

DateTimeOffset

Een object dat gelijk is aan de datum en tijd die is opgenomen in de input parameter, zoals opgegeven door de format, formatProvideren styles parameters.

Uitzonderingen

ArgumentException

De verschuiving is groter dan 14 uur of minder dan -14 uur.

– of –

De styles parameter bevat een niet-ondersteunde waarde.

– of –

De styles parameter bevat DateTimeStyles waarden die niet samen kunnen worden gebruikt.

ArgumentNullException

input is null.

– of –

format is null.

FormatException

input is een lege tekenreeks ("").

– of –

input bevat geen geldige tekenreeksweergave van een datum en tijd.

– of –

format is een lege tekenreeks.

– of –

Het uuronderdeel en de AM/PM-ontwerpaar in input komen niet overeen.

Voorbeelden

In het volgende voorbeeld wordt de DateTimeOffset.ParseExact(String, String, IFormatProvider, DateTimeStyles) 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;
CultureInfo provider = CultureInfo.InvariantCulture;

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

// Parse date-only value with leading white space.
// Should throw a FormatException because only trailing white space is
// specified in method call.
dateString = " 06/15/2008";
try
{
   result = DateTimeOffset.ParseExact(dateString, format, provider,
                                      DateTimeStyles.AllowTrailingWhite);
   Console.WriteLine("'{0}' converts to {1}.", dateString, result.ToString());
}
catch (FormatException)
{
   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";
try
{
   result = DateTimeOffset.ParseExact(dateString, format, provider,
                                      DateTimeStyles.AllowWhiteSpaces);
   Console.WriteLine("'{0}' converts to {1}.", dateString, result.ToString());
}
catch (FormatException)
{
   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";
try
{
   result = DateTimeOffset.ParseExact(dateString, format, provider,
                                      DateTimeStyles.AllowWhiteSpaces |
                                      DateTimeStyles.AdjustToUniversal);
   Console.WriteLine("'{0}' converts to {1}.", dateString, result.ToString());
}
catch (FormatException)
{
   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"
try
    let result = DateTimeOffset.ParseExact(dateString, format, provider, DateTimeStyles.AssumeUniversal)
    printfn $"'{dateString}' converts to {result}."
with :? FormatException ->
    printfn $"'{dateString}' is not in the correct format."

// Parse date-only value with leading white space.
// Should throw a FormatException because only trailing white space is
// specified in method call.
let dateString = " 06/15/2008"
try
    let result = DateTimeOffset.ParseExact(dateString, format, provider, DateTimeStyles.AllowTrailingWhite)
    printfn $"'{dateString}' converts to {result}."
with :? FormatException ->
    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"
try
    let result = DateTimeOffset.ParseExact(dateString, format, provider, DateTimeStyles.AllowWhiteSpaces)
    printfn $"'{dateString}' converts to {result}."
with :? FormatException ->
    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"
try
    let result = 
        DateTimeOffset.ParseExact(dateString, format, provider,
                                  DateTimeStyles.AllowWhiteSpaces |||
                                  DateTimeStyles.AdjustToUniversal)
    printfn $"'{dateString}' converts to {result}."
with :? FormatException ->
    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"
Try
   result = DateTimeOffset.ParseExact(dateString, format, provider, _
                                      DateTimeStyles.AssumeUniversal)
   Console.WriteLine("'{0}' converts to {1}.", dateString, result.ToString())
Catch e As FormatException
   Console.WriteLine("'{0}' is not in the correct format.", dateString)
End Try 

' Parse date-only value with leading white space.
' Should throw a FormatException because only trailing white space is  
' specified in method call.
dateString = " 06/15/2008"
Try
   result = DateTimeOffset.ParseExact(dateString, format, provider, _
                                      DateTimeStyles.AllowTrailingWhite)
   Console.WriteLine("'{0}' converts to {1}.", dateString, result.ToString())
Catch e As FormatException
   Console.WriteLine("'{0}' is not in the correct format.", dateString)
End Try 

' 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"
Try
   result = DateTimeOffset.ParseExact(dateString, format, provider, _
                                      DateTimeStyles.AllowWhiteSpaces)
   Console.WriteLine("'{0}' converts to {1}.", dateString, result.ToString())
Catch e As FormatException
   Console.WriteLine("'{0}' is not in the correct format.", dateString)
End Try 

' 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"       
Try
   result = DateTimeOffset.ParseExact(dateString, format, provider, _
                                      DateTimeStyles.AllowWhiteSpaces Or _
                                      DateTimeStyles.AdjustToUniversal)
   Console.WriteLine("'{0}' converts to {1}.", dateString, result.ToString())
Catch e As FormatException
   Console.WriteLine("'{0}' is not in the correct format.", dateString)
End Try 
' 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:

ze bevatten witruimte en een geschikte DateTimeStyles vlag (zoals DateTimeStyles.AllowWhiteSpaces niet opgegeven in de methodeaanroep.
ze bevatten datum- en tijdelementen die buiten het bereik vallen.

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

module parseexact_iso8601_2

open System
open System.Globalization

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" |] 

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

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
//         FormatException: Unable to convert '2018/08/18T12:45:16.0000000Z'
//         FormatException: Unable to convert '2018-18-08T12:45:16.0000000Z'
//         2018-08-18T12:45:16.0000000         --> 2018-08-18 12:45:16 -07:00
//         FormatException: 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
//         FormatException: Unable to convert '2018/08/18T12:45:16.0000000Z'
//         FormatException: 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
//         FormatException: Unable to convert '2018/08/18T12:45:16.0000000Z'
//         FormatException: Unable to convert '2018-18-08T12:45:16.0000000Z'
//         2018-08-18T12:45:16.0000000         --> 2018-08-18 19:45:16 +00:00
//         FormatException: 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
//         FormatException: Unable to convert '2018/08/18T12:45:16.0000000Z'
//         FormatException: Unable to convert '2018-18-08T12:45:16.0000000Z'
//         2018-08-18T12:45:16.0000000         --> 2018-08-18 12:45:16 -07:00
//         FormatException: 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
//         FormatException: Unable to convert '2018/08/18T12:45:16.0000000Z'
//         FormatException: Unable to convert '2018-18-08T12:45:16.0000000Z'
//         2018-08-18T12:45:16.0000000         --> 2018-08-18 12:45:16 +00:00
//         FormatException: 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}:");
      foreach (var dateString in dateStrings)
      {
         try {
            var date = DateTimeOffset.ParseExact(dateString, "O", null, styles);
            Console.WriteLine($"   {dateString,-35} --> {date:yyyy-MM-dd HH:mm:ss.FF zzz}");
         }
         catch (FormatException)
         {
            Console.WriteLine($"   FormatException: 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
//         FormatException: Unable to convert '2018/08/18T12:45:16.0000000Z'
//         FormatException: Unable to convert '2018-18-08T12:45:16.0000000Z'
//         2018-08-18T12:45:16.0000000         --> 2018-08-18 12:45:16 -07:00
//         FormatException: 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
//         FormatException: Unable to convert '2018/08/18T12:45:16.0000000Z'
//         FormatException: 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
//         FormatException: Unable to convert '2018/08/18T12:45:16.0000000Z'
//         FormatException: Unable to convert '2018-18-08T12:45:16.0000000Z'
//         2018-08-18T12:45:16.0000000         --> 2018-08-18 19:45:16 +00:00
//         FormatException: 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
//         FormatException: Unable to convert '2018/08/18T12:45:16.0000000Z'
//         FormatException: Unable to convert '2018-18-08T12:45:16.0000000Z'
//         2018-08-18T12:45:16.0000000         --> 2018-08-18 12:45:16 -07:00
//         FormatException: 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
//         FormatException: Unable to convert '2018/08/18T12:45:16.0000000Z'
//         FormatException: Unable to convert '2018-18-08T12:45:16.0000000Z'
//         2018-08-18T12:45:16.0000000         --> 2018-08-18 12:45:16 +00:00
//         FormatException: 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}:")
      For Each dateStr In dateStrings
         Try 
            Dim dat = DateTimeOffset.ParseExact(dateString, "O", Nothing, styles)
            Console.WriteLine($"   {dateString,-35} --> {dat:yyyy-MM-dd HH:mm:ss.FF zzz}")
         catch e As FormatException
            Console.WriteLine($"   FormatException: Unable to convert '{dateString}'")
         End Try   
      Next 
   End Sub
End Module
' The example displays the following output:
'      Parsing with None:
'         FormatException: Unable to convert '07-30-2018'
'         FormatException: Unable to convert '07-30-2018'
'         FormatException: Unable to convert '07-30-2018'
'         FormatException: Unable to convert '07-30-2018'
'         FormatException: Unable to convert '07-30-2018'
'         FormatException: Unable to convert '07-30-2018'
'         FormatException: Unable to convert '07-30-2018'
'
'      -----
'
'      Parsing with AllowWhiteSpaces:
'         FormatException: Unable to convert '07-30-2018'
'         FormatException: Unable to convert '07-30-2018'
'         FormatException: Unable to convert '07-30-2018'
'         FormatException: Unable to convert '07-30-2018'
'         FormatException: Unable to convert '07-30-2018'
'         FormatException: Unable to convert '07-30-2018'
'         FormatException: Unable to convert '07-30-2018'
'
'      -----
'
'      Parsing with AdjustToUniversal:
'         FormatException: Unable to convert '07-30-2018'
'         FormatException: Unable to convert '07-30-2018'
'         FormatException: Unable to convert '07-30-2018'
'         FormatException: Unable to convert '07-30-2018'
'         FormatException: Unable to convert '07-30-2018'
'         FormatException: Unable to convert '07-30-2018'
'         FormatException: Unable to convert '07-30-2018'
'
'      -----
'
'      Parsing with AssumeLocal:
'         FormatException: Unable to convert '07-30-2018'
'         FormatException: Unable to convert '07-30-2018'
'         FormatException: Unable to convert '07-30-2018'
'         FormatException: Unable to convert '07-30-2018'
'         FormatException: Unable to convert '07-30-2018'
'         FormatException: Unable to convert '07-30-2018'
'         FormatException: Unable to convert '07-30-2018'
'
'      -----
'
'      Parsing with AssumeUniversal:
'         FormatException: Unable to convert '07-30-2018'
'         FormatException: Unable to convert '07-30-2018'
'         FormatException: Unable to convert '07-30-2018'
'         FormatException: Unable to convert '07-30-2018'
'         FormatException: Unable to convert '07-30-2018'
'         FormatException: Unable to convert '07-30-2018'
'         FormatException: Unable to convert '07-30-2018'

Opmerkingen

De DateTimeOffset.ParseExact(String, String, IFormatProvider, DateTimeStyles) methode parseert de tekenreeksweergave van een datum, die de indeling moet hebben die is gedefinieerd door de format parameter. Het vereist ook dat de <elementen Datum>, <Tijd> en <Verschuiving> van de tekenreeksweergave van een datum en tijd worden weergegeven in de volgorde die is opgegeven door format. Als de input tekenreeks niet overeenkomt met het patroon van de format parameter, met eventuele variaties die door de styles parameter zijn gedefinieerd, genereert de methode een FormatException. De methode parseert daarentegen DateTimeOffset.Parse(String, IFormatProvider, DateTimeStyles) de tekenreeksweergave van een datum in een van de indelingen die worden herkend door het object van DateTimeFormatInfo de notatieprovider. Parse Hiermee kunnen ook de <elementen Datum>, <Tijd> en <Verschuiving> van de tekenreeksweergave van een datum en tijd in elke volgorde worden weergegeven.

De format parameter is een tekenreeks die één standaardnotatieaanduiding of een of meer aangepaste notatieaanduidingen bevat die het vereiste patroon van de input parameter definiëren. 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, genereert de methode een FormatException.

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 de exacte notatie 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 opmaak 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.

`DateTimeStyles` lid	Gedrag
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 de standaardwaarde.
AssumeUniversal	Als `format` er geen offsetwaarde is vereist `input` , krijgt het geretourneerde DateTimeOffset object de UTC-offset (+00:00).
AllowInnerWhite	Staat `input` toe om binnenste witruimte op te nemen die niet is opgegeven door `format`. Extra witruimte kan worden weergegeven tussen datum- en tijdonderdelen en binnen afzonderlijke onderdelen 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

Zie ook

Van toepassing op

ParseExact(String, String, IFormatProvider)

Bron:: DateTimeOffset.cs

Bron:: DateTimeOffset.cs

Bron:: DateTimeOffset.cs

Bron:: DateTimeOffset.cs

Bron:: DateTimeOffset.cs

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

public:
 static DateTimeOffset ParseExact(System::String ^ input, System::String ^ format, IFormatProvider ^ formatProvider);

public static DateTimeOffset ParseExact(string input, string format, IFormatProvider formatProvider);

public static DateTimeOffset ParseExact(string input, string format, IFormatProvider? formatProvider);

static member ParseExact : string * string * IFormatProvider -> DateTimeOffset

Public Shared Function ParseExact (input As String, format As String, formatProvider As IFormatProvider) As DateTimeOffset

Parameters

input: String

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

format: String

Een indelingsaanduiding waarmee de verwachte indeling van input.

formatProvider: IFormatProvider

Een object dat cultuurspecifieke opmaakinformatie over inputlevert.

Retouren

DateTimeOffset

Een object dat gelijk is aan de datum en tijd die is opgenomen input in zoals opgegeven door format en formatProvider.

Uitzonderingen

ArgumentException

De verschuiving is groter dan 14 uur of minder dan -14 uur.

ArgumentNullException

input is null.

– of –

format is null.

FormatException

input is een lege tekenreeks ("").

– of –

input bevat geen geldige tekenreeksweergave van een datum en tijd.

– of –

format is een lege tekenreeks.

– of –

Het uuronderdeel en de AM/PM-ontwerpaar in input komen niet overeen.

Voorbeelden

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

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

// Parse date-only value with invariant culture.
dateString = "06/15/2008";
format = "d";
try
{
   result = DateTimeOffset.ParseExact(dateString, format, provider);
   Console.WriteLine("{0} converts to {1}.", dateString, result.ToString());
}
catch (FormatException)
{
   Console.WriteLine("{0} is not in the correct format.", dateString);
}

// Parse date-only value without leading zero in month using "d" format.
// Should throw a FormatException because standard short date pattern of
// invariant culture requires two-digit month.
dateString = "6/15/2008";
try
{
   result = DateTimeOffset.ParseExact(dateString, format, provider);
   Console.WriteLine("{0} converts to {1}.", dateString, result.ToString());
}
catch (FormatException)
{
   Console.WriteLine("{0} is not in the correct format.", dateString);
}

// Parse date and time with custom specifier.
dateString = "Sun 15 Jun 2008 8:30 AM -06:00";
format = "ddd dd MMM yyyy h:mm tt zzz";
try
{
   result = DateTimeOffset.ParseExact(dateString, format, provider);
   Console.WriteLine("{0} converts to {1}.", dateString, result.ToString());
}
catch (FormatException)
{
   Console.WriteLine("{0} is not in the correct format.", dateString);
}

// Parse date and time with offset without offset//s minutes.
// Should throw a FormatException because "zzz" specifier requires leading
// zero in hours.
dateString = "Sun 15 Jun 2008 8:30 AM -06";
try
{
   result = DateTimeOffset.ParseExact(dateString, format, provider);
   Console.WriteLine("{0} converts to {1}.", dateString, result.ToString());
}
catch (FormatException)
{
   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 -07:00.
//    6/15/2008 is not in the correct format.
//    Sun 15 Jun 2008 8:30 AM -06:00 converts to 6/15/2008 8:30:00 AM -06:00.
//    Sun 15 Jun 2008 8:30 AM -06 is not in the correct format.

let provider = CultureInfo.InvariantCulture

// Parse date-only value with invariant culture.
let dateString = "06/15/2008"
let format = "d"
try
    let result = DateTimeOffset.ParseExact(dateString, format, provider)
    printfn $"{dateString} converts to {result}."
with :? FormatException ->
    printfn $"{dateString} is not in the correct format."

// Parse date-only value without leading zero in month using "d" format.
// Should throw a FormatException because standard short date pattern of
// invariant culture requires two-digit month.
let dateString = "6/15/2008"
try
    let result = DateTimeOffset.ParseExact(dateString, format, provider)
    printfn $"{dateString} converts to {result}."
with :? FormatException ->
    printfn $"{dateString} is not in the correct format."

// Parse date and time with custom specifier.
let dateString = "Sun 15 Jun 2008 8:30 AM -06:00"
let format = "ddd dd MMM yyyy h:mm tt zzz"
try
    let result = DateTimeOffset.ParseExact(dateString, format, provider)
    printfn $"{dateString} converts to {result}."
with :? FormatException ->
    printfn $"{dateString} is not in the correct format."

// Parse date and time with offset without offset//s minutes.
// Should throw a FormatException because "zzz" specifier requires leading
// zero in hours.
let dateString = "Sun 15 Jun 2008 8:30 AM -06"
try
    let result = DateTimeOffset.ParseExact(dateString, format, provider)
    printfn $"{dateString} converts to {result}."
with :? FormatException ->
    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 -07:00.
//    6/15/2008 is not in the correct format.
//    Sun 15 Jun 2008 8:30 AM -06:00 converts to 6/15/2008 8:30:00 AM -06:00.
//    Sun 15 Jun 2008 8:30 AM -06 is not in the correct format.

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

' Parse date-only value with invariant culture.
dateString = "06/15/2008"
format = "d"
Try
   result = DateTimeOffset.ParseExact(dateString, format, provider)
   Console.WriteLine("{0} converts to {1}.", dateString, result.ToString())
Catch e As FormatException
   Console.WriteLine("{0} is not in the correct format.", dateString)
End Try 

' Parse date-only value without leading zero in month using "d" format.
' Should throw a FormatException because standard short date pattern of 
' invariant culture requires two-digit month.
dateString = "6/15/2008"
Try
   result = DateTimeOffset.ParseExact(dateString, format, provider)
   Console.WriteLine("{0} converts to {1}.", dateString, result.ToString())
Catch e As FormatException
   Console.WriteLine("{0} is not in the correct format.", dateString)
End Try 

' Parse date and time with custom specifier.
dateString = "Sun 15 Jun 2008 8:30 AM -06:00"
format = "ddd dd MMM yyyy h:mm tt zzz"        
Try
   result = DateTimeOffset.ParseExact(dateString, format, provider)
   Console.WriteLine("{0} converts to {1}.", dateString, result.ToString())
Catch e As FormatException
   Console.WriteLine("{0} is not in the correct format.", dateString)
End Try 

' Parse date and time with offset without offset's minutes.
' Should throw a FormatException because "zzz" specifier requires leading  
' zero in hours.
dateString = "Sun 15 Jun 2008 8:30 AM -06"
Try
   result = DateTimeOffset.ParseExact(dateString, format, provider)
   Console.WriteLine("{0} converts to {1}.", dateString, result.ToString())
Catch e As FormatException
   Console.WriteLine("{0} is not in the correct format.", dateString)
End Try 
' The example displays the following output:
'    06/15/2008 converts to 6/15/2008 12:00:00 AM -07:00.
'    6/15/2008 is not in the correct format.
'    Sun 15 Jun 2008 8:30 AM -06:00 converts to 6/15/2008 8:30:00 AM -06:00.
'    Sun 15 Jun 2008 8:30 AM -06 is not in the correct format.

In het volgende voorbeeld wordt een matrix met tekenreeksen geparseerd die naar verwachting voldoen aan ISO 8601. Zoals in de uitvoer van het voorbeeld wordt weergegeven, kunnen tekenreeksen met voorloop- of volgspaties niet worden geparseerd, net zoals tekenreeksen met datum- en tijdelementen die buiten het bereik vallen.

module parseexact_iso8601

open System

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.0000000Z "
      "2018-08-18T12:45:16.0000000+02:00"
      "2018-08-18T12:45:16.0000000-07:00" ]

for dateString in dateStrings do
    try
        let date =
            DateTimeOffset.ParseExact(dateString, "O", null)

        printfn $"""{dateString, -35} --> {date.ToString "yyyy-MM-dd HH:mm:ss.FF zzz"}"""
    with :? FormatException -> printfn $"FormatException: Unable to convert '{dateString}'"


// The example displays the following output:
//      2018-08-18T12:45:16.0000000Z        --> 2018-08-18 12:45:16 +00:00
//      FormatException: Unable to convert '2018/08/18T12:45:16.0000000Z'
//      FormatException: Unable to convert '2018-18-08T12:45:16.0000000Z'
//      FormatException: 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;

public class Example2
{
   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.0000000Z ",
                               "2018-08-18T12:45:16.0000000+02:00",
                               "2018-08-18T12:45:16.0000000-07:00" }; 
      
      foreach (var dateString in dateStrings)
      {
         try {
            var date = DateTimeOffset.ParseExact(dateString, "O", null);
            Console.WriteLine($"{dateString,-35} --> {date:yyyy-MM-dd HH:mm:ss.FF zzz}");
         }
         catch (FormatException)
         {
            Console.WriteLine($"FormatException: Unable to convert '{dateString}'");
         }   
      } 
   }
}
// The example displays the following output:
//      2018-08-18T12:45:16.0000000Z        --> 2018-08-18 12:45:16 +00:00
//      FormatException: Unable to convert '2018/08/18T12:45:16.0000000Z'
//      FormatException: Unable to convert '2018-18-08T12:45:16.0000000Z'
//      FormatException: 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

Public Module Example
   Public Sub Main()
      Dim dateStrings() As String = { "2018-08-18T12:45:16.0000000Z",
                                      "2018/08/18T12:45:16.0000000Z",
                                      "2018-18-08T12:45:16.0000000Z",
                                      " 2018-08-18T12:45:16.0000000Z ",
                                      "2018-08-18T12:45:16.0000000+02:00",
                                      "2018-08-18T12:45:16.0000000-07:00" } 
      
      For Each dateStr In dateStrings
         Try 
            Dim dat = DateTimeOffset.ParseExact(dateStr, "O", Nothing)
            Console.WriteLine($"{dateStr,-35} --> {dat:yyyy-MM-dd HH:mm:ss.FF zzz}")
         Catch  e As FormatException
            Console.WriteLine($"FormatException: Unable to convert '{dateStr}'")
         End Try   
      Next 
   End Sub
End Module
' The example displays the following output:
'      2018-08-18T12:45:16.0000000Z        --> 2018-08-18 12:45:16 +00:00
'      FormatException: Unable to convert '2018/08/18T12:45:16.0000000Z'
'      FormatException: Unable to convert '2018-18-08T12:45:16.0000000Z'
'      FormatException: 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

De ParseExact(String, String, IFormatProvider) methode parseert de tekenreeksweergave van een datum, die de indeling moet hebben die is gedefinieerd door de format parameter. Het vereist ook dat de <elementen Datum>, <Tijd> en <Verschuiving> van de tekenreeksweergave van een datum en tijd worden weergegeven in de volgorde die is opgegeven door format. Als de input tekenreeks niet overeenkomt met deze format parameter, genereert de methode een FormatException. De methode parseert daarentegen DateTimeOffset.Parse(String, IFormatProvider) de tekenreeksweergave van een datum in een van de indelingen die worden herkend door het object van DateTimeFormatInfo de notatieprovider. Parse Hiermee kunnen ook de <elementen Datum>, <Tijd> en <Verschuiving> van de tekenreeksweergave van een datum en tijd in elke volgorde worden weergegeven.

De format parameter is een tekenreeks die één standaardnotatieaanduiding of een of meer aangepaste notatieaanduidingen bevat die de vereiste indeling van de input parameter definiëren. 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, genereert de methode een FormatException.

De specifieke datum- en tijdsymbolen en tekenreeksen die worden input gebruikt, worden gedefinieerd door de formatProvider parameter, net zoals de exacte notatie van input een format standaardnotatieaanduidingstekenreeks. 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 DateTimeFormat de eigenschap wordt geretourneerd, definieert de symbolen en opmaak 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.

Notities voor bellers

Zie ook

Van toepassing op

ParseExact(ReadOnlySpan<Char>, ReadOnlySpan<Char>, IFormatProvider, DateTimeStyles)

Bron:: DateTimeOffset.cs

Bron:: DateTimeOffset.cs

Bron:: DateTimeOffset.cs

Bron:: DateTimeOffset.cs

Bron:: DateTimeOffset.cs

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

public static DateTimeOffset ParseExact(ReadOnlySpan<char> input, ReadOnlySpan<char> format, IFormatProvider? formatProvider, System.Globalization.DateTimeStyles styles = System.Globalization.DateTimeStyles.None);

public static DateTimeOffset ParseExact(ReadOnlySpan<char> input, ReadOnlySpan<char> format, IFormatProvider formatProvider, System.Globalization.DateTimeStyles styles = System.Globalization.DateTimeStyles.None);

static member ParseExact : ReadOnlySpan<char> * ReadOnlySpan<char> * IFormatProvider * System.Globalization.DateTimeStyles -> DateTimeOffset

Public Shared Function ParseExact (input As ReadOnlySpan(Of Char), format As ReadOnlySpan(Of Char), formatProvider As IFormatProvider, Optional styles As DateTimeStyles = System.Globalization.DateTimeStyles.None) As DateTimeOffset

Parameters

input: ReadOnlySpan<Char>

Een tekenbereik dat een datum en tijd vertegenwoordigt.

format: ReadOnlySpan<Char>

Een tekenbereik dat een indelingsaanduiding bevat die de verwachte notatie definieert input.

formatProvider: IFormatProvider

Een object dat cultuurspecifieke opmaakinformatie biedt over input.

styles: DateTimeStyles

Een bitsgewijze combinatie van opsommingswaarden die de toegestane notatie van input.

Retouren

DateTimeOffset

Een object dat gelijk is aan de datum en tijd die is opgenomen in de input parameter, zoals opgegeven door de format, formatProvideren styles parameters.

Uitzonderingen

ArgumentException

De verschuiving is groter dan 14 uur of minder dan -14 uur. -of- De styles parameter bevat een niet-ondersteunde waarde. -of- De styles parameter bevat DateTimeStyles waarden die niet samen kunnen worden gebruikt.

FormatException

input is een leeg tekenbereik. -of- input bevat geen geldige tekenreeksweergave van een datum en tijd. -of- format is een leeg tekenbereik. -of- Het uuronderdeel en de AM/PM-designator zijn input het er niet mee eens.

Opmerkingen

Met deze methode wordt een tekenspanne geparseerd die een datum vertegenwoordigt, die de notatie moet hebben die is gedefinieerd door de format parameter. Het vereist ook dat de <elementen Datum>, <Tijd> en <Verschuiving> van de tekenreeksweergave van een datum en tijd worden weergegeven in de volgorde die is opgegeven door format. Als input dit niet overeenkomt met het format patroon, genereert de methode een FormatException. De methode parseert daarentegen DateTimeOffset.Parse(ReadOnlySpan<Char>, IFormatProvider, DateTimeStyles) de tekenreeksweergave van een datum in een van de indelingen die worden herkend door het object van DateTimeFormatInfo de notatieprovider. Parse Hiermee kunnen ook de <elementen Datum>, <Tijd> en <Verschuiving> van de tekenreeksweergave van een datum en tijd in elke volgorde worden weergegeven.

De format parameter is een tekenbereik dat een standaardnotatieaanduiding met één teken of een of meer aangepaste notatieaanduidingen bevat die de vereiste indeling van de input parameter definiëren. 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, genereert de methode een FormatException.

De specifieke datum- en tijdsymbolen en tekenreeksen die worden input gebruikt, worden gedefinieerd door de formatProvider parameter, net zoals de exacte notatie van input als format het een standaardnotatieaanduiding 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 DateTimeFormat de eigenschap wordt geretourneerd, definieert de symbolen en opmaak 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.

Van toepassing op

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

Bron:: DateTimeOffset.cs

Bron:: DateTimeOffset.cs

Bron:: DateTimeOffset.cs

Bron:: DateTimeOffset.cs

Bron:: DateTimeOffset.cs

Converteert een tekenbereik dat de tekenreeksweergave van een datum en tijd bevat 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 DateTimeOffset ParseExact(ReadOnlySpan<char> input, string[] formats, IFormatProvider? formatProvider, System.Globalization.DateTimeStyles styles = System.Globalization.DateTimeStyles.None);

public static DateTimeOffset ParseExact(ReadOnlySpan<char> input, string[] formats, IFormatProvider formatProvider, System.Globalization.DateTimeStyles styles = System.Globalization.DateTimeStyles.None);

static member ParseExact : ReadOnlySpan<char> * string[] * IFormatProvider * System.Globalization.DateTimeStyles -> DateTimeOffset

Public Shared Function ParseExact (input As ReadOnlySpan(Of Char), formats As String(), formatProvider As IFormatProvider, Optional styles As DateTimeStyles = System.Globalization.DateTimeStyles.None) As DateTimeOffset

Parameters

input: ReadOnlySpan<Char>

Een tekenbereik dat een datum en tijd bevat die moet worden geconverteerd.

formats: String[]

Een matrix van notatieaanduidingen die de verwachte notaties definiëren input.

formatProvider: IFormatProvider

Een object dat cultuurspecifieke opmaakinformatie over inputlevert.

styles: DateTimeStyles

Een bitsgewijze combinatie van opsommingswaarden die de toegestane notatie van input.

Retouren

DateTimeOffset

Een object dat gelijk is aan de datum en tijd die is opgenomen in de input parameter, zoals opgegeven door de formats, formatProvideren styles parameters.

Uitzonderingen

ArgumentException

De verschuiving is groter dan 14 uur of minder dan -14 uur. -of- styles bevat een niet-ondersteunde waarde. -of- De styles parameter bevat DateTimeStyles waarden die niet samen kunnen worden gebruikt.

FormatException

input is een leeg tekenbereik. -of- input bevat geen geldige tekenreeksweergave van een datum en tijd. -of- Geen element bevat formats een geldige notatieaanduiding. -of- Het uuronderdeel en de AM/PM-designator zijn input het er niet mee eens.

Opmerkingen

Met deze methode wordt een tekenspanne geparseerd die een datum vertegenwoordigt die overeenkomt met een van de patronen die aan de formats parameter zijn toegewezen. Als input een van deze patronen niet overeenkomt met een van de variaties die door de styles parameter zijn gedefinieerd, genereert de methode een FormatException. Afgezien van het vergelijken met input meerdere opmaakpatronen, gedraagt deze overbelasting zich identiek aan de DateTimeOffset.ParseExact(ReadOnlySpan<Char>, ReadOnlySpan<Char>, IFormatProvider, DateTimeStyles) methode.

Important

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 opmaak 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.

`DateTimeStyles` lid	Gedrag
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	Staat `input` toe om binnenste witruimte op te nemen die niet is opgegeven door `format`. 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 `formats`. Deze worden genegeerd bij het parseren van de tekenreeks.
AllowTrailingWhite	Hiermee kunt `input` u volgspaties opnemen die niet zijn opgegeven door `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 `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 van `formats` een overeenkomst. Dit is het standaardgedrag.
RoundtripKind	Heeft geen effect omdat de DateTimeOffset structuur geen eigenschap bevat `Kind` .

Van toepassing op

Feedback

Is deze pagina nuttig?