DateTimeOffset.TryParseExact Metoda

Definice

Obor názvů:: System

Sestavení:: mscorlib.dll, System.Runtime.dll

Sestavení:: netstandard.dll, System.Runtime.dll

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í

Name	Description
TryParseExact(String, String[], IFormatProvider, DateTimeStyles, DateTimeOffset)	Převede zadanou řetězcovou reprezentaci data a času na ekvivalent DateTimeOffset pomocí zadaného pole formátů, informací o formátu specifickém pro jazyk a styl. 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 jazyk a styl. 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 ekvivalent DateTimeOffset pomocí zadaných formátů, informací o formátu specifickém pro jazyk a styl. 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 ekvivalent DateTimeOffset pomocí zadaného formátu, informací o formátu specifickém pro jazykovou verzi a stylu. 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

Zdroj:: DateTimeOffset.cs

Zdroj:: DateTimeOffset.cs

Převede zadanou řetězcovou reprezentaci data a času na ekvivalent DateTimeOffset pomocí zadaného pole formátů, informací o formátu specifickém pro jazyk a styl. 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 inputformátování specifické pro jazykovou verzi .

styles: DateTimeStyles

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

result: DateTimeOffset

Když metoda vrátí, obsahuje DateTimeOffset ekvivalent k datu a času 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 nebo formatspokud formats je null. Tento parametr se předává neinicializovaný.

Návraty

Boolean

true input pokud je parametr úspěšně převeden; 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íné DateTimeStyles hodnoty.

Příklady

Následující příklad definuje více vstupních formátů pro řetězcovou reprezentaci hodnoty data a času a posunu a pak předá řetězec, který uživatel zadá 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) analyzuje řetězcovou reprezentaci data, které odpovídá libovolnému vzoru přiřazeného formats k poli. input Pokud řetězec neodpovídá žádnému z těchto vzorů s jakoukoli variantou definovanou parametremstyles, 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 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 formátových kódech naleznete 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 formats obsahuje zspecifikátory formátu , zznebo zzz vlastní formát označující, že posun musí být obsažen v input, musí být v daném posunu 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ý

formats Použití 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 formats vyžaduje, aby input obsahoval datum, ale ne čas, je výsledný DateTimeOffset objekt přiřazen čas půlnoci (0:00:00). Pokud odpovídající prvek vyžaduje formats , aby vstup obsahoval čas, ale ne datum, je výsledný DateTimeOffset objekt přiřazen aktuální datum v místním systému. Pokud odpovídající prvek formats nevyžaduje, aby input obsahoval posun, posun výsledného DateTimeOffset objektu závisí na hodnotě parametru styles . V případě styles zahrnutí AssumeLocalje posun místního časového pásma přiřazen k objektu DateTimeOffset . Pokud styles zahrnuje AssumeUniversalposun koordinovaného univerzálního času (UTC) nebo +00:00, je objektu DateTimeOffset přiřazen. 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 parametru formatProvider jsou definovány. Totéž platí pro přesný vzor input , pokud je odpovídající prvek formats standardního specifikátoru formátu řetězec. Parametr formatProvider může být následující:

Objekt CultureInfo , který představuje jazykovou verzi, na základě které input je interpretováno. 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, CultureInfo objekt, který odpovídá aktuální jazykové verzi je použit.

Parametr styles definuje, jestli je ve vstupním řetězci povolené prázdné znaky, určuje, jak se řetězce bez explicitní posunové komponenty parsují 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 následné volání DateTimeOffset.ToUniversalTime metody vráceného DateTimeOffset objektu.
AssumeLocal	Pokud odpovídající prvek `formats` nevyžaduje, aby `input` obsahoval hodnotu posunu, vrátí DateTimeOffset vrácený objekt posun místního časového pásma. Toto je výchozí hodnota.
AssumeUniversal	Pokud odpovídající prvek `formats` nevyžaduje, aby `input` obsahoval hodnotu posunu, vrátí vrácený DateTimeOffset objekt posun UTC (+00:00).
AllowInnerWhite	Umožňuje `input` zahrnout vnitřní prázdné znaky, které nejsou určeny 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, které nejsou určeny prvky v `formats`. Při analýze řetězce se tyto hodnoty ignorují.
AllowTrailingWhite	Umožňuje `input` zahrnout koncové mezery, které nejsou určeny prvky v `formats`. Při analýze řetězce se tyto hodnoty ignorují.
AllowWhiteSpaces	Umožňuje `input` zahrnout úvodní, koncové a vnitřní mezery, které nejsou určeny 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 `formats` .
None	Označuje, že další prázdné znaky nejsou povoleny v `input`. Prázdné znaky musí být zobrazeny přesně tak, jak je uvedeno v určitém prvku `formats` , aby se úspěšně shodovaly. Toto je výchozí chování.
RoundtripKind	Nemá žádný vliv, protože DateTimeOffset struktura neobsahuje `Kind` vlastnost.

Poznámky pro volající

V rozhraní .NET Framework 4 vrátí hodnotufalse, pokud řetězec, který se má analyzovat, TryParseExact 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

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 jazyk a styl. 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 inputformátování specifické pro jazykovou verzi .

styles: DateTimeStyles

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

result: DateTimeOffset

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

Návraty

Boolean

true input pokud je parametr úspěšně převeden; v opačném případě false.

Výjimky

ArgumentException

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

Poznámky

Toto přetížení je podobné 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. Parsuje reprezentaci data a času, které musí přesně odpovídat vzoru určenému parametrem format . Pokud input tento vzor neodpovídá, 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 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átových kódech naleznete v tématu Standardní řetězce formátu data a času a vlastní řetězce formátu data a času. Pokud format obsahuje zspecifikátory formátu , zznebo zzz vlastní formát, které označují, že posun musí být uveden 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 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 obsahovalo čas, ale ne datum, je výslednému DateTimeOffset objektu přiřazeno aktuální datum v místním systému. Pokud format nevyžaduje, aby input obsahoval posun, posun výsledného DateTimeOffset objektu závisí na hodnotě parametru styles . V případě styles zahrnutí AssumeLocalje posun místního časového pásma přiřazen k objektu DateTimeOffset . Pokud styles zahrnuje AssumeUniversalposun koordinovaného univerzálního času (UTC) nebo +00:00, je objektu DateTimeOffset přiřazen. 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 parametru formatProvider jsou definovány. Totéž platí pro přesný vzor input , pokud format je standardním specifikátorem formátu řetězec. Parametr formatProvider může být následující:

Objekt CultureInfo , který představuje jazykovou verzi, na základě které input je interpretováno. 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, CultureInfo objekt, který odpovídá aktuální jazykové verzi je použit.

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í 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átí vrácený DateTimeOffset objekt posun místního časového pásma. Toto je výchozí chování.
AssumeUniversal	Pokud `format` nevyžaduje, aby `input` obsahoval hodnotu posunu, vrátí 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ůže zobrazit nadbytečné prázdné znaky a při analýze řetězce se ignoruje.
AllowLeadingWhite	Umožňuje `input` zahrnout úvodní mezery nezadané parametrem `format`. Při analýze řetězce se tyto hodnoty ignorují.
AllowTrailingWhite	Umožňuje `input` zahrnout koncové mezery, které nejsou zadány `format`. Při analýze řetězce se tyto hodnoty ignorují.
AllowWhiteSpaces	Umožňuje `input` zahrnout úvodní, koncové a vnitřní mezery, které nejsou zadány `format`. Při analýze řetězce se ignorují všechny nadbytečné prázdné znaky, které `format` nejsou zadané.
None	Označuje, že další prázdné znaky nejsou povoleny v `input`. Prázdné znaky musí být zobrazeny 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

Zdroj:: DateTimeOffset.cs

Zdroj:: DateTimeOffset.cs

Převede reprezentaci data a času v rozsahu znaků na ekvivalent DateTimeOffset pomocí zadaných formátů, informací o formátu specifickém pro jazyk a styl. 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 inputformátování specifické pro jazykovou verzi .

styles: DateTimeStyles

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

result: DateTimeOffset

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

Návraty

Boolean

true input pokud je parametr úspěšně převeden; v opačném případě false.

Výjimky

ArgumentException

styles obsahuje nedefinovanou DateTimeStyles hodnotu. -nebo- NoCurrentDateDefault není podporován. -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 formats k poli. Pokud input neodpovídá žádnému z těchto vzorů s žádnou variantou definovanou 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 formats vyžaduje, aby input obsahoval datum, ale ne čas, je výsledný DateTimeOffset objekt přiřazen čas půlnoci (0:00:00). Pokud odpovídající prvek vyžaduje formats , aby vstup obsahoval čas, ale ne datum, je výsledný DateTimeOffset objekt přiřazen aktuální datum v místním systému. Pokud odpovídající prvek formats nevyžaduje, aby input obsahoval posun, posun výsledného DateTimeOffset objektu závisí na hodnotě parametru styles . V případě styles zahrnutí DateTimeStyles.AssumeLocalje posun místního časového pásma přiřazen k objektu DateTimeOffset . Pokud styles zahrnuje DateTimeStyles.AssumeUniversalposun koordinovaného univerzálního času (UTC) nebo +00:00, je objektu DateTimeOffset přiřazen. 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 parametru formatProvider jsou definovány. Totéž platí pro přesný vzor input , pokud je odpovídající prvek formats standardního specifikátoru formátu řetězec. Parametr formatProvider může být následující:

Objekt CultureInfo , který představuje jazykovou verzi, na základě které input je interpretováno. 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, CultureInfo objekt, který odpovídá aktuální jazykové verzi je použit.

`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 následné volání DateTimeOffset.ToUniversalTime metody vráceného DateTimeOffset objektu.
AssumeLocal	Pokud odpovídající prvek `formats` nevyžaduje, aby `input` obsahoval hodnotu posunu, vrátí DateTimeOffset vrácený objekt posun místního časového pásma. Toto je výchozí hodnota.
AssumeUniversal	Pokud odpovídající prvek `formats` nevyžaduje, aby `input` obsahoval hodnotu posunu, vrátí vrácený DateTimeOffset objekt posun UTC (+00:00).
AllowInnerWhite	Umožňuje `input` zahrnout vnitřní prázdné znaky, které nejsou určeny 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, které nejsou určeny prvky v `formats`. Při analýze řetězce se tyto hodnoty ignorují.
AllowTrailingWhite	Umožňuje `input` zahrnout koncové mezery, které nejsou určeny prvky v `formats`. Při analýze řetězce se tyto hodnoty ignorují.
AllowWhiteSpaces	Umožňuje `input` zahrnout úvodní, koncové a vnitřní mezery, které nejsou určeny 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 `formats` .
None	Označuje, že další prázdné znaky nejsou povoleny v `input`. Prázdné znaky musí být zobrazeny přesně tak, jak je uvedeno v určitém prvku `formats` , aby se úspěšně shodovaly. Toto je výchozí chování.
RoundtripKind	Nemá žádný vliv, protože DateTimeOffset struktura neobsahuje `Kind` vlastnost.

Platí pro

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

Zdroj:: DateTimeOffset.cs

Zdroj:: DateTimeOffset.cs

Zdroj:: DateTimeOffset.cs

Zdroj:: DateTimeOffset.cs

Zdroj:: DateTimeOffset.cs

Převede zadanou řetězcovou reprezentaci data a času na ekvivalent DateTimeOffset pomocí zadaného formátu, informací o formátu specifickém pro jazykovou verzi a stylu. 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 inputformátování specifické pro jazykovou verzi .

styles: DateTimeStyles

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

result: DateTimeOffset

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

Návraty

Boolean

true input pokud je parametr úspěšně převeden; 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í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, invariantní jazykovou verzí a různými DateTimeStyles hodnotami k analýze 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é 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 odpovídající 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é 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 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 podobné DateTimeOffset.ParseExact(String, String, IFormatProvider, DateTimeStyles) metodě, 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 určenému parametrem format . input Pokud řetězec neodpovídá tomuto vzoru, s některými možnými variacemi prázdných znaků definovaných parametremstyles, analýza operace 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 input. Podrobnosti o platných formátových kódech naleznete v tématu Standardní řetězce formátu data a času a vlastní řetězce formátu data a času. Pokud format obsahuje zspecifikátory formátu , zznebo zzz vlastní formát, které označují, že posun musí být uveden 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áno. 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, CultureInfo objekt, který odpovídá aktuální jazykové verzi je použit.

`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 následné volání DateTimeOffset.ToUniversalTime metody vráceného DateTimeOffset objektu.
AssumeLocal	Pokud `format` nevyžaduje, aby `input` obsahovala hodnotu posunu, vrátí vrácený DateTimeOffset objekt posun místního časového pásma. Toto je výchozí chování.
AssumeUniversal	Pokud `format` nevyžaduje, aby `input` obsahoval hodnotu posunu, vrátí 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ůže zobrazit nadbytečné prázdné znaky a při analýze řetězce se ignoruje.
AllowLeadingWhite	Umožňuje `input` zahrnout úvodní mezery nezadané parametrem `format`. Při analýze řetězce se tyto hodnoty ignorují.
AllowTrailingWhite	Umožňuje `input` zahrnout koncové mezery, které nejsou zadány `format`. Při analýze řetězce se tyto hodnoty ignorují.
AllowWhiteSpaces	Umožňuje `input` zahrnout úvodní, koncové a vnitřní mezery, které nejsou zadány `format`. Při analýze řetězce se ignorují všechny nadbytečné prázdné znaky, které `format` nejsou zadané.
None	Označuje, že další prázdné znaky nejsou povoleny v `input`. Prázdné znaky musí být zobrazeny 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

Váš názor

Byla tato stránka užitečná?

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

Váš názor