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é reprezentace musí přesně odpovídat zadané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é reprezentace se musí přesně shodovat s jedním ze zadaný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 v rozsahu znaků na jeho DateTimeOffset ekvivalent pomocí zadaných formátů, informací o formátu specifickém pro jazykovou verzi a stylu. Formát reprezentace data a času se musí přesně shodovat s jedním 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 jazyk a styl. Formát řetězcové reprezentace se musí přesně shodovat se zadaným formátem.

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

Zdroj:: DateTimeOffset.cs

Zdroj:: DateTimeOffset.cs

Zdroj:: 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é reprezentace se musí přesně shodovat s jedním ze zadaný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 pro převod.

formats: String[]

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

formatProvider: IFormatProvider

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

styles: DateTimeStyles

Bitová kombinace hodnot výčtu, která označuje povolený formát vstupu. Typická hodnota pro zadání je None.

result: DateTimeOffset

Když metoda vrátí, obsahuje DateTimeOffset ekvivalentní datum a čas input, pokud převod byl úspěšný nebo DateTimeOffset.MinValue, pokud převod selhal. Převod selže, pokud input neobsahuje platnou řetězcovou reprezentaci data a času nebo neobsahuje datum a čas v očekávaném formátu definovaném formatsnebo pokud je formatsnull. Tento parametr se předává neinicializovaný.

Návraty

Boolean

true, pokud je parametr input úspěšně převeden; jinak false.

Výjimky

ArgumentException

styles obsahuje nedefinovanou hodnotu DateTimeStyles.

-nebo-

NoCurrentDateDefault se nepodporuje.

-nebo-

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

Příklady

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

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 k poli formats. Pokud řetězec input neodpovídá žádnému z těchto vzorů s žádnými 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, se toto přetížení chová stejně jako DateTimeOffset.ParseExact(String, String[], IFormatProvider, DateTimeStyles) metoda.

Parametr formats je řetězcové pole, 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 formátovacích kódech najdete v tématu Standardní řetězce formátu data a času a vlastní řetězce formátu data a času. Pokud odpovídající prvek v formats obsahuje z, zznebo zzz specifikátory vlastního formátu, aby bylo možné určit, že posun musí být v input, 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.

Důležitý

Použití formats parametru tohoto přetížení k určení více formátů může pomoci snížit frustraci mnoho uživatelů, kteří zadávají data a časy. Konkrétně možnost definovat více vstupních vzorů umožňuje aplikaci zpracovat reprezentaci data a času, která může obsahovat nebo chybět úvodní nuly v měsících, dnech, hodinách, minutách a sekundách. Příklad obsahuje ilustraci tohoto příkladu.

Pokud odpovídající prvek v formats vyžaduje, aby input obsahoval datum, ale ne čas, je výsledný objekt DateTimeOffset 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, je výsledný objekt DateTimeOffset přiřazen aktuální datum v místním systému. Pokud odpovídající prvek v formats nevyžaduje, aby input obsahoval posun, posun výsledného objektu DateTimeOffset závisí na hodnotě parametru styles. Pokud styles zahrnuje AssumeLocal, je posun místního časového pásma přiřazen k objektu DateTimeOffset. Pokud styles zahrnuje AssumeUniversal, posun koordinovaného univerzálního času (UTC) nebo +00:00, je přiřazen k objektu DateTimeOffset. Pokud není zadána žádná hodnota, použije se posun místního časového pásma.

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

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

Pokud je formatprovidernull, použije se objekt CultureInfo odpovídající aktuální jazykové verzi.

Parametr styles definuje, jestli je ve vstupním řetězci povolené prázdné znaky, určuje, jak se analyzují řetězce bez explicitní posunové komponenty a podporuje převod UTC v rámci operace analýzy. Všechny členy výčtu DateTimeStyles jsou podporovány s výjimkou NoCurrentDateDefault. Následující tabulka uvádí účinek každého podporovaného člena.

`DateTimeStyles` člen	Chování
AdjustToUniversal	Parsuje `input` a v případě potřeby ho převede na UTC. Je ekvivalentní parsování řetězce a volání DateTimeOffset.ToUniversalTime metody vráceného DateTimeOffset objektu.
AssumeLocal	Pokud odpovídající prvek v `formats` nevyžaduje, aby `input` obsahovat hodnotu posunu, vrácený objekt DateTimeOffset má posun místního časového pásma. Toto je výchozí hodnota.
AssumeUniversal	Pokud odpovídající prvek v `formats` nevyžaduje, aby `input` obsahovat hodnotu posunu, vrácený objekt DateTimeOffset má posun UTC (+00:00).
AllowInnerWhite	Umožňuje `input` zahrnout vnitřní prázdné znaky nezadané prvky v `formats`. Mezi komponentami data a času a v jednotlivých komponentách (s výjimkou posunu) se může zobrazit nadbytečné prázdné znaky a při analýze řetězce se ignoruje.
AllowLeadingWhite	Umožňuje `input` zahrnout úvodní mezery nezadané prvky v `formats`. Při analýze řetězce se tyto hodnoty ignorují.
AllowTrailingWhite	Umožňuje `input` zahrnout koncové mezery nezadané prvky v `formats`. Při analýze řetězce se tyto hodnoty ignorují.
AllowWhiteSpaces	Umožňuje `input` zahrnout úvodní, koncové a vnitřní mezery nezadané prvky v `formats`. Při analýze řetězce se ignorují všechny nadbytečné prázdné znaky, které nejsou zadané ve shodném prvku v `formats`.
None	Označuje, že v `input`není povoleno další prázdné znaky. Prázdné znaky musí být zobrazeny přesně tak, jak je uvedeno v určitém prvku v `formats`, aby se úspěšně shodovaly. Toto je výchozí chování.
RoundtripKind	Nemá žádný vliv, protože struktura DateTimeOffset neobsahuje vlastnost `Kind`.

Poznámky pro volající

V rozhraní .NET Framework 4 vrátí TryParseExact vrátí false, pokud řetězec, který se má analyzovat, obsahuje hodinovou komponentu a návrh AM/PM, který není ve smlouvě. V rozhraní .NET Framework 3.5 a starších verzích se návrh AM/PM ignoruje.

Platí pro

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

Zdroj:: DateTimeOffset.cs

Zdroj:: DateTimeOffset.cs

Zdroj:: 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 pro převod.

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 jazykovou verzi o input.

styles: DateTimeStyles

Bitová kombinace hodnot výčtu, která označuje povolený formát input. Typická hodnota pro zadání je None.

result: DateTimeOffset

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

Návraty

Boolean

true, pokud je parametr input úspěšně převeden; jinak false.

Výjimky

ArgumentException

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

Poznámky

Toto přetížení se podobá metodě DateTimeOffset.ParseExact(ReadOnlySpan<Char>, ReadOnlySpan<Char>, IFormatProvider, DateTimeStyles) s tím rozdílem, že tato metoda nevyvolá výjimku, pokud převod selže. Parsuje 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 rozsah znaků, který obsahuje specifikátor jednoho standardního formátu nebo jeden nebo více specifikátorů vlastního formátu, které definují požadovaný vzor input. Podrobnosti o platných formátovacích kódech najdete v tématu Standardní řetězce formátu data a času a vlastní řetězce formátu data a času. Pokud format obsahuje specifikátory z, zznebo zzz vlastní formát, aby bylo možné označit, že posun musí být v input, 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 obsahovala datum, ale ne čas, je výsledný objekt DateTimeOffset přiřazen čas půlnoci (0:00:00). Pokud format vyžaduje, aby input obsahoval čas, ale ne datum, přiřadí se výslednému objektu DateTimeOffset aktuální datum v místním systému. Pokud format nevyžaduje, aby input obsahoval posun, posun výsledného objektu DateTimeOffset závisí na hodnotě parametru styles. Pokud styles zahrnuje AssumeLocal, je posun místního časového pásma přiřazen k objektu DateTimeOffset. Pokud styles zahrnuje AssumeUniversal, posun koordinovaného univerzálního času (UTC) nebo +00:00, je přiřazen k objektu DateTimeOffset. Pokud není zadána žádná hodnota, použije se posun místního časového pásma.

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

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

Pokud je formatprovidernull, použije se objekt CultureInfo odpovídající aktuální jazykové verzi.

`DateTimeStyles` člen	Chování
AdjustToUniversal	Parsuje `input` a v případě potřeby ho převede na UTC. Odpovídá 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` obsahovala hodnotu posunu, vrácený objekt DateTimeOffset má posun místního časového pásma. Toto je výchozí chování.
AssumeUniversal	Pokud `format` nevyžaduje, aby `input` obsahovala hodnotu posunu, vrátí vrácený objekt DateTimeOffset 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 zobrazit nadbytečné prázdné znaky a při analýze řetězce se ignoruje.
AllowLeadingWhite	Umožňuje `input` zahrnout úvodní mezery nezadané `format`. Při analýze řetězce se tyto hodnoty ignorují.
AllowTrailingWhite	Umožňuje `input` zahrnout koncové mezery nezadané `format`. Při analýze řetězce se tyto hodnoty ignorují.
AllowWhiteSpaces	Umožňuje `input` zahrnout úvodní, koncové a vnitřní mezery nezadané `format`. Při analýze řetězce se ignorují všechny nadbytečné prázdné znaky nezadané v `format`.
None	Označuje, že v `input`není povoleno další prázdné znaky. Prázdné znaky se musí zobrazovat 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)

Zdroj:: DateTimeOffset.cs

Zdroj:: DateTimeOffset.cs

Zdroj:: 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ém pro jazykovou verzi a stylu. Formát reprezentace data a času se musí přesně shodovat s jedním 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 pro převod.

formats: String[]

Pole standardních nebo vlastních formátových řetězců, které definují přijatelné formáty input.

formatProvider: IFormatProvider

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

styles: DateTimeStyles

Bitová kombinace hodnot výčtu, která označuje povolený formát input. Typická hodnota pro zadání je None.

result: DateTimeOffset

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

Návraty

Boolean

true, pokud je parametr input úspěšně převeden; jinak false.

Výjimky

ArgumentException

styles obsahuje nedefinovanou hodnotu DateTimeStyles. -nebo- NoCurrentDateDefault se nepodporuje. 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 poli formats. Pokud input neodpovídá žádnému z těchto vzorů s žádnými 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, se toto přetížení chová stejně jako DateTimeOffset.ParseExact(ReadOnlySpan<Char>, String[], IFormatProvider, DateTimeStyles) metoda.

Důležitý

Pokud odpovídající prvek v formats vyžaduje, aby input obsahoval datum, ale ne čas, je výsledný objekt DateTimeOffset 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, je výsledný objekt DateTimeOffset přiřazen aktuální datum v místním systému. Pokud odpovídající prvek v formats nevyžaduje, aby input obsahoval posun, posun výsledného objektu DateTimeOffset závisí na hodnotě parametru styles. Pokud styles zahrnuje DateTimeStyles.AssumeLocal, je posun místního časového pásma přiřazen k objektu DateTimeOffset. Pokud styles zahrnuje DateTimeStyles.AssumeUniversal, posun koordinovaného univerzálního času (UTC) nebo +00:00, je přiřazen k objektu DateTimeOffset. Pokud není zadána žádná hodnota, použije se posun místního časového pásma.

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

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

Pokud je formatprovidernull, použije se objekt CultureInfo odpovídající aktuální jazykové verzi.

`DateTimeStyles` člen	Chování
AdjustToUniversal	Parsuje `input` a v případě potřeby ho převede na UTC. Je ekvivalentní parsování řetězce a volání DateTimeOffset.ToUniversalTime metody vráceného DateTimeOffset objektu.
AssumeLocal	Pokud odpovídající prvek v `formats` nevyžaduje, aby `input` obsahovat hodnotu posunu, vrácený objekt DateTimeOffset má posun místního časového pásma. Toto je výchozí hodnota.
AssumeUniversal	Pokud odpovídající prvek v `formats` nevyžaduje, aby `input` obsahovat hodnotu posunu, vrácený objekt DateTimeOffset má posun UTC (+00:00).
AllowInnerWhite	Umožňuje `input` zahrnout vnitřní prázdné znaky nezadané prvky v `formats`. Mezi komponentami data a času a v jednotlivých komponentách (s výjimkou posunu) se může zobrazit nadbytečné prázdné znaky a při analýze řetězce se ignoruje.
AllowLeadingWhite	Umožňuje `input` zahrnout úvodní mezery nezadané prvky v `formats`. Při analýze řetězce se tyto hodnoty ignorují.
AllowTrailingWhite	Umožňuje `input` zahrnout koncové mezery nezadané prvky v `formats`. Při analýze řetězce se tyto hodnoty ignorují.
AllowWhiteSpaces	Umožňuje `input` zahrnout úvodní, koncové a vnitřní mezery nezadané prvky v `formats`. Při analýze řetězce se ignorují všechny nadbytečné prázdné znaky, které nejsou zadané ve shodném prvku v `formats`.
None	Označuje, že v `input`není povoleno další prázdné znaky. Prázdné znaky musí být zobrazeny přesně tak, jak je uvedeno v určitém prvku v `formats`, aby se úspěšně shodovaly. Toto je výchozí chování.
RoundtripKind	Nemá žádný vliv, protože struktura DateTimeOffset neobsahuje vlastnost `Kind`.

Platí pro

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

Zdroj:: DateTimeOffset.cs

Zdroj:: DateTimeOffset.cs

Zdroj:: 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 jazyk a styl. Formát řetězcové reprezentace se musí přesně shodovat se zadaným formátem.

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 pro převod.

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 jazykovou verzi o input.

styles: DateTimeStyles

Bitová kombinace hodnot výčtu, která označuje povolený formát vstupu. Typická hodnota pro zadání je None.

result: DateTimeOffset

Když metoda vrátí, obsahuje DateTimeOffset ekvivalentní datum a čas input, pokud převod byl úspěšný nebo DateTimeOffset.MinValue, pokud převod selhal. Převod selže, pokud je parametr inputnullnebo neobsahuje platnou řetězcovou reprezentaci data a času v očekávaném formátu definovaném format a provider. Tento parametr se předává neinicializovaný.

Návraty

Boolean

true, pokud je parametr input úspěšně převeden; jinak false.

Výjimky

ArgumentException

styles obsahuje nedefinovanou hodnotu DateTimeStyles.

-nebo-

NoCurrentDateDefault se nepodporuje.

-nebo-

styles zahrnuje vzájemně se vylučují 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, invariantní jazykovou verzí a různými hodnotami DateTimeStyles parsovat několik ř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é mají být v souladu s 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ý příznak DateTimeStyles (například DateTimeStyles.AllowWhiteSpaces nebyl do volání metody zadán.
obsahují prvky data a času, které jsou mimo rozsah.

Řetězce, které nezadávají posun UTC, se předpokládá, že mají posun místního časového pásma (v tomto případě -07:00, který odráží posun tichomoří letního časového pásma), pokud není v volání metody zadán příznak DateTimeStyles.AssumeUniversal. 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) metoda je jako metoda DateTimeOffset.ParseExact(String, String, IFormatProvider, DateTimeStyles) s tím rozdílem, že tato metoda nevyvolá výjimku, pokud převod selže. Analyzuje řetězcovou reprezentaci data a času, která musí přesně odpovídat vzoru zadanému parametrem format. Pokud řetězec 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 řetězec, který obsahuje buď jeden specifikátor standardního formátu, nebo jeden nebo více specifikátorů vlastního formátu, které definují požadovaný vzor input. Podrobnosti o platných formátovacích kódech najdete v tématu Standardní řetězce formátu data a času a vlastní řetězce formátu data a času. Pokud format obsahuje specifikátory z, zznebo zzz vlastní formát, aby bylo možné označit, že posun musí být v input, 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.

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

Pokud je formatprovidernull, použije se objekt CultureInfo odpovídající aktuální jazykové verzi.

`DateTimeStyles` člen	Chování
AdjustToUniversal	Parsuje `input` a v případě potřeby ho převede na UTC. Je ekvivalentní parsování řetězce a volání DateTimeOffset.ToUniversalTime metody vráceného DateTimeOffset objektu.
AssumeLocal	Pokud `format` nevyžaduje, aby `input` obsahovala hodnotu posunu, vrácený objekt DateTimeOffset má posun místního časového pásma. Toto je výchozí chování.
AssumeUniversal	Pokud `format` nevyžaduje, aby `input` obsahovala hodnotu posunu, vrátí vrácený objekt DateTimeOffset 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 zobrazit nadbytečné prázdné znaky a při analýze řetězce se ignoruje.
AllowLeadingWhite	Umožňuje `input` zahrnout úvodní mezery nezadané `format`. Při analýze řetězce se tyto hodnoty ignorují.
AllowTrailingWhite	Umožňuje `input` zahrnout koncové mezery nezadané `format`. Při analýze řetězce se tyto hodnoty ignorují.
AllowWhiteSpaces	Umožňuje `input` zahrnout úvodní, koncové a vnitřní mezery nezadané `format`. Při analýze řetězce se ignorují všechny nadbytečné prázdné znaky nezadané v `format`.
None	Označuje, že v `input`není povoleno další prázdné znaky. Prázdné znaky se musí zobrazovat 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.

Poznámky pro volající

Viz také

ParseExact

Platí pro

Sdílet prostřednictvím

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

Další materiály