DateTime.TryParseExact Metoda

Reference

Definice

Obor názvů:: System

Sestavení:: System.Runtime.dll

Sestavení:: netstandard.dll

Sestavení:: mscorlib.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 DateTime ekvivalent. Formát řetězcové reprezentace musí přesně odpovídat zadanému formátu. Metoda vrátí hodnotu, která označuje, zda převod byl úspěšný.

Přetížení

TryParseExact(ReadOnlySpan<Char>, ReadOnlySpan<Char>, IFormatProvider, DateTimeStyles, DateTime)	Převede zadanou reprezentaci data a času na jeho DateTime ekvivalent 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. Metoda vrátí hodnotu, která označuje, zda převod byl úspěšný.
TryParseExact(ReadOnlySpan<Char>, String[], IFormatProvider, DateTimeStyles, DateTime)	Převede zadaný rozsah znaku data a času na jeho DateTime ekvivalent a vrátí hodnotu, která označuje, zda převod proběhl úspěšně.
TryParseExact(String, String, IFormatProvider, DateTimeStyles, DateTime)	Převede zadanou řetězcovou reprezentaci data a času na jeho DateTime ekvivalent pomocí zadaného formátu, informací o formátu specifickém pro jazyk a styl. Formát řetězcové reprezentace se musí přesně shodovat se zadaným formátem. Metoda vrátí hodnotu, která označuje, zda převod byl úspěšný.
TryParseExact(String, String[], IFormatProvider, DateTimeStyles, DateTime)	Převede zadanou řetězcovou reprezentaci data a času na jeho DateTime ekvivalent pomocí zadaného pole formátů, informací o formátu specifickém pro jazykovou verzi a stylu. Formát řetězcové reprezentace musí přesně odpovídat jednomu ze zadaných formátů. Metoda vrátí hodnotu, která označuje, zda převod byl úspěšný.

Poznámky

Důležitý

Éry v japonských kalendářích jsou založeny na vládě císaře, a proto se očekává, že se změní. Například 1. května 2019 označí začátek období Reiwa v JapaneseCalendar a JapaneseLunisolarCalendar. Taková změna éry ovlivňuje všechny aplikace, které tyto kalendáře používají. Další informace a určení, zda jsou vaše aplikace ovlivněny, najdete v tématu Zpracování nové éry v japonském kalendáři v .NET. Informace o testování aplikací v systémech Windows za účelem zajištění připravenosti na změnu éry najdete v tématu Příprava aplikace na japonskou změnu éry. Funkce v .NET, které podporují kalendáře s více obdobími a osvědčené postupy při práci s kalendáři, které podporují více období, najdete v tématu Práce s obdobími.

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

Zdroj:: DateTime.cs

Zdroj:: DateTime.cs

Zdroj:: DateTime.cs

Převede zadanou reprezentaci data a času na jeho DateTime ekvivalent 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. Metoda vrátí hodnotu, která označuje, zda převod byl úspěšný.

public:
 static bool TryParseExact(ReadOnlySpan<char> s, ReadOnlySpan<char> format, IFormatProvider ^ provider, System::Globalization::DateTimeStyles style, [Runtime::InteropServices::Out] DateTime % result);

public static bool TryParseExact (ReadOnlySpan<char> s, ReadOnlySpan<char> format, IFormatProvider? provider, System.Globalization.DateTimeStyles style, out DateTime result);

public static bool TryParseExact (ReadOnlySpan<char> s, ReadOnlySpan<char> format, IFormatProvider provider, System.Globalization.DateTimeStyles style, out DateTime result);

static member TryParseExact : ReadOnlySpan<char> * ReadOnlySpan<char> * IFormatProvider * System.Globalization.DateTimeStyles * DateTime -> bool

Public Shared Function TryParseExact (s As ReadOnlySpan(Of Char), format As ReadOnlySpan(Of Char), provider As IFormatProvider, style As DateTimeStyles, ByRef result As DateTime) As Boolean

Parametry

s: ReadOnlySpan<Char>

Rozsah obsahující znaky představující datum a čas pro převod.

format: ReadOnlySpan<Char>

Požadovaný formát s.

provider: IFormatProvider

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

style: DateTimeStyles

Bitová kombinace jedné nebo více hodnot výčtu, která označuje povolený formát s.

result: DateTime

Pokud tato metoda vrátí, obsahuje DateTime hodnotu ekvivalentní datu a času obsažené v s, pokud převod proběhl úspěšně nebo DateTime.MinValue pokud převod selhal. Převod selže, pokud je parametr s nebo formatnull, je prázdný řetězec nebo neobsahuje datum a čas, které odpovídají vzoru zadanému v format. Tento parametr se předává neinicializovaný.

Návraty

Boolean

true, pokud byl s úspěšně převeden; jinak false.

Platí pro

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

Zdroj:: DateTime.cs

Zdroj:: DateTime.cs

Zdroj:: DateTime.cs

Převede zadaný rozsah znaku data a času na jeho DateTime ekvivalent a vrátí hodnotu, která označuje, zda převod proběhl úspěšně.

public:
 static bool TryParseExact(ReadOnlySpan<char> s, cli::array <System::String ^> ^ formats, IFormatProvider ^ provider, System::Globalization::DateTimeStyles style, [Runtime::InteropServices::Out] DateTime % result);

public static bool TryParseExact (ReadOnlySpan<char> s, string?[]? formats, IFormatProvider? provider, System.Globalization.DateTimeStyles style, out DateTime result);

public static bool TryParseExact (ReadOnlySpan<char> s, string[] formats, IFormatProvider provider, System.Globalization.DateTimeStyles style, out DateTime result);

static member TryParseExact : ReadOnlySpan<char> * string[] * IFormatProvider * System.Globalization.DateTimeStyles * DateTime -> bool

Public Shared Function TryParseExact (s As ReadOnlySpan(Of Char), formats As String(), provider As IFormatProvider, style As DateTimeStyles, ByRef result As DateTime) As Boolean

Parametry

s: ReadOnlySpan<Char>

Rozsah obsahující řetězec, který se má analyzovat.

formats: String[]

Pole povolených formátů s.

provider: IFormatProvider

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

style: DateTimeStyles

Bitová kombinace hodnot výčtu, která definuje, jak interpretovat parsované datum ve vztahu k aktuálnímu časovému pásmu nebo aktuálnímu datu. Typická hodnota pro zadání je None.

result: DateTime

Pokud tato metoda vrátí, obsahuje DateTime hodnotu ekvivalentní datu a času obsažené v s, pokud převod proběhl úspěšně nebo DateTime.MinValue pokud převod selhal. Převod selže, pokud je parametr snull, je Emptynebo neobsahuje platnou řetězcovou reprezentaci data a času. Tento parametr se předává neinicializovaný.

Návraty

Boolean

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

Platí pro

TryParseExact(String, String, IFormatProvider, DateTimeStyles, DateTime)

Zdroj:: DateTime.cs

Zdroj:: DateTime.cs

Zdroj:: DateTime.cs

Převede zadanou řetězcovou reprezentaci data a času na jeho DateTime ekvivalent pomocí zadaného formátu, informací o formátu specifickém pro jazyk a styl. Formát řetězcové reprezentace se musí přesně shodovat se zadaným formátem. Metoda vrátí hodnotu, která označuje, zda převod byl úspěšný.

public:
 static bool TryParseExact(System::String ^ s, System::String ^ format, IFormatProvider ^ provider, System::Globalization::DateTimeStyles style, [Runtime::InteropServices::Out] DateTime % result);

public static bool TryParseExact (string s, string format, IFormatProvider provider, System.Globalization.DateTimeStyles style, out DateTime result);

public static bool TryParseExact (string? s, string? format, IFormatProvider? provider, System.Globalization.DateTimeStyles style, out DateTime result);

static member TryParseExact : string * string * IFormatProvider * System.Globalization.DateTimeStyles * DateTime -> bool

Public Shared Function TryParseExact (s As String, format As String, provider As IFormatProvider, style As DateTimeStyles, ByRef result As DateTime) As Boolean

Parametry

s: String

Řetězec obsahující datum a čas pro převod.

format: String

Požadovaný formát s.

provider: IFormatProvider

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

style: DateTimeStyles

Bitová kombinace jedné nebo více hodnot výčtu, která označuje povolený formát s.

result: DateTime

Návraty

Boolean

true, pokud byl s úspěšně převeden; jinak false.

Výjimky

ArgumentException

style není platná hodnota DateTimeStyles.

-nebo-

style obsahuje neplatnou kombinaci hodnot DateTimeStyles (například AssumeLocal i AssumeUniversal).

Příklady

Následující příklad ukazuje DateTime.TryParseExact(String, String, IFormatProvider, DateTimeStyles, DateTime) metoda. Všimněte si, že řetězec 5/01/2009 8:30 AM nelze úspěšně analyzovat, pokud se parametr styles rovná DateTimeStyles.None, protože počáteční mezery nejsou povoleny format. Kromě toho řetězec "5/01/2009 09:00" nelze úspěšně analyzovat s format "MM/dd/yyyyhh:mm", protože řetězec kalendářního data před číslem měsíce s úvodní nulou, protože format vyžaduje.

using System;
using System.Globalization;

public class Example
{
   public static void Main()
   {
      CultureInfo enUS = new CultureInfo("en-US");
      string dateString;
      DateTime dateValue;

      // Parse date with no style flags.
      dateString = " 5/01/2009 8:30 AM";
      if (DateTime.TryParseExact(dateString, "g", enUS,
                                 DateTimeStyles.None, out dateValue))
         Console.WriteLine("Converted '{0}' to {1} ({2}).", dateString, dateValue,
                           dateValue.Kind);
      else
         Console.WriteLine("'{0}' is not in an acceptable format.", dateString);

      // Allow a leading space in the date string.
      if (DateTime.TryParseExact(dateString, "g", enUS,
                                 DateTimeStyles.AllowLeadingWhite, out dateValue))
         Console.WriteLine("Converted '{0}' to {1} ({2}).", dateString, dateValue,
                           dateValue.Kind);
      else
         Console.WriteLine("'{0}' is not in an acceptable format.", dateString);

      // Use custom formats with M and MM.
      dateString = "5/01/2009 09:00";
      if (DateTime.TryParseExact(dateString, "M/dd/yyyy hh:mm", enUS,
                                 DateTimeStyles.None, out dateValue))
         Console.WriteLine("Converted '{0}' to {1} ({2}).", dateString, dateValue,
                           dateValue.Kind);
      else
         Console.WriteLine("'{0}' is not in an acceptable format.", dateString);

      // Allow a leading space in the date string.
      if (DateTime.TryParseExact(dateString, "MM/dd/yyyy hh:mm", enUS,
                              DateTimeStyles.None, out dateValue))
         Console.WriteLine("Converted '{0}' to {1} ({2}).", dateString, dateValue,
                           dateValue.Kind);
      else
         Console.WriteLine("'{0}' is not in an acceptable format.", dateString);

      // Parse a string with time zone information.
      dateString = "05/01/2009 01:30:42 PM -05:00";
      if (DateTime.TryParseExact(dateString, "MM/dd/yyyy hh:mm:ss tt zzz", enUS,
                              DateTimeStyles.None, out dateValue))
         Console.WriteLine("Converted '{0}' to {1} ({2}).", dateString, dateValue,
                           dateValue.Kind);
      else
         Console.WriteLine("'{0}' is not in an acceptable format.", dateString);

      // Allow a leading space in the date string.
      if (DateTime.TryParseExact(dateString, "MM/dd/yyyy hh:mm:ss tt zzz", enUS,
                              DateTimeStyles.AdjustToUniversal, out dateValue))
         Console.WriteLine("Converted '{0}' to {1} ({2}).", dateString, dateValue,
                           dateValue.Kind);
      else
         Console.WriteLine("'{0}' is not in an acceptable format.", dateString);

      // Parse a string representing UTC.
      dateString = "2008-06-11T16:11:20.0904778Z";
      if (DateTime.TryParseExact(dateString, "o", CultureInfo.InvariantCulture,
                                     DateTimeStyles.None, out dateValue))
         Console.WriteLine("Converted '{0}' to {1} ({2}).", dateString, dateValue,
                           dateValue.Kind);
      else
         Console.WriteLine("'{0}' is not in an acceptable format.", dateString);

      if (DateTime.TryParseExact(dateString, "o", CultureInfo.InvariantCulture,
                                 DateTimeStyles.RoundtripKind, out dateValue))
         Console.WriteLine("Converted '{0}' to {1} ({2}).", dateString, dateValue,
                           dateValue.Kind);
      else
         Console.WriteLine("'{0}' is not in an acceptable format.", dateString);
   }
}
// The example displays the following output:
//    ' 5/01/2009 8:30 AM' is not in an acceptable format.
//    Converted ' 5/01/2009 8:30 AM' to 5/1/2009 8:30:00 AM (Unspecified).
//    Converted '5/01/2009 09:00' to 5/1/2009 9:00:00 AM (Unspecified).
//    '5/01/2009 09:00' is not in an acceptable format.
//    Converted '05/01/2009 01:30:42 PM -05:00' to 5/1/2009 11:30:42 AM (Local).
//    Converted '05/01/2009 01:30:42 PM -05:00' to 5/1/2009 6:30:42 PM (Utc).
//    Converted '2008-06-11T16:11:20.0904778Z' to 6/11/2008 9:11:20 AM (Local).
//    Converted '2008-06-11T16:11:20.0904778Z' to 6/11/2008 4:11:20 PM (Utc).

open System
open System.Globalization

[<EntryPoint>]
let main _ =
    let enUS = CultureInfo "en-US"

    // Parse date with no style flags.
    let dateString = " 5/01/2009 8:30 AM"
    match DateTime.TryParseExact(dateString, "g", enUS, DateTimeStyles.None) with
    | true, dateValue ->
        printfn $"Converted '{dateString}' to {dateValue} ({dateValue.Kind})."              
    | _ ->
        printfn $"'{dateString}' is not in an acceptable format."

    // Allow a leading space in the date string.
    match DateTime.TryParseExact(dateString, "g", enUS, DateTimeStyles.AllowLeadingWhite) with
    | true, dateValue ->
        printfn $"Converted '{dateString}' to {dateValue} ({dateValue.Kind})."
    | _ ->
        printfn $"'{dateString}' is not in an acceptable format."

    // Use custom formats with M and MM.
    let dateString = "5/01/2009 09:00"
    match DateTime.TryParseExact(dateString, "M/dd/yyyy hh:mm", enUS, DateTimeStyles.None) with
    | true, dateValue ->
        printfn $"Converted '{dateString}' to {dateValue} ({dateValue.Kind})."
    | _ ->
        printfn $"'{dateString}' is not in an acceptable format."

    // Allow a leading space in the date string.
    match DateTime.TryParseExact(dateString, "MM/dd/yyyy hh:mm", enUS, DateTimeStyles.None) with
    | true, dateValue ->
        printfn $"Converted '{dateString}' to {dateValue} ({dateValue.Kind})."
    | _ ->
        printfn $"'{dateString}' is not in an acceptable format."

    // Parse a string with time zone information.
    let dateString = "05/01/2009 01:30:42 PM -05:00"
    match DateTime.TryParseExact(dateString, "MM/dd/yyyy hh:mm:ss tt zzz", enUS, DateTimeStyles.None) with
    | true, dateValue ->
        printfn $"Converted '{dateString}' to {dateValue} ({dateValue.Kind})."
    | _ ->
        printfn $"'{dateString}' is not in an acceptable format."

    // Allow a leading space in the date string.
    match DateTime.TryParseExact(dateString, "MM/dd/yyyy hh:mm:ss tt zzz", enUS, DateTimeStyles.AdjustToUniversal) with
    | true, dateValue ->
        printfn $"Converted '{dateString}' to {dateValue} ({dateValue.Kind})."
    | _ ->
        printfn $"'{dateString}' is not in an acceptable format."

    // Parse a string representing UTC.
    let dateString = "2008-06-11T16:11:20.0904778Z"
    match DateTime.TryParseExact(dateString, "o", CultureInfo.InvariantCulture, DateTimeStyles.None) with
    | true, dateValue ->
        printfn $"Converted '{dateString}' to {dateValue} ({dateValue.Kind})."
    | _ ->
        printfn $"'{dateString}' is not in an acceptable format."

    match DateTime.TryParseExact(dateString, "o", CultureInfo.InvariantCulture, DateTimeStyles.RoundtripKind) with
    | true, dateValue ->
        printfn $"Converted '{dateString}' to {dateValue} ({dateValue.Kind})."
    | _ ->
        printfn $"'{dateString}' is not in an acceptable format."

    0

    // The example displays the following output:
    //    ' 5/01/2009 8:30 AM' is not in an acceptable format.
    //    Converted ' 5/01/2009 8:30 AM' to 5/1/2009 8:30:00 AM (Unspecified).
    //    Converted '5/01/2009 09:00' to 5/1/2009 9:00:00 AM (Unspecified).
    //    '5/01/2009 09:00' is not in an acceptable format.
    //    Converted '05/01/2009 01:30:42 PM -05:00' to 5/1/2009 11:30:42 AM (Local).
    //    Converted '05/01/2009 01:30:42 PM -05:00' to 5/1/2009 6:30:42 PM (Utc).
    //    Converted '2008-06-11T16:11:20.0904778Z' to 6/11/2008 9:11:20 AM (Local).
    //    Converted '2008-06-11T16:11:20.0904778Z' to 6/11/2008 4:11:20 PM (Utc).

Imports System.Globalization

Public Module Example
   Public Sub Main()
      Dim enUS As New CultureInfo("en-US") 
      Dim dateString As String
      Dim dateValue As Date
      
      ' Parse date with no style flags.
      dateString = " 5/01/2009 8:30 AM"
      If Date.TryParseExact(dateString, "g", enUS, _
                            DateTimeStyles.None, dateValue) Then
         Console.WriteLine("Converted '{0}' to {1} ({2}).", dateString, dateValue, _
                           dateValue.Kind)
      Else
         Console.WriteLine("'{0}' is not in an acceptable format.", dateString)
      End If
      ' Allow a leading space in the date string.
      If Date.TryParseExact(dateString, "g", enUS, _
                            DateTimeStyles.AllowLeadingWhite, dateValue) Then
         Console.WriteLine("Converted '{0}' to {1} ({2}).", dateString, dateValue, _
                           dateValue.Kind)
      Else
         Console.WriteLine("'{0}' is not in an acceptable format.", dateString)
      End If
      
      ' Use custom formats with M and MM.
      dateString = "5/01/2009 09:00"
      If Date.TryParseExact(dateString, "M/dd/yyyy hh:mm", enUS, _
                            DateTimeStyles.None, dateValue) Then
         Console.WriteLine("Converted '{0}' to {1} ({2}).", dateString, dateValue, _
                           dateValue.Kind)
      Else
         Console.WriteLine("'{0}' is not in an acceptable format.", dateString)
      End If
      ' Allow a leading space in the date string.
      If Date.TryParseExact(dateString, "MM/dd/yyyy hh:mm", enUS, _
                            DateTimeStyles.None, dateValue) Then
         Console.WriteLine("Converted '{0}' to {1} ({2}).", dateString, dateValue, _
                           dateValue.Kind)
      Else
         Console.WriteLine("'{0}' is not in an acceptable format.", dateString)
      End If

      ' Parse a string with time zone information.
      dateString = "05/01/2009 01:30:42 PM -05:00" 
      If Date.TryParseExact(dateString, "MM/dd/yyyy hh:mm:ss tt zzz", enUS, _
                            DateTimeStyles.None, dateValue) Then
         Console.WriteLine("Converted '{0}' to {1} ({2}).", dateString, dateValue, _
                           dateValue.Kind)
      Else
         Console.WriteLine("'{0}' is not in an acceptable format.", dateString)
      End If
      ' Allow a leading space in the date string.
      If Date.TryParseExact(dateString, "MM/dd/yyyy hh:mm:ss tt zzz", enUS, _
                            DateTimeStyles.AdjustToUniversal, dateValue) Then
         Console.WriteLine("Converted '{0}' to {1} ({2}).", dateString, dateValue, _
                           dateValue.Kind)
      Else
         Console.WriteLine("'{0}' is not in an acceptable format.", dateString)
      End If
           
      ' Parse a string representing UTC.
      dateString = "2008-06-11T16:11:20.0904778Z"
      If Date.TryParseExact(dateString, "o", CultureInfo.InvariantCulture, _
                                     DateTimeStyles.None, dateValue) Then
         Console.WriteLine("Converted '{0}' to {1} ({2}).", dateString, dateValue, _
                           dateValue.Kind)
      Else
         Console.WriteLine("'{0}' is not in an acceptable format.", dateString)
      End If
      
      If Date.TryParseExact(dateString, "o", CultureInfo.InvariantCulture, _
                            DateTimeStyles.RoundtripKind, dateValue) Then
         Console.WriteLine("Converted '{0}' to {1} ({2}).", dateString, dateValue, _
                           dateValue.Kind)
      Else
         Console.WriteLine("'{0}' is not in an acceptable format.", dateString)
      End If
   End Sub
End Module
' The example displays the following output:
'    ' 5/01/2009 8:30 AM' is not in an acceptable format.
'    Converted ' 5/01/2009 8:30 AM' to 5/1/2009 8:30:00 AM (Unspecified).
'    Converted '5/01/2009 09:00' to 5/1/2009 9:00:00 AM (Unspecified).
'    '5/01/2009 09:00' is not in an acceptable format.
'    Converted '05/01/2009 01:30:42 PM -05:00' to 5/1/2009 11:30:42 AM (Local).
'    Converted '05/01/2009 01:30:42 PM -05:00' to 5/1/2009 6:30:42 PM (Utc).
'    Converted '2008-06-11T16:11:20.0904778Z' to 6/11/2008 9:11:20 AM (Local).
'    Converted '2008-06-11T16:11:20.0904778Z' to 6/11/2008 4:11:20 PM (Utc).

Poznámky

Metoda DateTime.TryParseExact(String, String, IFormatProvider, DateTimeStyles, DateTime) parsuje řetězcovou reprezentaci data, která musí být ve formátu definovaném parametrem format. Podobá se DateTime.ParseExact(String, String, IFormatProvider, DateTimeStyles) metodě s tím rozdílem, že TryParseExact(String, String, IFormatProvider, DateTimeStyles, DateTime) metoda nevyvolá výjimku, pokud převod selže.

Parametr s obsahuje datum a čas k analýze a musí být ve formátu definovaném parametrem format. Pokud jsou prvky data, času a časového pásma přítomny v s, musí se zobrazit také v pořadí určeném format. Pokud format definuje datum bez časového prvku a operace analýzy proběhne úspěšně, výsledná hodnota DateTime má čas půlnoci (00:00:00). Pokud format definuje čas bez prvku data a operace analýzy proběhne úspěšně, výsledná hodnota DateTime má ve výchozím nastavení datum DateTime.Now.Datenebo má datum DateTime.MinValue.Date, pokud styles obsahuje příznak DateTimeStyles.NoCurrentDateDefault. Parametr style určuje, zda parametr s může obsahovat počáteční, vnitřní nebo koncové prázdné znaky.

Pokud s neobsahuje žádné informace o časovém pásmu, Kind vlastnost vráceného objektu DateTime je DateTimeKind.Unspecified. Toto chování lze změnit pomocí příznaku DateTimeStyles.AssumeLocal, který vrací hodnotu DateTime, jejíž Kind vlastnost je DateTimeKind.Local, nebo pomocí DateTimeStyles.AssumeUniversal a DateTimeStyles.AdjustToUniversal příznaky, která vrací hodnotu DateTime, jejíž Kind vlastnost je DateTimeKind.Utc. Pokud s obsahuje informace o časovém pásmu, čas se v případě potřeby převede na místní čas a vlastnost Kind vráceného objektu DateTime je nastavena na DateTimeKind.Local. Toto chování lze změnit pomocí příznaku DateTimeStyles.RoundtripKind, který nepřevedí koordinovaný univerzální čas (UTC) na místní čas a nastaví vlastnost Kind na DateTimeKind.Utc.

Parametr format obsahuje vzor, který odpovídá očekávanému formátu parametru s. Vzor v parametru format se skládá z jednoho nebo více specifikátorů vlastního formátu z vlastních řetězců formátu data a času tabulky nebo jednoho standardního specifikátoru formátu, který identifikuje předdefinovaný vzor z standardních řetězců data a času formátovací tabulky.

Pokud v vzoru vlastního formátu nepoužíváte oddělovače data nebo času, použijte neutrální jazykovou verzi pro parametr provider a nejširší formu specifikátoru vlastního formátu. Pokud například chcete zadat hodiny ve vzoru, zadejte širší tvar "HH" místo užšího tvaru "H".

Poznámka

Místo toho, aby s odpovídaly jednomu formátu, aby operace analýzy byla úspěšná, můžete volat metodu DateTime.TryParseExact(String, String[], IFormatProvider, DateTimeStyles, DateTime) a zadat více povolených formátů. Díky tomu bude operace analýzy s větší pravděpodobností úspěšná.

Konkrétní symboly a řetězce data a času (například názvy dnů v týdnu v určitém jazyce) používané v s jsou definovány parametrem provider, stejně jako přesný formát s, pokud je format standardním specifikátorem formátu řetězce. Parametr provider může být následující:

Objekt CultureInfo, který představuje jazykovou verzi použitou k interpretaci s. Objekt DateTimeFormatInfo vrácený vlastností DateTimeFormat definuje symboly a formátování v s.
Objekt DateTimeFormatInfo, který definuje formát dat data a času.
Vlastní implementace IFormatProvider, jejíž GetFormat metoda vrací objekt CultureInfo nebo objekt DateTimeFormatInfo, který poskytuje informace o formátování.

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

Parametr styles obsahuje jeden nebo více členů DateTimeStyles výčtu, které určují, zda a kde prázdné znaky, které nejsou definovány format, se mohou objevit v s a řídí přesné chování operace analýzy. Následující tabulka popisuje, jak každý člen DateTimeStyles výčtu ovlivňuje operaci TryParseExact(String, String, IFormatProvider, DateTimeStyles, DateTime) metody.

DateTimeStyles – člen	Popis
AdjustToUniversal	Parsuje `s` a v případě potřeby ho převede na UTC. Pokud `s` zahrnuje posun časového pásma nebo pokud `s` neobsahuje žádné informace o časovém pásmu, ale `styles` zahrnuje příznak DateTimeStyles.AssumeLocal, metoda analyzuje řetězec, volá ToUniversalTime k převodu vrácené hodnoty DateTime na UTC a nastaví vlastnost Kind na DateTimeKind.Utc. Pokud `s` označuje, že představuje utc, nebo pokud `s` neobsahuje informace o časovém pásmu, ale `styles` zahrnuje příznak DateTimeStyles.AssumeUniversal, metoda analyzuje řetězec, neprovádí převod časového pásma na vrácenou hodnotu DateTime a nastaví vlastnost Kind na DateTimeKind.Utc. Ve všech ostatních případech nemá příznak žádný vliv.
AllowInnerWhite	Určuje, že prázdné znaky, které nejsou definovány `format` mohou být zobrazeny mezi libovolným prvkem data nebo času.
AllowLeadingWhite	Určuje, že prázdné znaky, které nejsou definovány `format` mohou být zobrazeny na začátku `s`.
AllowTrailingWhite	Určuje, že prázdné znaky, které nejsou definovány `format` mohou být zobrazeny na konci `s`.
AllowWhiteSpaces	Určuje, že `s` může obsahovat úvodní, vnitřní a koncové prázdné znaky, které nejsou definovány `format`.
AssumeLocal	Určuje, že pokud `s` chybí informace o časovém pásmu, předpokládá se, že představuje místní čas. Pokud není k dispozici příznak DateTimeStyles.AdjustToUniversal, je vlastnost Kind vrácené hodnoty DateTime nastavena na DateTimeKind.Local.
AssumeUniversal	Určuje, že pokud `s` neobsahují informace o časovém pásmu, předpokládá se, že představuje UTC. Pokud není k dispozici příznak DateTimeStyles.AdjustToUniversal, metoda převede vrácenou hodnotu DateTime z UTC na místní čas a nastaví jeho Kind vlastnost na DateTimeKind.Local.
NoCurrentDateDefault	Pokud `s` obsahuje čas bez informací o datu, je datum návratové hodnoty nastaveno na `DateTime.MinValue.Date`.
None	Parametr `s` se analyzuje pomocí výchozích hodnot. Nejsou povoleny žádné prázdné znaky, které jsou přítomné v `format`. Pokud `s` chybí součást data, je datum vrácené hodnoty DateTime nastaveno na 1. 1. 1. 0001. Pokud `s` neobsahuje žádné informace o časovém pásmu, je vlastnost Kind vráceného objektu DateTime nastavena na DateTimeKind.Unspecified. Pokud se informace o časovém pásmu nacházejí v `s`, čas se převede na místní čas a Kind vlastnost vráceného objektu DateTime je nastavena na DateTimeKind.Local.
RoundtripKind	U řetězců obsahujících informace o časovém pásmu se pokusí zabránit převodu na hodnotu DateTime s vlastností Kind nastavenou na DateTimeKind.Local. Tento příznak primárně zabraňuje převodu časů UTC na místní časy.

Poznámky pro volající

V rozhraní .NET Framework 4 vrátí metoda TryParseExactfalse, 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

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

Zdroj:: DateTime.cs

Zdroj:: DateTime.cs

Zdroj:: DateTime.cs

Převede zadanou řetězcovou reprezentaci data a času na jeho DateTime ekvivalent pomocí zadaného pole formátů, informací o formátu specifickém pro jazykovou verzi a stylu. Formát řetězcové reprezentace musí přesně odpovídat jednomu ze zadaných formátů. Metoda vrátí hodnotu, která označuje, zda převod byl úspěšný.

public:
 static bool TryParseExact(System::String ^ s, cli::array <System::String ^> ^ formats, IFormatProvider ^ provider, System::Globalization::DateTimeStyles style, [Runtime::InteropServices::Out] DateTime % result);

public static bool TryParseExact (string s, string[] formats, IFormatProvider provider, System.Globalization.DateTimeStyles style, out DateTime result);

public static bool TryParseExact (string? s, string?[]? formats, IFormatProvider? provider, System.Globalization.DateTimeStyles style, out DateTime result);

static member TryParseExact : string * string[] * IFormatProvider * System.Globalization.DateTimeStyles * DateTime -> bool

Public Shared Function TryParseExact (s As String, formats As String(), provider As IFormatProvider, style As DateTimeStyles, ByRef result As DateTime) As Boolean

Parametry

s: String

Řetězec, který obsahuje datum a čas pro převod.

formats: String[]

Pole povolených formátů s.

provider: IFormatProvider

Objekt, který poskytuje informace o formátu specifické pro jazykovou verzi o s.

style: DateTimeStyles

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

result: DateTime

Pokud tato metoda vrátí, obsahuje DateTime hodnotu ekvivalentní datu a času obsažené v s, pokud převod proběhl úspěšně nebo DateTime.MinValue pokud převod selhal. Převod selže, pokud je s nebo formatsnull, s nebo prvek formats je prázdný řetězec nebo formát s není přesně určený alespoň jedním ze vzorů formátu v formats. Tento parametr se předává neinicializovaný.

Návraty

Boolean

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

Výjimky

ArgumentException

style není platná hodnota DateTimeStyles.

-nebo-

style obsahuje neplatnou kombinaci hodnot DateTimeStyles (například AssumeLocal i AssumeUniversal).

Příklady

Následující příklad používá DateTime.TryParseExact(String, String, IFormatProvider, DateTimeStyles, DateTime) metoda k zajištění, že řetězec v řadě možných formátů lze úspěšně analyzovat .

using System;
using System.Globalization;

public class Example
{
   public static void Main()
   {
      string[] formats= {"M/d/yyyy h:mm:ss tt", "M/d/yyyy h:mm tt",
                         "MM/dd/yyyy hh:mm:ss", "M/d/yyyy h:mm:ss",
                         "M/d/yyyy hh:mm tt", "M/d/yyyy hh tt",
                         "M/d/yyyy h:mm", "M/d/yyyy h:mm",
                         "MM/dd/yyyy hh:mm", "M/dd/yyyy hh:mm"};
      string[] dateStrings = {"5/1/2009 6:32 PM", "05/01/2009 6:32:05 PM",
                              "5/1/2009 6:32:00", "05/01/2009 06:32",
                              "05/01/2009 06:32:00 PM", "05/01/2009 06:32:00"};
      DateTime dateValue;

      foreach (string dateString in dateStrings)
      {
         if (DateTime.TryParseExact(dateString, formats,
                                    new CultureInfo("en-US"),
                                    DateTimeStyles.None,
                                    out dateValue))
            Console.WriteLine("Converted '{0}' to {1}.", dateString, dateValue);
         else
            Console.WriteLine("Unable to convert '{0}' to a date.", dateString);
      }
   }
}
// The example displays the following output:
//       Converted '5/1/2009 6:32 PM' to 5/1/2009 6:32:00 PM.
//       Converted '05/01/2009 6:32:05 PM' to 5/1/2009 6:32:05 PM.
//       Converted '5/1/2009 6:32:00' to 5/1/2009 6:32:00 AM.
//       Converted '05/01/2009 06:32' to 5/1/2009 6:32:00 AM.
//       Converted '05/01/2009 06:32:00 PM' to 5/1/2009 6:32:00 PM.
//       Converted '05/01/2009 06:32:00' to 5/1/2009 6:32:00 AM.

open System
open System.Globalization

let formats= 
    [| "M/d/yyyy h:mm:ss tt"; "M/d/yyyy h:mm tt"
       "MM/dd/yyyy hh:mm:ss"; "M/d/yyyy h:mm:ss"
       "M/d/yyyy hh:mm tt"; "M/d/yyyy hh tt"
       "M/d/yyyy h:mm"; "M/d/yyyy h:mm"
       "MM/dd/yyyy hh:mm"; "M/dd/yyyy hh:mm" |]

let dateStrings = 
    [ "5/1/2009 6:32 PM"; "05/01/2009 6:32:05 PM"
      "5/1/2009 6:32:00"; "05/01/2009 06:32"
      "05/01/2009 06:32:00 PM"; "05/01/2009 06:32:00" ]

for dateString in dateStrings do
    match DateTime.TryParseExact(dateString, formats, CultureInfo "en-US", DateTimeStyles.None) with
    | true, dateValue ->
        printfn $"Converted '{dateString}' to {dateValue}."
    | _ ->
        printfn $"Unable to convert '{dateString}' to a date."


// The example displays the following output:
//       Converted '5/1/2009 6:32 PM' to 5/1/2009 6:32:00 PM.
//       Converted '05/01/2009 6:32:05 PM' to 5/1/2009 6:32:05 PM.
//       Converted '5/1/2009 6:32:00' to 5/1/2009 6:32:00 AM.
//       Converted '05/01/2009 06:32' to 5/1/2009 6:32:00 AM.
//       Converted '05/01/2009 06:32:00 PM' to 5/1/2009 6:32:00 PM.
//       Converted '05/01/2009 06:32:00' to 5/1/2009 6:32:00 AM.

Imports System.Globalization

Public Module Example
   Public Sub Main()
      Dim formats() As String = {"M/d/yyyy h:mm:ss tt", "M/d/yyyy h:mm tt", _
                                 "MM/dd/yyyy hh:mm:ss", "M/d/yyyy h:mm:ss", _
                                 "M/d/yyyy hh:mm tt", "M/d/yyyy hh tt", _
                                 "M/d/yyyy h:mm", "M/d/yyyy h:mm", _
                                 "MM/dd/yyyy hh:mm", "M/dd/yyyy hh:mm"}
      Dim dateStrings() As String = {"5/1/2009 6:32 PM", "05/01/2009 6:32:05 PM", _
                                     "5/1/2009 6:32:00", "05/01/2009 06:32", _
                                     "05/01/2009 06:32:00 PM", "05/01/2009 06:32:00"} 

      Dim dateValue As DateTime
      
      For Each dateString As String In dateStrings
         If Date.TryParseExact(dateString, formats, _
                               New CultureInfo("en-US"), _
                               DateTimeStyles.None, _
                               dateValue) Then
            Console.WriteLine("Converted '{0}' to {1}.", dateString, dateValue)
         Else
            Console.WriteLine("Unable to convert '{0}' to a date.", dateString)
         End If                                               
      Next
   End Sub   
End Module
' The example displays the following output:
'       Converted '5/1/2009 6:32 PM' to 5/1/2009 6:32:00 PM.
'       Converted '05/01/2009 6:32:05 PM' to 5/1/2009 6:32:05 PM.
'       Converted '5/1/2009 6:32:00' to 5/1/2009 6:32:00 AM.
'       Converted '05/01/2009 06:32' to 5/1/2009 6:32:00 AM.
'       Converted '05/01/2009 06:32:00 PM' to 5/1/2009 6:32:00 PM.
'       Converted '05/01/2009 06:32:00' to 5/1/2009 6:32:00 AM.

Poznámky

Metoda DateTime.TryParseExact(String, String[], IFormatProvider, DateTimeStyles, DateTime) parsuje řetězcovou reprezentaci data, které odpovídá libovolnému vzoru přiřazeného k parametru formats. Je to jako DateTime.ParseExact(String, String[], IFormatProvider, DateTimeStyles) metoda, s výjimkou TryParseExact metoda nevyvolá výjimku, pokud převod selže.

Parametr s obsahuje datum a čas, které se mají analyzovat. Pokud parametr s obsahuje pouze čas a žádné datum, použije se aktuální datum, pokud parametr style neobsahuje příznak DateTimeStyles.NoCurrentDateDefault, v takovém případě se použije výchozí datum (DateTime.Date.MinValue). Pokud parametr s obsahuje pouze datum a žádný čas, použije se půlnoc (00:00:00). Parametr style také určuje, zda parametr s může obsahovat počáteční, vnitřní nebo koncové prázdné znaky jiné než ty povolené jedním z formátovacích řetězců v formats.

Parametr formats obsahuje pole vzorů, z nichž jeden s musí přesně odpovídat, pokud je operace analýzy úspěšná. Vzory v parametru formats se skládají z jednoho nebo více specifikátorů vlastního formátu z tabulky Vlastní řetězce formátu data a času tabulky nebo jednoho standardního specifikátoru formátu, který identifikuje předdefinovaný vzor z standardních řetězců data a času tabulky.

Objekt CultureInfo, který představuje jazykovou verzi použitou k interpretaci s. Objekt DateTimeFormatInfo vrácený vlastností DateTimeFormat definuje symboly a formátování v s.
Objekt DateTimeFormatInfo, který definuje formát dat data a času.
Vlastní implementace IFormatProvider, jejíž GetFormat metoda vrací objekt CultureInfo nebo objekt DateTimeFormatInfo, který poskytuje informace o formátování.

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

Parametr styles obsahuje jeden nebo více členů DateTimeStyles výčtu, které určují, zda a kde prázdné znaky, které nejsou definovány format, se mohou objevit v s a řídí přesné chování operace analýzy. Následující tabulka popisuje, jak každý člen DateTimeStyles výčtu ovlivňuje operaci TryParseExact(String, String[], IFormatProvider, DateTimeStyles, DateTime) metody.

DateTimeStyles – člen	Popis
AdjustToUniversal	Parsuje `s` a v případě potřeby ho převede na UTC. Pokud `s` zahrnuje posun časového pásma nebo pokud `s` neobsahuje žádné informace o časovém pásmu, ale `styles` zahrnuje příznak DateTimeStyles.AssumeLocal, metoda analyzuje řetězec, volá ToUniversalTime k převodu vrácené hodnoty DateTime na UTC a nastaví vlastnost Kind na DateTimeKind.Utc. Pokud `s` označuje, že představuje utc, nebo pokud `s` neobsahuje informace o časovém pásmu, ale `styles` zahrnuje příznak DateTimeStyles.AssumeUniversal, metoda analyzuje řetězec, neprovádí převod časového pásma na vrácenou hodnotu DateTime a nastaví vlastnost Kind na DateTimeKind.Utc. Ve všech ostatních případech nemá příznak žádný vliv.
AllowInnerWhite	Určuje, že prázdné znaky, které nejsou definovány `format` mohou být zobrazeny mezi libovolným prvkem data nebo času.
AllowLeadingWhite	Určuje, že prázdné znaky, které nejsou definovány `format` mohou být zobrazeny na začátku `s`.
AllowTrailingWhite	Určuje, že prázdné znaky, které nejsou definovány `format` mohou být zobrazeny na konci `s`.
AllowWhiteSpaces	Určuje, že `s` může obsahovat úvodní, vnitřní a koncové prázdné znaky, které nejsou definovány `format`.
AssumeLocal	Určuje, že pokud `s` chybí informace o časovém pásmu, předpokládá se, že představuje místní čas. Pokud není k dispozici příznak DateTimeStyles.AdjustToUniversal, je vlastnost Kind vrácené hodnoty DateTime nastavena na DateTimeKind.Local.
AssumeUniversal	Určuje, že pokud `s` neobsahují informace o časovém pásmu, předpokládá se, že představuje UTC. Pokud není k dispozici příznak DateTimeStyles.AdjustToUniversal, metoda převede vrácenou hodnotu DateTime z UTC na místní čas a nastaví jeho Kind vlastnost na DateTimeKind.Local.
NoCurrentDateDefault	Pokud `s` obsahuje čas bez informací o datu, je datum návratové hodnoty nastaveno na `DateTime.MinValue.Date`.
None	Parametr `s` se analyzuje pomocí výchozích hodnot. Nejsou povoleny žádné prázdné znaky, které jsou přítomné v `format`. Pokud `s` chybí součást data, je datum vrácené hodnoty DateTime nastaveno na 1. 1. 1. 0001. Pokud `s` neobsahuje žádné informace o časovém pásmu, je vlastnost Kind vráceného objektu DateTime nastavena na DateTimeKind.Unspecified. Pokud se informace o časovém pásmu nacházejí v `s`, čas se převede na místní čas a Kind vlastnost vráceného objektu DateTime je nastavena na DateTimeKind.Local.
RoundtripKind	U řetězců obsahujících informace o časovém pásmu se pokusí zabránit převodu na hodnotu DateTime s vlastností Kind nastavenou na DateTimeKind.Local. Tento příznak primárně zabraňuje převodu časů UTC na místní časy.

Poznámky pro volající

Viz také

Platí pro

Sdílet prostřednictvím

DateTime.TryParseExact Metoda

Definice

Přetížení

Poznámky

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

Parametry

Návraty

Platí pro

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

Parametry

Návraty

Platí pro

TryParseExact(String, String, IFormatProvider, DateTimeStyles, DateTime)

Parametry

Návraty

Výjimky

Příklady

Poznámky

Poznámky pro volající

Viz také

Platí pro

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

Parametry

Návraty

Výjimky

Příklady

Poznámky

Poznámky pro volající

Viz také

Platí pro

Další materiály