DateTimeOffset.ParseExact 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 ekvivalent.DateTimeOffset Formát řetězcového vyjádření musí přesně odpovídat určenému formátu.

Přetížení

ParseExact(String, String[], IFormatProvider, DateTimeStyles)	Převede zadanou řetězcovou reprezentaci data a času na jeho DateTimeOffset ekvivalent pomocí zadaných formátů, informací o formátu specifické pro jazykovou verzi a stylu. Formát řetězcového vyjádření musí přesně odpovídat jednomu z určených formátů.
ParseExact(String, String, IFormatProvider, DateTimeStyles)	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ého vyjádření musí přesně odpovídat určenému formátu.
ParseExact(String, String, IFormatProvider)	Převede zadanou řetězcovou reprezentaci data a času na ekvivalent DateTimeOffset pomocí zadaného formátu a informací o formátu specifickém pro jazykovou verzi. Formát řetězcového vyjádření musí přesně odpovídat určenému formátu.
ParseExact(ReadOnlySpan<Char>, ReadOnlySpan<Char>, IFormatProvider, DateTimeStyles)	Převede rozsah znaků, který představuje datum a čas 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.
ParseExact(ReadOnlySpan<Char>, String[], IFormatProvider, DateTimeStyles)	Převede rozsah znaků obsahující řetězcovou reprezentaci data a času 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 musí přesně odpovídat jednomu ze zadaných formátů.

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

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

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

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

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

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

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

Parametry

input: String

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

formats: String[]

Pole specifikátorů formátu, které definují očekávané formáty input.

formatProvider: IFormatProvider

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

styles: DateTimeStyles

Bitové kombinace hodnot výčtu, která označuje povolený formát input.

Návraty

DateTimeOffset

Objekt, který odpovídá datu a času obsaženému v parametru input , jak je určeno parametrem formats, formatProvidera styles parametry.

Výjimky

ArgumentException

Posun je větší než 14 hodin nebo menší než-14 hodin.

-nebo-

styles obsahuje nepodporovanou hodnotu.

-nebo-

Parametr styles obsahuje DateTimeStyles hodnoty, které nelze použít společně.

ArgumentNullException

input je null.

FormatException

input je prázdný řetězec ("").

-nebo-

input neobsahuje platnou řetězcovou reprezentaci data a času.

-nebo-

Žádný prvek neobsahuje specifikátor platného formats formátu.

-nebo-

Hodinová komponenta a návrh AM/PM nesouhlasí input .

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 zadaný uživatelem metodě DateTimeOffset.ParseExact(String, String[], IFormatProvider, DateTimeStyles) .

TextReader conIn = Console.In;
TextWriter conOut = Console.Out;
int tries = 0;
string input = String.Empty;
string[] formats = new string[] {@"@M/dd/yyyy HH:m zzz", @"MM/dd/yyyy HH:m zzz",
                                 @"M/d/yyyy HH:m zzz", @"MM/d/yyyy HH:m zzz",
                                 @"M/dd/yy HH:m zzz", @"MM/dd/yy HH:m zzz",
                                 @"M/d/yy HH:m zzz", @"MM/d/yy HH:m zzz",
                                 @"M/dd/yyyy H:m zzz", @"MM/dd/yyyy H:m zzz",
                                 @"M/d/yyyy H:m zzz", @"MM/d/yyyy H:m zzz",
                                 @"M/dd/yy H:m zzz", @"MM/dd/yy H:m zzz",
                                 @"M/d/yy H:m zzz", @"MM/d/yy H:m zzz",
                                 @"M/dd/yyyy HH:mm zzz", @"MM/dd/yyyy HH:mm zzz",
                                 @"M/d/yyyy HH:mm zzz", @"MM/d/yyyy HH:mm zzz",
                                 @"M/dd/yy HH:mm zzz", @"MM/dd/yy HH:mm zzz",
                                 @"M/d/yy HH:mm zzz", @"MM/d/yy HH:mm zzz",
                                 @"M/dd/yyyy H:mm zzz", @"MM/dd/yyyy H:mm zzz",
                                 @"M/d/yyyy H:mm zzz", @"MM/d/yyyy H:mm zzz",
                                 @"M/dd/yy H:mm zzz", @"MM/dd/yy H:mm zzz",
                                 @"M/d/yy H:mm zzz", @"MM/d/yy H:mm zzz"};
IFormatProvider provider = CultureInfo.InvariantCulture.DateTimeFormat;
DateTimeOffset result = new DateTimeOffset();

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

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

let mutable result = None
let mutable tries = 0
while tries < 3 && result.IsNone do
    printfn "Enter a date, time, and offset (MM/DD/YYYY HH:MM +/-HH:MM),"
    printf "Then press Enter: "
    let input = stdin.ReadLine()
    printfn ""
    try
        result <- 
            DateTimeOffset.ParseExact(input, formats, provider, DateTimeStyles.AllowWhiteSpaces) 
            |> Some
    with :? FormatException ->
        printfn $"Unable to parse {input}."
        tries <- tries + 1

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

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

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

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

Poznámky

Metoda DateTimeOffset.ParseExact(String, String[], IFormatProvider, DateTimeStyles) analyzuje řetězcovou reprezentaci data, která odpovídá jakémukoli vzoru přiřazeného k parametru formats . input Pokud řetězec neodpovídá žádnému z těchto vzorů s žádnou z variant definovaných parametremstyles, metoda vyvolá FormatException. Kromě porovnání s input více vzory formátování se toto přetížení chová stejně jako metoda DateTimeOffset.ParseExact(String, String, IFormatProvider, DateTimeStyles) .

Parametr formats je pole řetězců, jehož prvky obsahují specifikátor standardního formátu nebo jeden nebo více specifikátorů vlastního formátu, které definují možný vzor parametru input . Při zavolání input metody se musí shodovat s jedním z těchto vzorů. Podrobnosti o platných kódech formátování 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 obsahuje formats zspecifikátory formátu , zznebo zzz vlastní formát, které označují, že posun musí být obsažen v input, musí tento posun obsahovat buď záporné znaménko, nebo kladné znaménko. Pokud znaménko chybí, metoda vyvolá FormatExceptionchybu .

Důležité

formats Použití parametru tohoto přetížení k určení více formátů může pomoct snížit frustraci mnoha uživatelů, když zadají data a časy. Konkrétně schopnost definovat více vstupních vzorů umožňuje aplikaci zpracovávat reprezentace data a času, které mohou zahrnovat nebo chybí počáteční 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 vyžaduje formats , aby input obsahoval datum, ale ne čas, výsledný DateTimeOffset objekt je přiřazen čas půlnoci (0:00:00). Pokud odpovídající prvek vyžaduje formats , aby input obsahoval čas, ale ne datum, výsledný DateTimeOffset objekt je 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 . Pokud styles zahrnuje AssumeLocal, posun místního časového pásma je přiřazen 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 ani jedna hodnota, bude použit posun místního časového pásma.

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

Objekt CultureInfo , který představuje jazykovou verzi, na základě které input se interpretuje. 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 ano null, CultureInfo použije se objekt 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 ř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 kromě NoCurrentDateDefault. V následující tabulce jsou uvedeny účinky jednotlivých podporovaných členů.

`DateTimeStyles` Členské	Chování
AdjustToUniversal	Parsuje `input` a v případě potřeby ho převede na UTC. Je ekvivalentní analýze ř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ácený DateTimeOffset objekt 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` obsahoval hodnotu posunu, vrácený DateTimeOffset objekt má posun UTC (+00:00).
AllowInnerWhite	Umožňuje `input` zahrnout vnitřní prázdné znaky, které neurčené `format`. Mezi komponentami data a času a v jednotlivých komponentách (s výjimkou posunu) se může objevit nadbytečné prázdné znaky a při analýze řetězce se ignoruje.
AllowLeadingWhite	Umožňuje `input` zahrnout úvodní mezery, které nejsou zadány .`formats` Při analýze řetězce jsou ignorovány.
AllowTrailingWhite	Umožňuje `input` zahrnout koncové mezery, které nejsou určené .`formats` Při analýze řetězce jsou ignorovány.
AllowWhiteSpaces	Umožňuje `input` zahrnout úvodní, koncové a vnitřní mezery, které nejsou určené .`formats` Při analýze řetězce se ignorují všechny nadbytečné prázdné znaky nezadané v odpovídajícím prvku `formats` .
None	Označuje, že další prázdné znaky nejsou povoleny v `input`. Prázdné znaky se musí zobrazovat přesně tak, jak je uvedeno v určitém prvku `formats` shody. 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 metoda vyvolá metoduFormatException, pokud řetězec, ParseExact který se má analyzovat, obsahuje hodinovou komponentu a designátor AM/PM, který není ve smlouvě. V rozhraní .NET Framework 3.5 a starších verzích se designátor AM/PM ignoruje.

Viz také

Platí pro

ParseExact(String, String, IFormatProvider, DateTimeStyles)

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ého vyjádření musí přesně odpovídat určenému formátu.

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

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

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

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

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

Parametry

input: String

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

format: String

Specifikátor formátu, který definuje očekávaný formát input.

formatProvider: IFormatProvider

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

styles: DateTimeStyles

Bitové kombinace hodnot výčtu, která označuje povolený formát input.

Návraty

DateTimeOffset

Objekt, který odpovídá datu a času obsaženému v parametru input , jak je určeno parametrem format, formatProvidera styles parametry.

Výjimky

ArgumentException

Posun je větší než 14 hodin nebo menší než-14 hodin.

-nebo-

Parametr styles obsahuje nepodporovanou hodnotu.

-nebo-

Parametr styles obsahuje DateTimeStyles hodnoty, které nelze použít společně.

ArgumentNullException

input je null.

-nebo-

format je null.

FormatException

input je prázdný řetězec ("").

-nebo-

input neobsahuje platnou řetězcovou reprezentaci data a času.

-nebo-

format je prázdný řetězec.

-nebo-

Hodinová komponenta a designátor input AM/PM nesouhlasí.

Příklady

Následující příklad používá metodu DateTimeOffset.ParseExact(String, String, IFormatProvider, DateTimeStyles) se specifikátory standardního a vlastního formátu, invariantní jazykovou verzi a různé DateTimeStyles hodnoty k analýze několika řetězců data a času.

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

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

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

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

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

let provider = CultureInfo.InvariantCulture

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

// Parse date-only value with leading white space.
// Should throw a FormatException because only trailing white space is
// specified in method call.
let dateString = " 06/15/2008"
try
    let result = DateTimeOffset.ParseExact(dateString, format, provider, DateTimeStyles.AllowTrailingWhite)
    printfn $"'{dateString}' converts to {result}."
with :? FormatException ->
    printfn $"'{dateString}' is not in the correct format."

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

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

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

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

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

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

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

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

Následující příklad používá různé DateTimeStyles hodnoty k analýze pole řetězců, které mají odpovídat 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), 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.

module parseexact_iso8601_2

open System
open System.Globalization

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

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

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


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

using System;
using System.Globalization;

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

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

Imports System.Globalization

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

   Private Sub ParseWithISO8601(dateStrings() As String, styles As DateTimeStyles)
      Console.WriteLine($"Parsing with {styles}:")
      For Each dateStr In dateStrings
         Try 
            Dim dat = DateTimeOffset.ParseExact(dateString, "O", Nothing, styles)
            Console.WriteLine($"   {dateString,-35} --> {dat:yyyy-MM-dd HH:mm:ss.FF zzz}")
         catch e As FormatException
            Console.WriteLine($"   FormatException: Unable to convert '{dateString}'")
         End Try   
      Next 
   End Sub
End Module
' The example displays the following output:
'      Parsing with None:
'         FormatException: Unable to convert '07-30-2018'
'         FormatException: Unable to convert '07-30-2018'
'         FormatException: Unable to convert '07-30-2018'
'         FormatException: Unable to convert '07-30-2018'
'         FormatException: Unable to convert '07-30-2018'
'         FormatException: Unable to convert '07-30-2018'
'         FormatException: Unable to convert '07-30-2018'
'
'      -----
'
'      Parsing with AllowWhiteSpaces:
'         FormatException: Unable to convert '07-30-2018'
'         FormatException: Unable to convert '07-30-2018'
'         FormatException: Unable to convert '07-30-2018'
'         FormatException: Unable to convert '07-30-2018'
'         FormatException: Unable to convert '07-30-2018'
'         FormatException: Unable to convert '07-30-2018'
'         FormatException: Unable to convert '07-30-2018'
'
'      -----
'
'      Parsing with AdjustToUniversal:
'         FormatException: Unable to convert '07-30-2018'
'         FormatException: Unable to convert '07-30-2018'
'         FormatException: Unable to convert '07-30-2018'
'         FormatException: Unable to convert '07-30-2018'
'         FormatException: Unable to convert '07-30-2018'
'         FormatException: Unable to convert '07-30-2018'
'         FormatException: Unable to convert '07-30-2018'
'
'      -----
'
'      Parsing with AssumeLocal:
'         FormatException: Unable to convert '07-30-2018'
'         FormatException: Unable to convert '07-30-2018'
'         FormatException: Unable to convert '07-30-2018'
'         FormatException: Unable to convert '07-30-2018'
'         FormatException: Unable to convert '07-30-2018'
'         FormatException: Unable to convert '07-30-2018'
'         FormatException: Unable to convert '07-30-2018'
'
'      -----
'
'      Parsing with AssumeUniversal:
'         FormatException: Unable to convert '07-30-2018'
'         FormatException: Unable to convert '07-30-2018'
'         FormatException: Unable to convert '07-30-2018'
'         FormatException: Unable to convert '07-30-2018'
'         FormatException: Unable to convert '07-30-2018'
'         FormatException: Unable to convert '07-30-2018'
'         FormatException: Unable to convert '07-30-2018'

Poznámky

Metoda DateTimeOffset.ParseExact(String, String, IFormatProvider, DateTimeStyles) parsuje řetězcovou reprezentaci data, která musí být ve formátu definovaném parametrem format . Vyžaduje také, aby <Date><Time>se prvky řetězcové reprezentace data a <Offset> času zobrazovaly v pořadí určeném uživatelem format. input Pokud řetězec neodpovídá vzoru parametruformat, se všemi variantami definovanými styles parametrem vyvolá metoda FormatException. Naproti tomu DateTimeOffset.Parse(String, IFormatProvider, DateTimeStyles) metoda parsuje řetězcovou reprezentaci data v libovolném z formátů rozpoznaných objektem zprostředkovatele DateTimeFormatInfo formátu. Parse také umožňuje <Date>, <Time>a prvky řetězcové reprezentace data a <Offset> času zobrazovat v libovolném pořadí.

Parametr format je řetězec, 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 parametru input . Podrobnosti o platných kódech formátování 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 vlastního zformátu zzz , které označují, zzž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í, metoda vyvolá FormatExceptionchybu .

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

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

Objekt CultureInfo , který představuje jazykovou verzi, na 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 data a času.

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

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

`DateTimeStyles` Členské	Chování
AdjustToUniversal	Parsuje `input` a v případě potřeby ho převede na UTC. Je ekvivalentní analýze ř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í DateTimeOffset vrácený objekt posun místního časového pásma. Toto je výchozí hodnota.
AssumeUniversal	Pokud `format` nevyžaduje, aby `input` obsahovala hodnotu posunu, vrátí DateTimeOffset vrácený objekt posun (+00:00).
AllowInnerWhite	Umožňuje `input` zahrnout vnitřní prázdné místo, které `format`není určeno . Mezi komponentami data a času a v jednotlivých komponentách se může zobrazit nadbytečné prázdné místo a při analýze řetězce se ignoruje.
AllowLeadingWhite	Umožňuje `input` zahrnout úvodní mezery, které nejsou zadány .`format` Při analýze řetězce jsou ignorovány.
AllowTrailingWhite	Umožňuje `input` zahrnout koncové mezery, které nejsou zadány .`format` Při analýze řetězce jsou ignorovány.
AllowWhiteSpaces	Umožňuje `input` zahrnout úvodní, koncové a vnitřní mezery, které nejsou specifikovány `format`. Při analýze řetězce se ignorují všechny nadbytečné znaky prázdných znaků, které `format` nejsou zadané.
None	Označuje, že další prázdné znaky nejsou povoleny v `input`. Prázdné místo musí vypadat 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í

V rozhraní .NET Framework 4 metoda ParseExact vyvolá FormatException , pokud řetězec, který se má analyzovat, obsahuje hodinovou komponentu a designátor AM/PM, který není ve smlouvě. V rozhraní .NET Framework 3.5 a starších verzích se designátor AM/PM ignoruje.

Viz také

Platí pro

ParseExact(String, String, IFormatProvider)

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

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

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

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

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

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

Parametry

input: String

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

format: String

Specifikátor formátu, který definuje očekávaný formát input.

formatProvider: IFormatProvider

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

Návraty

DateTimeOffset

Objekt, který je ekvivalentní datu a času, který je obsažen v input zadaném a format formatProvider.

Výjimky

ArgumentException

Posun je větší než 14 hodin nebo menší než-14 hodin.

ArgumentNullException

input je null.

-nebo-

format je null.

FormatException

input je prázdný řetězec ("").

-nebo-

input neobsahuje platnou řetězcovou reprezentaci data a času.

-nebo-

format je prázdný řetězec.

-nebo-

Hodinová komponenta a návrh AM/PM nesouhlasí input .

Příklady

Následující příklad používá metodu DateTimeOffset.ParseExact(String, String, IFormatProvider) se standardními a vlastními specifikátory formátu a invariantní jazykovou verzí k analýze několika řetězců data a času.

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

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

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

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

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

let provider = CultureInfo.InvariantCulture

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

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

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

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

// The example displays the following output:
//    06/15/2008 converts to 6/15/2008 12:00:00 AM -07:00.
//    6/15/2008 is not in the correct format.
//    Sun 15 Jun 2008 8:30 AM -06:00 converts to 6/15/2008 8:30:00 AM -06:00.
//    Sun 15 Jun 2008 8:30 AM -06 is not in the correct format.

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

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

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

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

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

Následující příklad analyzuje pole řetězců, u které se očekává, že odpovídají iso 8601. Jak ukazuje výstup z příkladu, řetězce s úvodními nebo koncovými mezerami se nepodaří úspěšně analyzovat, stejně jako řetězce s prvky data a času, které jsou mimo rozsah.

module parseexact_iso8601

open System

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

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

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


// The example displays the following output:
//      2018-08-18T12:45:16.0000000Z        --> 2018-08-18 12:45:16 +00:00
//      FormatException: Unable to convert '2018/08/18T12:45:16.0000000Z'
//      FormatException: Unable to convert '2018-18-08T12:45:16.0000000Z'
//      FormatException: Unable to convert ' 2018-08-18T12:45:16.0000000Z '
//      2018-08-18T12:45:16.0000000+02:00   --> 2018-08-18 12:45:16 +02:00
//      2018-08-18T12:45:16.0000000-07:00   --> 2018-08-18 12:45:16 -07:00

using System;

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

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

Poznámky

Metoda ParseExact(String, String, IFormatProvider) analyzuje řetězcovou reprezentaci data, která musí být ve formátu definovaném parametrem format . Vyžaduje také, aby <Date><Time>se prvky řetězce <Offset> vyjádření data a času zobrazovaly v pořadí určeném parametrem format. input Pokud řetězec neodpovídá tomuto format parametru, metoda vyvolá FormatException. Naproti tomu DateTimeOffset.Parse(String, IFormatProvider) metoda parsuje řetězcovou reprezentaci data v libovolném z formátů rozpoznaných objektem zprostředkovatele DateTimeFormatInfo formátu. Parse také umožňuje <Date>, <Time>a <Offset> prvky řetězcové reprezentace data a času zobrazovat v libovolném pořadí.

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ý formát parametru input . Podrobnosti o platných kódech formátování 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é indikují, že posun musí být obsažen v input, musí toto posun obsahovat záporné znaménko nebo kladné znaménko. Pokud znaménko chybí, metoda vyvolá FormatExceptionchybu .

Konkrétní symboly data a času použité v input parametru formatProvider jsou definovány, stejně jako přesný formát input , pokud format je standardní specifikátor formátu řetězec. Parametr formatProvider může být některý z následujících:

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

Pokud formatprovider ano null, CultureInfo použije se objekt odpovídající aktuální jazykové verzi.

Poznámky pro volající

Viz také

Platí pro

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

Převede rozsah znaků, který představuje datum a čas 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 DateTimeOffset ParseExact (ReadOnlySpan<char> input, ReadOnlySpan<char> format, IFormatProvider? formatProvider, System.Globalization.DateTimeStyles styles = System.Globalization.DateTimeStyles.None);

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

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

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

Parametry

input: ReadOnlySpan<Char>

Rozsah znaků, který představuje datum a čas.

format: ReadOnlySpan<Char>

Rozsah znaků, který obsahuje specifikátor formátu, který definuje očekávaný formát input.

formatProvider: IFormatProvider

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

styles: DateTimeStyles

Bitové kombinace hodnot výčtu, která označuje povolený formát input.

Návraty

DateTimeOffset

Objekt, který odpovídá datu a času obsaženému v parametru input , jak je určeno parametrem format, formatProvidera styles parametry.

Výjimky

ArgumentException

Posun je větší než 14 hodin nebo menší než-14 hodin. -or- Parametr styles obsahuje nepodporovanou hodnotu. -nebo- Parametr styles obsahuje DateTimeStyles hodnoty, které nelze použít společně.

FormatException

input je prázdné rozpětí znaků. -nebo- input neobsahuje platnou řetězcovou reprezentaci data a času. -nebo- format je prázdné rozpětí znaků. -nebo- Hodinová komponenta a designátor AM/PM nesouhlasí input .

Poznámky

Tato metoda analyzuje rozsah znaků, který představuje datum, které musí být ve formátu definovaném parametrem format . Vyžaduje také, aby <Date><Time>se prvky řetězce <Offset> vyjádření data a času zobrazovaly v pořadí určeném parametrem format. Pokud input se vzor neshoduje format FormatException, metoda vyvolá . Naproti tomu DateTimeOffset.Parse(ReadOnlySpan<Char>, IFormatProvider, DateTimeStyles) metoda parsuje řetězcovou reprezentaci data v libovolném z formátů rozpoznaných objektem zprostředkovatele DateTimeFormatInfo formátu. Parse také umožňuje <Date>, <Time>a <Offset> prvky řetězcové reprezentace data a času zobrazovat v libovolném pořadí.

Parametr format je rozsah znaků, který obsahuje specifikátor standardního formátu s jedním znakem nebo jeden nebo více specifikátorů vlastního formátu, které definují požadovaný formát parametru input . Podrobnosti o platných kódech formátování 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é indikují, že posun musí být obsažen v input, musí toto posun obsahovat záporné znaménko nebo kladné znaménko. Pokud znaménko chybí, metoda vyvolá FormatExceptionchybu .

Konkrétní symboly data a času použité v input parametru formatProvider jsou definovány, stejně jako přesný formát input , pokud format je specifikátor standardního formátu. Parametr formatProvider může být některý z následujících:

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

Pokud formatprovider ano null, CultureInfo použije se objekt odpovídající aktuální jazykové verzi.

Platí pro

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

Převede rozsah znaků obsahující řetězcovou reprezentaci data a času 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 musí přesně odpovídat jednomu ze zadaných formátů.

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

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

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

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

Parametry

input: ReadOnlySpan<Char>

Rozsah znaků, který obsahuje datum a čas pro převod.

formats: String[]

Pole specifikátorů formátu, které definují očekávané formáty input.

formatProvider: IFormatProvider

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

styles: DateTimeStyles

Bitové kombinace hodnot výčtu, která označuje povolený formát input.

Návraty

DateTimeOffset

Objekt, který odpovídá datu a času obsaženému v parametru input , jak je určeno parametrem formats, formatProvidera styles parametry.

Výjimky

ArgumentException

Posun je větší než 14 hodin nebo menší než-14 hodin. -nebo- styles obsahuje nepodporovanou hodnotu. -or- Parametr styles obsahuje DateTimeStyles hodnoty, které nelze použít společně.

FormatException

input je prázdný rozsah znaků. -nebo- input neobsahuje platnou řetězcovou reprezentaci data a času. -or- Žádný prvek formats neobsahuje platný specifikátor formátu. -nebo- Hodinová komponenta a designátor input AM/PM nesouhlasí.

Poznámky

Tato metoda analyzuje rozsah znaků představující datum, které odpovídá některému ze vzorů přiřazených k parametru formats . Pokud input neodpovídá žádnému z těchto vzorů s žádnou z variant definovaných parametrem styles , metoda vyvolá FormatException. Kromě porovnání s input více vzory formátování se toto přetížení chová stejně jako metoda DateTimeOffset.ParseExact(ReadOnlySpan<Char>, ReadOnlySpan<Char>, IFormatProvider, DateTimeStyles) .

Důležité

Objekt CultureInfo , který představuje jazykovou verzi, na základě které input se interpretuje. 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 ano null, CultureInfo použije se objekt odpovídající aktuální jazykové verzi.

`DateTimeStyles` Členské	Chování
AdjustToUniversal	Parsuje `input` a v případě potřeby ho převede na UTC. Je ekvivalentní analýze ř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í se vrácený DateTimeOffset objekt posunu 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í DateTimeOffset vrácený objekt posun (+00:00).
AllowInnerWhite	Umožňuje `input` zahrnout vnitřní prázdné místo, které `format`není určeno . Mezi komponentami data a času a v jednotlivých komponentách (s výjimkou posunu) se může zobrazit nadbytečné prázdné místo a při analýze řetězce se ignoruje.
AllowLeadingWhite	Umožňuje `input` zahrnout úvodní mezery, které nejsou zadány .`formats` Při analýze řetězce jsou ignorovány.
AllowTrailingWhite	Umožňuje `input` zahrnout koncové mezery, které nejsou zadány .`formats` Při analýze řetězce jsou ignorovány.
AllowWhiteSpaces	Umožňuje `input` zahrnout úvodní, koncové a vnitřní mezery, které nejsou specifikovány `formats`. Při analýze řetězce se ignorují všechny nadbytečné prázdné znaky, které nejsou zadané v odpovídajícím elementu `formats` .
None	Označuje, že další prázdné znaky nejsou povoleny v `input`. Prázdné místo se musí zobrazovat přesně tak, jak je uvedeno v určitém prvku `formats` shody. Toto je výchozí chování.
RoundtripKind	Nemá žádný vliv, protože DateTimeOffset struktura neobsahuje `Kind` vlastnost.

Platí pro

DateTimeOffset.ParseExact Metoda

Definice

Přetížení

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

Parametry

Návraty

Výjimky

Příklady

Poznámky

Poznámky pro volající

Viz také

Platí pro

ParseExact(String, String, IFormatProvider, DateTimeStyles)

Parametry

Návraty

Výjimky

Příklady

Poznámky

Poznámky pro volající

Viz také

Platí pro

ParseExact(String, String, IFormatProvider)

Parametry

Návraty

Výjimky

Příklady

Poznámky

Poznámky pro volající

Viz také

Platí pro

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

Parametry

Návraty

Výjimky

Poznámky

Platí pro

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

Parametry

Návraty

Výjimky

Poznámky

Platí pro

Další materiály