DateTimeOffset.TryParseExact Metoda

Reference

Definice

Obor názvů:: System

Sestavení:: System.Runtime.dll

Sestavení:: mscorlib.dll

Sestavení:: netstandard.dll

Důležité

Některé informace platí pro předběžně vydaný produkt, který se může zásadně změnit, než ho výrobce nebo autor vydá. Microsoft neposkytuje žádné záruky, výslovné ani předpokládané, týkající se zde uváděných informací.

Převede zadanou řetězcovou reprezentaci data a času na jeho DateTimeOffset ekvivalent. Formát řetězcového vyjádření musí přesně odpovídat určenému formátu.

Přetížení

TryParseExact(String, String[], IFormatProvider, DateTimeStyles, DateTimeOffset)	Převede zadanou řetězcovou reprezentaci data a času na jeho DateTimeOffset ekvivalent pomocí zadaného pole formátů, informací o formátu specifickém pro jazykovou verzi a stylu. Formát řetězcového vyjádření musí přesně odpovídat jednomu z určených formátů.
TryParseExact(ReadOnlySpan<Char>, ReadOnlySpan<Char>, IFormatProvider, DateTimeStyles, DateTimeOffset)	Převede reprezentaci data a času v rozsahu znaků na jeho DateTimeOffset ekvivalent pomocí zadaného formátu, informací o formátu specifickém pro jazykovou verzi a stylu. Formát reprezentace data a času musí přesně odpovídat zadanému formátu.
TryParseExact(ReadOnlySpan<Char>, String[], IFormatProvider, DateTimeStyles, DateTimeOffset)	Převede reprezentaci data a času ve znakovém rozsahu na jeho DateTimeOffset ekvivalent pomocí zadaných formátů, informací o formátu specifického pro jazykovou verzi a stylu. Formát reprezentace data a času musí přesně odpovídat jednomu ze zadaných formátů.
TryParseExact(String, String, IFormatProvider, DateTimeStyles, DateTimeOffset)	Převede zadanou řetězcovou reprezentaci data a času na jeho DateTimeOffset ekvivalent pomocí zadaného formátu, informací o formátu specifickém pro jazykovou verzi a stylu. Formát řetězcového vyjádření musí přesně odpovídat určenému formátu.

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

Source:: DateTimeOffset.cs

Source:: DateTimeOffset.cs

Source:: DateTimeOffset.cs

Převede zadanou řetězcovou reprezentaci data a času na jeho DateTimeOffset ekvivalent pomocí zadaného pole formátů, informací o formátu specifickém pro jazykovou verzi a stylu. Formát řetězcového vyjádření musí přesně odpovídat jednomu z určených formátů.

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);

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

Parametry

input: String

Řetězec, který obsahuje datum a čas k převedení.

formats: String[]

Pole, které definuje očekávané formáty .input

formatProvider: IFormatProvider

Objekt, který poskytuje informace o formátování specifické pro inputjazykovou verzi.

styles: DateTimeStyles

Bitová kombinace hodnot výčtu, která označuje povolený formát vstupu. Typická hodnota, která se má zadat, je None.

result: DateTimeOffset

Když metoda vrátí, obsahuje DateTimeOffset ekvivalent k datu a času input, pokud byl převod úspěšný, nebo DateTimeOffset.MinValue, pokud převod selhal. Převod se nezdaří, pokud input neobsahuje platné řetězcové vyjádření data a času nebo neobsahuje datum a čas v očekávaném formátu definovaném parametrem formatnebo pokud formats je null. Tento parametr se předává neinicializovaný.

Návraty

Boolean

true pokud se input parametr úspěšně převeďte, jinak hodnota false.

Výjimky

ArgumentException

styles obsahuje nedefinovanou DateTimeStyles hodnotu.

-nebo-

NoCurrentDateDefault se nepodporuje.

-nebo-

styles zahrnuje vzájemně se vylučujíné DateTimeStyles hodnoty.

Příklady

Následující příklad definuje více vstupních formátů pro řetězcovou reprezentaci data a času a hodnoty posunu a pak předá řetězec zadaný uživatelem metodě TryParseExact(String, String[], IFormatProvider, DateTimeStyles, DateTimeOffset) .

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

Poznámky

Metoda TryParseExact(String, String[], IFormatProvider, DateTimeStyles, DateTimeOffset) parsuje řetězcovou reprezentaci data, které odpovídá libovolnému vzoru přiřazeného formats k poli. Pokud řetězec neodpovídá žádnému input z těchto vzorů s variantami definovanými parametrem styles , operace analýzy selže a metoda vrátí false. Kromě porovnání input s více řetězci, které obsahují specifikátory formátu, toto přetížení se chová stejně jako DateTimeOffset.ParseExact(String, String[], IFormatProvider, DateTimeStyles) metoda.

Parametr formats je pole řetězců, jehož prvky obsahují buď jeden specifikátor standardního formátu, nebo jeden nebo více specifikátorů vlastního formátu, které definují možný vzor .input Podrobnosti o platných kódech formátování najdete v tématech Řetězce standardního formátu data a času a Vlastní řetězce formátu data a času. Pokud odpovídající prvek v formats obsahuje zzz, nebo zzz vlastní specifikátory formátu, které označují, že posun musí být přítomen v input, musí tento posun obsahovat buď záporné znaménko, nebo kladné znaménko. Pokud znaménko chybí, operace parsování selže a metoda vrátí false.

Důležité

Použití parametru formats tohoto přetížení k určení více formátů může pomoct snížit frustraci mnoha uživatelů při zadávání dat a časů. Konkrétně schopnost definovat více vzorů vstupu umožňuje aplikaci zpracovávat reprezentace data a času, která mohou zahrnovat nebo chybí úvodní nuly v měsících, dnech, hodinách, minutách a sekundách. Příklad obsahuje ilustraci.

Pokud odpovídající prvek v formats vyžaduje, aby input obsahoval datum, ale ne čas, výsledný DateTimeOffset objekt je přiřazen čas půlnoci (0:00:00). Pokud odpovídající prvek v formats vyžaduje, že vstup obsahuje čas, ale ne datum, bude výslednému DateTimeOffset objektu přiřazeno aktuální datum v místním systému. Pokud odpovídající prvek v formats nevyžaduje, že input obsahuje posun, posun výsledného DateTimeOffset objektu závisí na hodnotě parametru styles . Pokud styles zahrnuje AssumeLocal, je objektu přiřazen posun místního časového pásma DateTimeOffset . Pokud styles obsahuje AssumeUniversal, je k objektu přiřazen posun koordinovaného univerzálního DateTimeOffset času (UTC) nebo +00:00. Pokud není zadána ani jedna hodnota, bude použit posun místního časového pásma.

Konkrétní symboly data a času a řetězce použité v input nástroji jsou definovány parametrem formatProvider . Totéž platí pro přesný vzor input , pokud odpovídající prvek je formats standardní řetězec specifikátoru formátu. Parametr formatProvider může být jeden z následujících:

Objekt CultureInfo , který představuje jazykovou verzi, na jejímž input základě je interpretována. Objekt DateTimeFormatInfo vrácený CultureInfo.DateTimeFormat vlastností definuje symboly a formátování v input.
Objekt DateTimeFormatInfo , který definuje formát dat data a času.

Pokud formatprovider je null, použije se CultureInfo objekt, který odpovídá aktuální jazykové verzi.

Parametr styles definuje, jestli je ve vstupním řetězci povolená mezera, určuje, jak se analyzují řetězce bez komponenty explicitního posunu, a podporuje převod UTC jako součást analýzy. Podporují se všechny členy výčtu DateTimeStyles s výjimkou NoCurrentDateDefault. V následující tabulce jsou uvedeny účinky jednotlivých podporovaných členů.

`DateTimeStyles` Členské	Chování
AdjustToUniversal	`input` Analyzuje ho a v případě potřeby převede na UTC. Je ekvivalentní k analýze řetězce a následnému DateTimeOffset.ToUniversalTime volání metody vráceného DateTimeOffset objektu.
AssumeLocal	Pokud odpovídající prvek v `formats` nevyžaduje, že `input` obsahuje hodnotu posunu, vrácený DateTimeOffset objekt je přidělen posun místního časového pásma. Toto je výchozí hodnota.
AssumeUniversal	Pokud odpovídající prvek v `formats` nástroji nevyžaduje, aby `input` obsahoval hodnotu posunu, vrátí se vrácený DateTimeOffset objekt posun UTC (+00:00).
AllowInnerWhite	Umožňuje `input` zahrnout vnitřní prázdné znaky neurčené prvky v `formats`souboru . Mezi komponentami data a času a v jednotlivých komponentách (s výjimkou posunu) se můžou objevit nadbytečné prázdné znaky a při analýze řetězce se ignorují.
AllowLeadingWhite	Umožňuje `input` zahrnout počáteční mezery, které nejsou neurčené prvky v `formats`souboru . Při analýze řetězce jsou ignorovány.
AllowTrailingWhite	Umožňuje `input` zahrnout koncové mezery, které nejsou neurčené elementy v `formats`souboru . Při analýze řetězce jsou ignorovány.
AllowWhiteSpaces	Umožňuje `input` zahrnout počáteční, koncové a vnitřní mezery, které nejsou neurčené prvky v `formats`souboru . Při analýze řetězce se ignorují všechny nadbytečné prázdné znaky, které nejsou zadány v shodném elementu v `formats` .
None	Označuje, že další prázdné znaky nejsou povoleny v `input`. Aby mohlo dojít k úspěšné shodě, musí se prázdné znaky zobrazovat přesně tak, jak je uvedeno v určitém prvku v `formats` . Toto je výchozí chování.
RoundtripKind	Nemá žádný vliv, DateTimeOffset protože struktura neobsahuje `Kind` vlastnost.

Poznámky pro volající

V rozhraní .NET Framework 4 vrátí hodnotu false , TryParseExact pokud řetězec, který má být analyzován, obsahuje komponentu hodiny a označení do hodiny a odpoledne, které nejsou v dohodě. V rozhraní .NET Framework 3.5 a starších verzích je označení do hodiny a odpoledne ignorováno.

Platí pro

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

Source:: DateTimeOffset.cs

Source:: DateTimeOffset.cs

Source:: DateTimeOffset.cs

Převede reprezentaci data a času v rozsahu znaků na jeho DateTimeOffset ekvivalent pomocí zadaného formátu, informací o formátu specifickém pro jazykovou verzi a stylu. Formát reprezentace data a času musí přesně odpovídat zadanému formátu.

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);

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

Parametry

input: ReadOnlySpan<Char>

Rozsah obsahující znaky, které představují datum a čas, které se mají převést.

format: ReadOnlySpan<Char>

Specifikátor formátu, který definuje požadovaný formát .input

formatProvider: IFormatProvider

Objekt, který poskytuje informace o formátování specifické pro inputjazykovou verzi.

styles: DateTimeStyles

Bitová kombinace hodnot výčtu, která označuje povolený formát .input Typická hodnota, která se má zadat, je None.

result: DateTimeOffset

Když metoda vrátí, obsahuje DateTimeOffset ekvivalent k datu a času input, pokud byl převod úspěšný, nebo DateTimeOffset.MinValue , pokud převod selhal. Převod se nezdaří, pokud

Návraty

Boolean

truepokud se input parametr úspěšně převeďte, v opačném případě . false

Výjimky

ArgumentException

styles obsahuje nedefinovanou DateTimeStyles hodnotu. -nebo- NoCurrentDateDefault není podporováno. -nebo- styles zahrnuje vzájemně se vylučující DateTimeStyles hodnoty.

Poznámky

Toto přetížení se podobá DateTimeOffset.ParseExact(ReadOnlySpan<Char>, ReadOnlySpan<Char>, IFormatProvider, DateTimeStyles) metodě s tím rozdílem, že tato metoda nevyvolá výjimku, pokud převod selže. Analyzuje reprezentaci data a času, které musí přesně odpovídat vzoru určenému parametrem format . Pokud input neodpovídá tomuto vzoru, s některými možnými variacemi prázdných znaků definovaných parametrem styles , operace analýzy selže a metoda vrátí false.

Parametr format je znakové rozpětí, které obsahuje buď jeden standardní specifikátor formátu, nebo jeden nebo více specifikátorů vlastního formátu, které definují požadovaný vzor pro input. Podrobnosti o platných kódech formátování najdete v tématech Řetězce standardního formátu data a času a Vlastní řetězce formátu data a času. Pokud format obsahuje specifikátory vlastního zformátu , zznebo zzz označující, že musí být v inputsouboru k dispozici posun, musí tento posun obsahovat buď záporné znaménko, nebo kladné znaménko. Pokud znaménko chybí, operace analýzy selže a metoda vrátí false.

Pokud format vyžaduje, aby input obsahovalo datum, ale ne čas, je výslednému DateTimeOffset objektu přiřazen čas půlnoci (0:00:00). Pokud format vyžaduje, aby input obsahoval čas, ale ne datum, bude výslednému DateTimeOffset objektu přiřazeno aktuální datum v místním systému. Pokud format nevyžaduje, že input obsahuje posun, odsazení výsledného DateTimeOffset objektu závisí na hodnotě parametru styles . Pokud styles zahrnuje AssumeLocal, je objektu přiřazen posun místního časového pásma DateTimeOffset . Pokud styles obsahuje AssumeUniversal, je objektu přiřazen posun koordinovaného univerzálního DateTimeOffset času (UTC) neboli +00:00. Pokud není zadána ani jedna hodnota, bude použit posun místního časového pásma.

Konkrétní symboly data a času a řetězce použité v input parametru jsou definovány parametrem formatProvider . Totéž platí pro přesný vzor řetězce specifikátoru format standardního input formátu. Parametr formatProvider může být jeden z následujících parametrů:

Objekt CultureInfo , který představuje jazykovou verzi na základě, na které input je interpretována. Objekt DateTimeFormatInfo vrácený CultureInfo.DateTimeFormat vlastností definuje symboly a standardní formáty povolené v input.
Objekt DateTimeFormatInfo , který definuje formát dat data a času.

Pokud formatprovider je null, použije se CultureInfo objekt, který odpovídá aktuální jazykové verzi.

Parametr styles definuje, jestli je ve vstupním řetězci povolená mezera, určuje, jak se analyzují řetězce bez explicitní komponenty posunu, a podporuje převod UTC v rámci operace analýzy. Podporují se všechny členy výčtu DateTimeStyles s výjimkou NoCurrentDateDefault. V následující tabulce jsou uvedeny účinky jednotlivých podporovaných členů.

`DateTimeStyles` Členské	Chování
AdjustToUniversal	Provede analýzu `input` a v případě potřeby převede na UTC. Je to ekvivalent parsování reprezentace data a času a následné volání DateTimeOffset.ToUniversalTime metody vráceného DateTimeOffset objektu.
AssumeLocal	Pokud `format` nevyžaduje, aby `input` obsahoval hodnotu posunu, vrácený DateTimeOffset objekt je přidělen posun místního časového pásma. Toto je výchozí chování.
AssumeUniversal	Pokud `format` nevyžaduje, aby `input` hodnota odsazení obsahovala, vrátí se vrácený DateTimeOffset objekt o posun UTC (+00:00).
AllowInnerWhite	Umožňuje `input` zahrnout vnitřní prázdné znaky, které nejsou určené formátem. Mezi komponentami data a času a v jednotlivých komponentách kromě posunu se může objevit nadbytečná mezera a při analýze řetězce se ignoruje.
AllowLeadingWhite	Umožňuje `input` zahrnout úvodní mezery, které nejsou zadány nástrojem `format`. Při analýze řetězce jsou ignorovány.
AllowTrailingWhite	Umožňuje `input` zahrnout koncové mezery, které nejsou zadány nástrojem `format`. Při analýze řetězce jsou ignorovány.
AllowWhiteSpaces	Umožňuje `input` zahrnout počáteční, koncové a vnitřní mezery, které nejsou zadány nástrojem `format`. Všechny nadbytečné prázdné znaky, které nejsou zadány v `format` , se při analýze řetězce ignorují.
None	Označuje, že další prázdné znaky nejsou povoleny v nástroji `input`. Prázdné znaky se musí zobrazit přesně tak, jak je uvedeno v `format`. Toto je výchozí chování.
RoundtripKind	Nemá žádný vliv, protože DateTimeOffset struktura neobsahuje `Kind` vlastnost.

Platí pro

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

Source:: DateTimeOffset.cs

Source:: DateTimeOffset.cs

Source:: DateTimeOffset.cs

Převede reprezentaci data a času v rozsahu znaků na jeho DateTimeOffset ekvivalent pomocí zadaných formátů, informací o formátu specifické pro jazykovou verzi a stylu. Formát reprezentace data a času musí přesně odpovídat jednomu ze zadaných formátů.

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);

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

Parametry

input: ReadOnlySpan<Char>

Rozsah obsahující znaky, které představují datum a čas, které se mají převést.

formats: String[]

Pole řetězců standardního nebo vlastního formátu, které definují přijatelné formáty nástroje input.

formatProvider: IFormatProvider

Objekt, který poskytuje informace o formátování specifické pro jazykovou verzi .input

styles: DateTimeStyles

Bitové kombinace hodnot výčtu, která označuje povolený formát souboru input. Typická hodnota, která se má zadat, je None.

result: DateTimeOffset

Když metoda vrátí, obsahuje DateTimeOffset ekvivalent k datu a času input, pokud byl převod úspěšný, nebo DateTimeOffset.MinValue , pokud převod selhal. Převod selže, pokud

Návraty

Boolean

truepokud se input parametr úspěšně převeďte, v opačném případě . false

Výjimky

ArgumentException

styles obsahuje nedefinovanou DateTimeStyles hodnotu. -nebo- NoCurrentDateDefault se nepodporuje. -nebo- styles zahrnuje vzájemně se vylučující DateTimeStyles hodnoty.

Poznámky

Tato metoda parsuje řetězcovou reprezentaci data, která odpovídá libovolnému vzoru přiřazeného k formats poli. Pokud input neodpovídá žádnému z těchto vzorů s variantami definovanými parametrem styles , operace parsování selže a metoda vrátí false. Kromě porovnání s input více řetězci, které obsahují specifikátory formátu, se toto přetížení chová stejně jako DateTimeOffset.ParseExact(ReadOnlySpan<Char>, String[], IFormatProvider, DateTimeStyles) metoda.

Parametr formats je pole řetězců, jehož prvky obsahují buď jeden specifikátor standardního formátu, nebo jeden nebo více specifikátorů vlastního formátu, které definují možný vzor .input Podrobnosti o platných kódech formátování najdete v tématech Řetězce standardního formátu data a času a Vlastní řetězce formátu data a času. Pokud odpovídající prvek v formats obsahuje zzz, nebo zzz specifikátory vlastního formátu, které označují, že musí být přítomen posun v input, musí tento posun obsahovat buď záporné znaménko, nebo kladné znaménko. Pokud znaménko chybí, operace parsování selže a metoda vrátí false.

Důležité

Použití parametru formats tohoto přetížení k určení více formátů může pomoci snížit frustraci mnoha uživatelů při zadávání dat a časů. Zejména schopnost definovat více vstupních vzorů umožňuje aplikaci zpracovávat reprezentace data a času, které můžou obsahovat nebo chybí úvodní nuly v měsících, dnech, hodinách, minutách a sekundách. Příklad poskytuje ilustraci tohoto příkladu.

Pokud odpovídající prvek v vyžaduje formats , že input obsahuje datum, ale ne čas, je výslednému DateTimeOffset objektu přiřazen čas půlnoci (0:00:00). Pokud odpovídající prvek v formats vyžaduje, aby vstup obsahoval čas, ale ne datum, bude výslednému DateTimeOffset objektu přiřazeno aktuální datum v místním systému. Pokud odpovídající prvek v formats nevyžaduje, že input obsahuje posun, odsazení výsledného DateTimeOffset objektu závisí na hodnotě parametru styles . Pokud styles zahrnuje DateTimeStyles.AssumeLocal, je objektu přiřazen posun místního časového pásma DateTimeOffset . Pokud styles obsahuje DateTimeStyles.AssumeUniversal, je objektu přiřazen posun koordinovaného univerzálního DateTimeOffset času (UTC) neboli +00:00. Pokud není zadána ani jedna hodnota, bude použit posun místního časového pásma.

Konkrétní symboly data a času použité v input parametru jsou definovány parametrem formatProvider . Totéž platí pro přesný vzor input , pokud je odpovídající prvek řetězce standardního formats formátu specifikátoru. Parametr formatProvider může být jeden z následujících parametrů:

Objekt CultureInfo , který představuje jazykovou verzi na základě, na které input je interpretována. Objekt DateTimeFormatInfo vrácený CultureInfo.DateTimeFormat vlastností definuje symboly a formátování v input.
Objekt DateTimeFormatInfo , který definuje formát dat data a času.

Pokud formatprovider je null, použije se CultureInfo objekt, který odpovídá aktuální jazykové verzi.

`DateTimeStyles` Členské	Chování
AdjustToUniversal	Provede analýzu `input` a v případě potřeby převede na UTC. Je ekvivalentní k analýze řetězce a následnému DateTimeOffset.ToUniversalTime volání metody vráceného DateTimeOffset objektu.
AssumeLocal	Pokud odpovídající prvek v `formats` nevyžaduje, že `input` obsahuje hodnotu posunu, vrácený DateTimeOffset objekt je přidělen posun místního časového pásma. Toto je výchozí hodnota.
AssumeUniversal	Pokud odpovídající prvek v systému `formats` nevyžaduje, aby `input` obsahoval hodnotu posunu, vrátí se vrácený DateTimeOffset objekt o posun UTC (+00:00).
AllowInnerWhite	Umožňuje `input` zahrnout vnitřní prázdné znaky, které nejsou určené elementy v `formats`. Mezi komponentami data a času a v jednotlivých komponentách (s výjimkou posunu) se může objevit nadbytečná mezera a při analýze řetězce se ignoruje.
AllowLeadingWhite	Umožňuje `input` zahrnout úvodní mezery, které nejsou určené elementy v `formats`. Při analýze řetězce jsou ignorovány.
AllowTrailingWhite	Umožňuje `input` zahrnout koncové mezery, které nejsou určené elementy v `formats`. Při analýze řetězce jsou ignorovány.
AllowWhiteSpaces	Umožňuje `input` zahrnout počáteční, koncové a vnitřní mezery, které nejsou určené prvky v `formats`. Při analýze řetězce se ignorují všechny nadbytečné prázdné znaky, které nejsou zadané v odpovídajícím elementu v `formats` souboru.
None	Označuje, že další prázdné znaky nejsou povoleny v nástroji `input`. Prázdné znaky se musí zobrazit přesně tak, jak je uvedeno v určitém prvku v `formats` , aby došlo k úspěšné shodě. Toto je výchozí chování.
RoundtripKind	Nemá žádný účinek, DateTimeOffset protože struktura neobsahuje `Kind` vlastnost.

Platí pro

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

Source:: DateTimeOffset.cs

Source:: DateTimeOffset.cs

Source:: DateTimeOffset.cs

Převede zadanou řetězcovou reprezentaci data a času na jeho DateTimeOffset ekvivalent pomocí zadaného formátu, informací o formátu specifickém pro jazykovou verzi a stylu. Formát řetězcového vyjádření musí přesně odpovídat určenému formátu.

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);

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

Parametry

input: String

Řetězec, který obsahuje datum a čas k převedení.

format: String

Specifikátor formátu, který definuje požadovaný formát .input

formatProvider: IFormatProvider

Objekt, který poskytuje informace o formátování specifické pro inputjazykovou verzi.

styles: DateTimeStyles

Bitová kombinace hodnot výčtu, která označuje povolený formát vstupu. Typická hodnota, která se má zadat, je None.

result: DateTimeOffset

Když metoda vrátí, obsahuje DateTimeOffset ekvivalent k datu a času input, pokud byl převod úspěšný, nebo DateTimeOffset.MinValue, pokud převod selhal. Převod selže, pokud input parametr je nullnebo neobsahuje platné řetězcové vyjádření data a času v očekávaném formátu definovaném pomocí format a provider. Tento parametr se předává neinicializovaný.

Návraty

Boolean

true pokud se input parametr úspěšně převeďte, jinak hodnota false.

Výjimky

ArgumentException

styles obsahuje nedefinovanou DateTimeStyles hodnotu.

-nebo-

NoCurrentDateDefault se nepodporuje.

-nebo-

styles zahrnuje vzájemně se vylučujíné DateTimeStyles hodnoty.

Příklady

Následující příklad používá metodu TryParseExact(String, String, IFormatProvider, DateTimeStyles, DateTimeOffset) se standardními a vlastními specifikátory formátu, neutrální jazykovou verzi a různými DateTimeStyles hodnotami k parsování několika řetězců data a času.

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.

Následující příklad používá různé DateTimeStyles hodnoty k analýze pole řetězců, které by měly být v souladu se standardem ISO 8601. Jak ukazuje výstup z příkladu, řetězce, které jsou ve správném formátu, se nepodaří analyzovat, pokud:

obsahují prázdné znaky a příslušný DateTimeStyles příznak (například DateTimeStyles.AllowWhiteSpaces nebyl zadán ve volání metody.
obsahují prvky data a času, které jsou mimo rozsah.

Řetězce, které neurčují posun UTC, se předpokládají, že mají posun místního časového pásma (v tomto případě -07:00, což odráží posun letního časového pásma Tichomoří), pokud DateTimeStyles.AssumeUniversal není příznak zadán ve volání metody. V takovém případě se předpokládá, že se jedná o univerzální koordinovaný čas.

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

Poznámky

Toto přetížení TryParseExact(String, String, IFormatProvider, DateTimeStyles, DateTimeOffset) metody je stejné jako DateTimeOffset.ParseExact(String, String, IFormatProvider, DateTimeStyles) metoda s tím rozdílem, že tato metoda nevyvolá výjimku, pokud se převod nezdaří. Analyzuje řetězcovou reprezentaci data a času, která musí přesně odpovídat vzoru určenému parametrem format . input Pokud řetězec tomuto vzoru neodpovídá, s některými možnými variacemi prázdných znaků definovaných parametremstyles, operace analýzy selže a metoda vrátí false.

Parametr format je řetězec, který obsahuje buď jeden standardní specifikátor formátu, nebo jeden nebo více specifikátorů vlastního formátu, které definují požadovaný vzor pro input. Podrobnosti o platných kódech formátování najdete v tématech Řetězce standardního formátu data a času a Vlastní řetězce formátu data a času. Pokud format obsahuje specifikátory vlastního zformátu , zznebo zzz , které označují, že v musí být k dispozici inputposun, musí tento posun obsahovat buď záporné znaménko, nebo kladné znaménko. Pokud znaménko chybí, operace analýzy selže a metoda vrátí false.

Pokud format vyžaduje, které input obsahují datum, ale ne čas, výsledný DateTimeOffset objekt je přiřazen čas půlnoci (0:00:00). Pokud format vyžaduje, které input obsahují čas, ale ne datum, výsledný DateTimeOffset objekt je přiřazen aktuální datum v místním systému. Pokud format nevyžaduje, že input obsahuje posun, posun výsledného DateTimeOffset objektu závisí na hodnotě parametru styles . Pokud styles zahrnuje AssumeLocal, je objektu přiřazen posun místního časového pásma DateTimeOffset . Pokud styles obsahuje AssumeUniversal, je k objektu přiřazen posun koordinovaného univerzálního DateTimeOffset času (UTC) nebo +00:00. Pokud není zadána ani jedna hodnota, bude použit posun místního časového pásma.

Konkrétní symboly data a času a řetězce použité v input nástroji jsou definovány parametrem formatProvider . Totéž platí pro přesný vzor input řetězce , pokud format je standardní řetězec specifikátoru formátu. Parametr formatProvider může být jeden z následujících:

Objekt CultureInfo , který představuje jazykovou verzi, na jejímž input základě je interpretována. Objekt DateTimeFormatInfo vrácený CultureInfo.DateTimeFormat vlastností definuje symboly a standardní formáty povolené v input.
Objekt DateTimeFormatInfo , který definuje formát dat data a času.

Pokud formatprovider je null, použije se CultureInfo objekt, který odpovídá aktuální jazykové verzi.

Parametr styles definuje, jestli je ve vstupním řetězci povolená mezera, určuje, jak se analyzují řetězce bez komponenty explicitního posunu, a podporuje převod UTC v rámci operace analýzy. Podporují se všechny členy výčtu DateTimeStyles s výjimkou NoCurrentDateDefault. V následující tabulce jsou uvedeny účinky jednotlivých podporovaných členů.

`DateTimeStyles` Členské	Chování
AdjustToUniversal	`input` Analyzuje ho a v případě potřeby převede na UTC. Je ekvivalentní k analýze řetězce a následnému DateTimeOffset.ToUniversalTime volání metody vráceného DateTimeOffset objektu.
AssumeLocal	Pokud `format` nevyžaduje, že `input` obsahuje hodnotu posunu, vrácený DateTimeOffset objekt je přidělen posun místního časového pásma. Toto je výchozí chování.
AssumeUniversal	Pokud `format` nevyžaduje, že `input` obsahuje hodnotu posunu, vrátí se vrácený DateTimeOffset objekt posun UTC (+00:00).
AllowInnerWhite	Umožňuje `input` zahrnout vnitřní prázdné znaky, které nejsou určené formátem. Mezi komponentami data a času a v jednotlivých komponentách kromě posunu se můžou objevit nadbytečné prázdné znaky a při analýze řetězce se ignorují.
AllowLeadingWhite	Umožňuje `input` zahrnout počáteční mezery, které nejsou zadané v `format`. Při analýze řetězce jsou ignorovány.
AllowTrailingWhite	Umožňuje `input` zahrnout koncové mezery, které nejsou zadané parametrem `format`. Při analýze řetězce jsou ignorovány.
AllowWhiteSpaces	Umožňuje `input` zahrnout počáteční, koncové a vnitřní mezery, které nejsou specifikovány parametrem `format`. Při analýze řetězce se ignorují všechny nadbytečné prázdné znaky, které nejsou zadány v `format` souboru .
None	Označuje, že další prázdné znaky nejsou povoleny v `input`. Prázdné znaky se musí zobrazovat přesně tak, jak je uvedeno v `format`souboru . Toto je výchozí chování.
RoundtripKind	Nemá žádný vliv, protože DateTimeOffset struktura neobsahuje `Kind` vlastnost.

Poznámky pro volající

Viz také

ParseExact

Platí pro

DateTimeOffset.TryParseExact Metoda

Definice

Přetížení

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

Parametry

Návraty

Výjimky

Příklady

Poznámky

Poznámky pro volající

Platí pro

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

Parametry

Návraty

Výjimky

Poznámky

Platí pro

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

Parametry

Návraty

Výjimky

Poznámky

Platí pro

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

Parametry

Návraty

Výjimky

Příklady

Poznámky

Poznámky pro volající

Viz také

Platí pro

Váš názor

Další materiály