DateTimeOffset.ParseExact 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
ParseExact(String, String[], IFormatProvider, DateTimeStyles)	Převede zadanou řetězcovou reprezentaci data a času na ekvivalent DateTimeOffset pomocí zadaných formátů, informací o formátu specifickém pro jazykovou verzi a stylu. Formát řetězcové reprezentace se musí přesně shodovat s jedním ze zadaných formátů.
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é reprezentace se musí přesně shodovat se zadaným formátem.
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é reprezentace se musí přesně shodovat se zadaným formátem.
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 se musí přesně shodovat s jedním ze zadaných formátů.

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

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ých formátů, informací o formátu specifickém pro jazykovou verzi a stylu. Formát řetězcové reprezentace se musí přesně shodovat s jedním ze zadaných formátů.

public:
 static 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 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 inputformátování specifické pro jazykovou verzi .

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 formats platný specifikátor formátu.

nebo

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

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 DateTimeOffset.ParseExact(String, String[], IFormatProvider, DateTimeStyles) 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 = 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) parsuje řetězcovou reprezentaci data, které odpovídá libovolnému 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 styles parametrem, metoda vyvolá FormatException. Kromě porovnání s input více vzory formátování 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 parametru input . Při zavolání input metody se musí shodovat s jedním z těchto vzorů. 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í, metoda vyvolá FormatExceptionchybu .

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 formats vyžaduje, aby input 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ý formát 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 zadány `format`. Mezi komponentami data a času a v jednotlivých komponentách (s výjimkou posunu) se může zobrazit nadbytečné prázdné znaky a při analýze řetězce se ignoruje.
AllowLeadingWhite	Umožňuje `input` zahrnout úvodní mezery nezadané parametrem `formats`. Při analýze řetězce se tyto hodnoty ignorují.
AllowTrailingWhite	Umožňuje `input` zahrnout koncové mezery, které nejsou zadány `formats`. 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 `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` 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 vyvolá ParseExact metoda 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 návrh AM/PM ignoruje.

Viz také

Platí pro

ParseExact(String, String, IFormatProvider, DateTimeStyles)

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

format: String

Specifikátor formátu, který definuje očekávaný 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.

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 návrh input AM/PM nesouhlasí.

Příklady

Následující příklad používá metodu DateTimeOffset.ParseExact(String, String, IFormatProvider, DateTimeStyles) 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;
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í 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), 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) analyzuje řetězcovou reprezentaci data, která musí být ve formátu definovaném parametrem format . Vyžaduje také, aby <se prvky datum>, <čas> a <posun> řetězcové reprezentace data a času zobrazovaly v pořadí určeném parametrem 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 DateTimeFormatInfo zprostředkovatele formátu. Parse také umožňuje <, aby se prvky datum>, <čas> a <posun> řetězcové reprezentace data a času zobrazovaly 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ý vzor parametru 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í, metoda vyvolá FormatExceptionchybu .

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ý formát , inputpokud format je standardní specifikátor 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 analyzují řetězce bez explicitní posunové komponenty a podporuje převod UTC v rámci operace analýzy. Všechny členy výčtu DateTimeStyles jsou podporovány s výjimkou NoCurrentDateDefault. Následující tabulka uvádí účinek každého podporovaného člena.

`DateTimeStyles` člen	Chování
AdjustToUniversal	Parsuje `input` a v případě potřeby ho převede na UTC. Je ekvivalentní parsování řetězce a 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í hodnota.
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 zadány `format`. Mezi komponentami data a času a v jednotlivých komponentách 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é

Platí pro

ParseExact(String, String, IFormatProvider)

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 a informací o formátu specifickém pro jazykovou verzi. Formát řetězcové reprezentace se musí přesně shodovat se zadaným formátem.

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

format: String

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

formatProvider: IFormatProvider

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

Návraty

DateTimeOffset

Objekt, který je ekvivalentní k datu a času, který je obsažen v input zadaném format a 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 input AM/PM nesouhlasí.

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í normě ISO 8601. Jak ukazuje výstup z příkladu, řetězce s počátečními nebo koncovými mezerami se nepodaří úspěšně analyzovat, stejně jako řetězce s elementy 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 <se prvky datum>, <čas> a <posun> řetězcové reprezentace 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 DateTimeFormatInfo zprostředkovatele formátu. Parse také umožňuje <, aby se prvky datum>, <čas> a <posun> řetězcové reprezentace data a času zobrazovaly 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 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í, metoda vyvolá FormatExceptionchybu .

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

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

Poznámky pro volající

Viz také

Platí pro

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

Zdroj:: DateTimeOffset.cs

Zdroj:: DateTimeOffset.cs

Zdroj:: DateTimeOffset.cs

Zdroj:: DateTimeOffset.cs

Zdroj:: DateTimeOffset.cs

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

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. -or- 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. -or- format je prázdné rozpětí znaků. -nebo- Hodinová komponenta a návrh input AM/PM nesouhlasí.

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 <se prvky datum>, <čas> a <posun> řetězcové reprezentace data a času zobrazovaly v pořadí určeném parametrem format. Pokud input neodpovídá format vzoru, metoda vyvolá FormatException. Naproti tomu DateTimeOffset.Parse(ReadOnlySpan<Char>, IFormatProvider, DateTimeStyles) metoda parsuje řetězcovou reprezentaci data v libovolném z formátů rozpoznaných objektem DateTimeFormatInfo zprostředkovatele formátu. Parse také umožňuje <, aby se prvky datum>, <čas> a <posun> řetězcové reprezentace data a času zobrazovaly 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 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í, metoda vyvolá FormatExceptionchybu .

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

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

Platí pro

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

Zdroj:: DateTimeOffset.cs

Zdroj:: DateTimeOffset.cs

Zdroj:: DateTimeOffset.cs

Zdroj:: DateTimeOffset.cs

Zdroj:: DateTimeOffset.cs

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 se musí přesně shodovat s jedním 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 inputformátování specifické pro jazykovou verzi .

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 zahrnuje nepodporovanou hodnotu. -or- 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. -or- Žádný prvek formats neobsahuje platný specifikátor formátu. -nebo- Hodinová komponenta a návrh input AM/PM nesouhlasí.

Poznámky

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

Důležité

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 zadány `format`. Mezi komponentami data a času a v jednotlivých komponentách (s výjimkou posunu) se může zobrazit nadbytečné prázdné znaky a při analýze řetězce se ignoruje.
AllowLeadingWhite	Umožňuje `input` zahrnout úvodní mezery nezadané parametrem `formats`. Při analýze řetězce se tyto hodnoty ignorují.
AllowTrailingWhite	Umožňuje `input` zahrnout koncové mezery, které nejsou zadány `formats`. 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 `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` shody. Toto je výchozí chování.
RoundtripKind	Nemá žádný vliv, protože DateTimeOffset struktura neobsahuje `Kind` vlastnost.

Platí pro

Váš názor

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

Sdílet prostřednictvím

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

Váš názor