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ého vyjádření musí přesně odpovídat určenému formátu. Metoda vrátí hodnotu, která označuje, zda převod proběhl úspěšně.

Přetížení

TryParseExact(ReadOnlySpan<Char>, ReadOnlySpan<Char>, IFormatProvider, DateTimeStyles, DateTime)	Převede zadanou reprezentaci rozsahu 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ého vyjádření musí přesně odpovídat určenému formátu. Metoda vrátí hodnotu, která označuje, zda převod proběhl úspěšně.
TryParseExact(ReadOnlySpan<Char>, String[], IFormatProvider, DateTimeStyles, DateTime)	Převede zadaný rozsah znaků data a času na jeho DateTime ekvivalent a vrátí hodnotu, která označuje, zda byl převod ú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 jazykovou verzi a stylu. Formát řetězcového vyjádření musí přesně odpovídat určenému formátu. Metoda 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 pole formátů, informací o formátu specifickém pro jazykovou verzi a stylu. Formát řetězcové reprezentace musí přesně odpovídat alespoň jednomu ze zadaných formátů. Metoda vrátí hodnotu, která označuje, zda převod proběhl ú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 bylo začátkem éry Reiwa v JapaneseCalendar a JapaneseLunisolarCalendar. Taková změna éry ovlivní všechny aplikace, které tyto kalendáře používají. Další informace a informace o tom, jestli se to týká vašich aplikací, najdete v tématu Zpracování nové éry v japonském kalendáři v .NET. Informace o testování aplikací v systémech Windows, abyste zajistili jejich připravenost na změnu éry, najdete v tématu Příprava aplikace na změnu japonské éry. Funkce v .NET, které podporují kalendáře s více érami, a osvědčené postupy při práci s kalendáři, které podporují více ér, najdete v tématu Práce s érami.

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

Source:: DateTime.cs

Source:: DateTime.cs

Source:: DateTime.cs

Převede zadanou reprezentaci rozsahu 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ého vyjádření musí přesně odpovídat určenému formátu. Metoda vrátí hodnotu, která označuje, zda převod proběhl ú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, které se mají převést.

format: ReadOnlySpan<Char>

Požadovaný formát souboru s.

provider: IFormatProvider

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

style: DateTimeStyles

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

result: DateTime

Když tato metoda vrátí, obsahuje DateTime hodnotu odpovídající datu a času obsažené v s, pokud převod byl úspěšný, nebo DateTime.MinValue , pokud převod selhal. Převod selže, pokud s parametr nebo format je null, 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 s byl úspěšně převeden, jinak hodnota false.

Platí pro

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

Source:: DateTime.cs

Source:: DateTime.cs

Source:: DateTime.cs

Převede zadaný rozsah znaků data a času na jeho DateTime ekvivalent a vrátí hodnotu, která označuje, zda byl převod ú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 k analýze.

formats: String[]

Pole povolených formátů s.

provider: IFormatProvider

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

style: DateTimeStyles

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

result: DateTime

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

Návraty

Boolean

true pokud byl s parametr úspěšně převeden, v opačném případě hodnota false.

Platí pro

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

Source:: DateTime.cs

Source:: DateTime.cs

Source:: 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 jazykovou verzi a stylu. Formát řetězcového vyjádření musí přesně odpovídat určenému formátu. Metoda vrátí hodnotu, která označuje, zda převod proběhl ú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, který chcete převést.

format: String

Požadovaný formát souboru s.

provider: IFormatProvider

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

style: DateTimeStyles

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

result: DateTime

Návraty

Boolean

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

Výjimky

ArgumentException

styles není platná DateTimeStyles hodnota.

-nebo-

styles obsahuje neplatnou kombinaci DateTimeStyles hodnot (například a AssumeLocal AssumeUniversal).

Příklady

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

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 . Je podobný metodě s tím rozdílem DateTime.ParseExact(String, String, IFormatProvider, DateTimeStyles)TryParseExact(String, String, IFormatProvider, DateTimeStyles, DateTime) , že metoda nevyvolá výjimku, pokud se převod nezdaří.

Parametr s obsahuje datum a čas k analýze a musí být ve formátu definovaném parametrem format . Pokud se v ssystému nacházejí prvky data, času a časového pásma, musí se zobrazit také v pořadí určeném parametrem format. Pokud format definuje datum bez prvku času a operace parse bude úspěšná, výsledná DateTime hodnota bude o půlnoci (00:00:00). Pokud format definuje čas bez prvku date a operace parse bude úspěšná, výsledná DateTime hodnota má ve výchozím nastavení datum DateTime.Now.Datenebo má datum DateTime.MinValue.Date if styles zahrnuje DateTimeStyles.NoCurrentDateDefault příznak. Parametr style určuje, zda s parametr 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 DateTime objektu je DateTimeKind.Unspecified. Toto chování lze změnit pomocí příznaku DateTimeStyles.AssumeLocal , který vrací DateTime hodnotu, jejíž Kind vlastnost je DateTimeKind.Local, nebo pomocí DateTimeStyles.AssumeUniversal příznaků a DateTimeStyles.AdjustToUniversal , které vrátí DateTime hodnotu, 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 Kind vlastnost vráceného DateTime objektu se nastaví 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í Kind vlastnost 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 tabulky Řetězce vlastního formátu data a času nebo z jednoho standardního specifikátoru formátu, který identifikuje předdefinovaný vzor z tabulky Řetězce standardního formátu data a času .

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

Poznámka

Místo toho, aby s se pro úspěšnou operaci analýzy vyžadovala shoda s jedním formátem, můžete volat metodu DateTime.TryParseExact(String, String[], IFormatProvider, DateTimeStyles, DateTime) a zadat více povolených formátů. Díky tomu je pravděpodobnější, že operace parsování bude úspěšná.

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

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

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

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

Člen DateTimeStyles	Description
AdjustToUniversal	`s` Analyzuje ho a v případě potřeby převede na UTC. Pokud `s` obsahuje posun časového pásma nebo pokud `s` neobsahuje žádné informace o časovém pásmu, ale `styles` zahrnuje DateTimeStyles.AssumeLocal příznak, metoda analyzuje řetězec, zavolá k ToUniversalTime převodu vrácené DateTime hodnoty na UTC a nastaví Kind vlastnost na DateTimeKind.Utc. Pokud `s` označuje, že představuje utc, nebo pokud `s` neobsahuje informace o časovém pásmu, ale `styles` zahrnuje DateTimeStyles.AssumeUniversal příznak, metoda analyzuje řetězec, neprovádí žádný převod časového pásma na vrácenou DateTime hodnotu a nastaví Kind vlastnost na DateTimeKind.Utc. Ve všech ostatních případech nemá příznak žádný vliv.
AllowInnerWhite	Určuje, že se mezi libovolným prvkem data nebo času mohou objevit prázdné znaky, které nejsou definovány `format` nástrojem .
AllowLeadingWhite	Určuje, že se na začátku `s`může zobrazit prázdný znak, který není definován nástrojem `format` .
AllowTrailingWhite	Určuje, že se na konci objektu mohou zobrazit prázdné znaky, které `format` nejsou definovány `s`nástrojem .
AllowWhiteSpaces	Určuje, že `s` může obsahovat počáteční, vnitřní a koncové prázdné znaky, které nejsou definovány nástrojem `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í DateTimeStyles.AdjustToUniversal příznak přítomen, Kind vlastnost vrácené DateTime hodnoty je nastavena na DateTimeKind.Localhodnotu .
AssumeUniversal	Určuje, že pokud `s` chybí informace o časovém pásmu, předpokládá se, že představují UTC. DateTimeStyles.AdjustToUniversal Pokud není příznak přítomen, metoda převede vrácenou DateTime hodnotu z UTC na místní čas a nastaví její Kind vlastnost na DateTimeKind.Local.
NoCurrentDateDefault	Pokud `s` obsahuje čas bez informací o datu, nastaví se datum návratové hodnoty na `DateTime.MinValue.Date`hodnotu .
None	Parametr `s` se parsuje pomocí výchozích hodnot. Nejsou povoleny žádné jiné prázdné znaky než ty, které jsou v `format` souboru. Pokud `s` chybí komponenta data, datum vrácené DateTime hodnoty se nastaví na 1.1.0001. Pokud `s` neobsahuje žádné informace o časovém pásmu Kind , je vlastnost vráceného DateTime objektu nastavená na DateTimeKind.Unspecifiedhodnotu . Pokud se informace o časovém pásmu nacházejí v `s`souboru , čas se převede na místní čas a Kind vlastnost vráceného DateTime objektu je nastavena na DateTimeKind.Localhodnotu .
RoundtripKind	U řetězců, které obsahují informace o časovém pásmu, se pokusí zabránit převodu na hodnotu s její Kind vlastností nastavenou DateTime na DateTimeKind.Localhodnotu . Tento příznak zabraňuje především převodu času UTC na místní čas.

Poznámky pro volající

V rozhraní .NET Framework 4 metoda vrátífalse, TryParseExact pokud řetězec, který má být analyzován, obsahuje komponentu hodiny a označení do hodiny a do hodiny odpoledne, které nejsou v dohodě. V rozhraní .NET Framework 3.5 a starších verzích je označení do hodiny a odpoledne ignorováno.

Viz také

Platí pro

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

Source:: DateTime.cs

Source:: DateTime.cs

Source:: 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 alespoň jednomu ze zadaných formátů. Metoda vrátí hodnotu, která označuje, zda převod proběhl ú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 k převedení.

formats: String[]

Pole povolených formátů s.

provider: IFormatProvider

Objekt, který poskytuje informace o formátu specifickém pro sjazykovou verzi.

style: DateTimeStyles

Bitová kombinace hodnot výčtu, která označuje povolený formát .s Typická hodnota, která se má zadat, je None.

result: DateTime

Když tato metoda vrátí, obsahuje DateTime hodnotu odpovídající datu a času obsažené v s, pokud převod byl úspěšný, nebo DateTime.MinValue , pokud převod selhal. Převod se nezdaří, pokud s je nebo formats je null, s nebo je prvek elementu formats prázdný řetězec, nebo pokud formát s není přesně takový, jak určuje alespoň jeden ze vzorů formátu v formatssouboru . Tento parametr se předává neinicializovaný.

Návraty

Boolean

true pokud byl s parametr úspěšně převeden, v opačném případě hodnota false.

Výjimky

ArgumentException

styles není platná DateTimeStyles hodnota.

-nebo-

styles obsahuje neplatnou kombinaci DateTimeStyles hodnot (například a AssumeLocal AssumeUniversal).

Příklady

Následující příklad používá metodu DateTime.TryParseExact(String, String, IFormatProvider, DateTimeStyles, DateTime) k zajištění, že řetězec v několika možných formátech 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 jako metoda DateTime.ParseExact(String, String[], IFormatProvider, DateTimeStyles) s tím rozdílem, že TryParseExact metoda nevyvolá výjimku, pokud se převod nezdaří.

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

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

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

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

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

Člen DateTimeStyles	Description
AdjustToUniversal	`s` Analyzuje ho a v případě potřeby převede na UTC. Pokud `s` obsahuje posun časového pásma nebo pokud `s` neobsahuje žádné informace o časovém pásmu, ale `styles` zahrnuje DateTimeStyles.AssumeLocal příznak, metoda analyzuje řetězec, zavolá k ToUniversalTime převodu vrácené DateTime hodnoty na UTC a nastaví Kind vlastnost na DateTimeKind.Utc. Pokud `s` označuje, že představuje utc, nebo pokud `s` neobsahuje informace o časovém pásmu, ale `styles` zahrnuje DateTimeStyles.AssumeUniversal příznak, metoda analyzuje řetězec, neprovádí žádný převod časového pásma na vrácenou DateTime hodnotu a nastaví Kind vlastnost na DateTimeKind.Utc. Ve všech ostatních případech nemá příznak žádný vliv.
AllowInnerWhite	Určuje, že se mezi libovolným prvkem data nebo času mohou objevit prázdné znaky, které nejsou definovány `format` nástrojem .
AllowLeadingWhite	Určuje, že se na začátku `s`může zobrazit prázdný znak, který není definován nástrojem `format` .
AllowTrailingWhite	Určuje, že se na konci objektu mohou zobrazit prázdné znaky, které `format` nejsou definovány `s`nástrojem .
AllowWhiteSpaces	Určuje, že `s` může obsahovat počáteční, vnitřní a koncové prázdné znaky, které nejsou definovány nástrojem `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í DateTimeStyles.AdjustToUniversal příznak přítomen, Kind vlastnost vrácené DateTime hodnoty je nastavena na DateTimeKind.Localhodnotu .
AssumeUniversal	Určuje, že pokud `s` chybí informace o časovém pásmu, předpokládá se, že představují UTC. DateTimeStyles.AdjustToUniversal Pokud není příznak přítomen, metoda převede vrácenou DateTime hodnotu z UTC na místní čas a nastaví její Kind vlastnost na DateTimeKind.Local.
NoCurrentDateDefault	Pokud `s` obsahuje čas bez informací o datu, nastaví se datum návratové hodnoty na `DateTime.MinValue.Date`hodnotu .
None	Parametr `s` se parsuje pomocí výchozích hodnot. Nejsou povoleny žádné jiné prázdné znaky než ty, které jsou v `format` souboru. Pokud `s` chybí komponenta data, datum vrácené DateTime hodnoty se nastaví na 1.1.0001. Pokud `s` neobsahuje žádné informace o časovém pásmu Kind , je vlastnost vráceného DateTime objektu nastavená na DateTimeKind.Unspecifiedhodnotu . Pokud se informace o časovém pásmu nacházejí v `s`souboru , čas se převede na místní čas a Kind vlastnost vráceného DateTime objektu je nastavena na DateTimeKind.Localhodnotu .
RoundtripKind	U řetězců, které obsahují informace o časovém pásmu, se pokusí zabránit převodu na hodnotu s její Kind vlastností nastavenou DateTime na DateTimeKind.Localhodnotu . Tento příznak zabraňuje především převodu času UTC na místní čas.

Poznámky pro volající

Viz také

Platí pro

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

Váš názor

Další materiály