DateTime.TryParse Metoda

Definice

Obor názvů:: System

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

Sestavení:: System.Runtime.dll

Sestavení:: netstandard.dll

Sestavení:: mscorlib.dll, System.Runtime.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 a vrátí hodnotu, která označuje, zda převod proběhl úspěšně.

Přetížení

Name	Description
TryParse(ReadOnlySpan<Char>, DateTime)	Převede zadané rozsahy znaků data a času na jeho DateTime ekvivalent a vrátí hodnotu, která označuje, zda převod proběhl úspěšně.
TryParse(String, DateTime)	Převede zadanou řetězcovou reprezentaci data a času na jeho DateTime ekvivalent a vrátí hodnotu, která označuje, zda převod proběhl úspěšně.
TryParse(ReadOnlySpan<Char>, IFormatProvider, DateTime)	Pokusí se analyzovat rozsah znaků do hodnoty.
TryParse(String, IFormatProvider, DateTime)	Pokusí se analyzovat řetězec do hodnoty.
TryParse(String, IFormatProvider, DateTimeStyles, DateTime)	Převede zadanou řetězcovou reprezentaci data a času na ekvivalent DateTime pomocí zadaných informací o formátu specifickém pro jazykovou verzi a stylu formátování a vrátí hodnotu, která určuje, zda převod proběhl úspěšně.
TryParse(ReadOnlySpan<Char>, IFormatProvider, DateTimeStyles, DateTime)	Převede reprezentaci rozsahu data a času na jeho DateTime ekvivalent pomocí zadaných informací o formátu specifické pro jazykovou verzi a stylu formátování a vrátí hodnotu, která označuje, zda převod proběhl úspěšně.

Poznámky

Important

É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čilo 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 ovlivněny vaše aplikace, naleznete 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 v éře najdete v tématu Příprava aplikace na změnu japonské é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.

TryParse(ReadOnlySpan<Char>, DateTime)

Zdroj:: DateTime.cs

Zdroj:: DateTime.cs

Zdroj:: DateTime.cs

Zdroj:: DateTime.cs

Zdroj:: DateTime.cs

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

public:
 static bool TryParse(ReadOnlySpan<char> s, [Runtime::InteropServices::Out] DateTime % result);

public static bool TryParse(ReadOnlySpan<char> s, out DateTime result);

static member TryParse : ReadOnlySpan<char> * DateTime -> bool

Public Shared Function TryParse (s As ReadOnlySpan(Of Char), ByRef result As DateTime) As Boolean

Parametry

s: ReadOnlySpan<Char>

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

result: DateTime

Pokud tato metoda vrátí, obsahuje DateTime hodnotu ekvivalentní datu a času obsažené v s, pokud převod byl úspěšný, nebo DateTime.MinValue v případě selhání převodu. Převod selže, pokud s je nullparametr , je prázdný řetězec (""), nebo neobsahuje platnou řetězcovou reprezentaci data a času. Tento parametr se předává neinicializovaný.

Návraty

Boolean

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

Platí pro

TryParse(String, DateTime)

Zdroj:: DateTime.cs

Zdroj:: DateTime.cs

Zdroj:: DateTime.cs

Zdroj:: DateTime.cs

Zdroj:: DateTime.cs

Převede zadanou řetězcovou reprezentaci data a času na jeho DateTime ekvivalent a vrátí hodnotu, která označuje, zda převod proběhl úspěšně.

public:
 static bool TryParse(System::String ^ s, [Runtime::InteropServices::Out] DateTime % result);

public static bool TryParse(string s, out DateTime result);

public static bool TryParse(string? s, out DateTime result);

static member TryParse : string * DateTime -> bool

Public Shared Function TryParse (s As String, ByRef result As DateTime) As Boolean

Parametry

s: String

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

result: DateTime

Návraty

Boolean

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

Příklady

Následující příklad předá metodě několik řetězců DateTime.TryParse(String, DateTime) data a času.

using System;
using System.Globalization;

public class Example
{
   public static void Main()
   {
      string[] dateStrings = {"05/01/2009 14:57:32.8", "2009-05-01 14:57:32.8",
                              "2009-05-01T14:57:32.8375298-04:00", "5/01/2008",
                              "5/01/2008 14:57:32.80 -07:00",
                              "1 May 2008 2:57:32.8 PM", "16-05-2009 1:00:32 PM",
                              "Fri, 15 May 2009 20:10:57 GMT" };
      DateTime dateValue;

      Console.WriteLine("Attempting to parse strings using {0} culture.",
                        CultureInfo.CurrentCulture.Name);
      foreach (string dateString in dateStrings)
      {
         if (DateTime.TryParse(dateString, out dateValue))
            Console.WriteLine("  Converted '{0}' to {1} ({2}).", dateString,
                              dateValue, dateValue.Kind);
         else
            Console.WriteLine("  Unable to parse '{0}'.", dateString);
      }
   }
}
// The example displays output like the following:
//    Attempting to parse strings using en-US culture.
//      Converted '05/01/2009 14:57:32.8' to 5/1/2009 2:57:32 PM (Unspecified).
//      Converted '2009-05-01 14:57:32.8' to 5/1/2009 2:57:32 PM (Unspecified).
//      Converted '2009-05-01T14:57:32.8375298-04:00' to 5/1/2009 11:57:32 AM (Local).
//
//      Converted '5/01/2008' to 5/1/2008 12:00:00 AM (Unspecified).
//      Converted '5/01/2008 14:57:32.80 -07:00' to 5/1/2008 2:57:32 PM (Local).
//      Converted '1 May 2008 2:57:32.8 PM' to 5/1/2008 2:57:32 PM (Unspecified).
//      Unable to parse '16-05-2009 1:00:32 PM'.
//      Converted 'Fri, 15 May 2009 20:10:57 GMT' to 5/15/2009 1:10:57 PM (Local).

open System
open System.Globalization

let dateStrings = 
    [ "05/01/2009 14:57:32.8"; "2009-05-01 14:57:32.8"
      "2009-05-01T14:57:32.8375298-04:00"; "5/01/2008"
      "5/01/2008 14:57:32.80 -07:00"
      "1 May 2008 2:57:32.8 PM"; "16-05-2009 1:00:32 PM"
      "Fri, 15 May 2009 20:10:57 GMT" ]

printfn $"Attempting to parse strings using {CultureInfo.CurrentCulture.Name} culture."
for dateString in dateStrings do
    match DateTime.TryParse dateString with
    | true, dateValue ->
        printfn $"  Converted '{dateString}' to {dateValue} ({dateValue.Kind})."
    | _ ->
        printfn $"  Unable to parse '{dateString}'."


// The example displays output like the following:
//    Attempting to parse strings using en-US culture.
//      Converted '05/01/2009 14:57:32.8' to 5/1/2009 2:57:32 PM (Unspecified).
//      Converted '2009-05-01 14:57:32.8' to 5/1/2009 2:57:32 PM (Unspecified).
//      Converted '2009-05-01T14:57:32.8375298-04:00' to 5/1/2009 11:57:32 AM (Local).
//      Converted '5/01/2008' to 5/1/2008 12:00:00 AM (Unspecified).
//      Converted '5/01/2008 14:57:32.80 -07:00' to 5/1/2008 2:57:32 PM (Local).
//      Converted '1 May 2008 2:57:32.8 PM' to 5/1/2008 2:57:32 PM (Unspecified).
//      Unable to parse '16-05-2009 1:00:32 PM'.
//      Converted 'Fri, 15 May 2009 20:10:57 GMT' to 5/15/2009 1:10:57 PM (Local).

Imports System.Globalization

Public Module Example
   Public Sub Main()
      Dim dateStrings() As String = {"05/01/2009 14:57:32.8", "2009-05-01 14:57:32.8",
                                     "2009-05-01T14:57:32.8375298-04:00", "5/01/2008",
                                     "5/01/2008 14:57:32.80 -07:00",
                                     "1 May 2008 2:57:32.8 PM", "16-05-2009 1:00:32 PM",
                                     "Fri, 15 May 2009 20:10:57 GMT"}
      Dim dateValue As Date
      
      Console.WriteLine("Attempting to parse strings using {0} culture.", _
                        CultureInfo.CurrentCulture.Name)
      For Each dateString As String In dateStrings
         If Date.TryParse(dateString, dateValue) Then
            Console.WriteLine("  Converted '{0}' to {1} ({2}).", dateString, _
                              dateValue, dateValue.Kind)
         Else
            Console.WriteLine("  Unable to parse '{0}'.", dateString)
         End If
      Next
   End Sub
End Module
' The example displays output like the following:
'    Attempting to parse strings using en-US culture.
'      Converted '05/01/2009 14:57:32.8' to 5/1/2009 2:57:32 PM (Unspecified).
'      Converted '2009-05-01 14:57:32.8' to 5/1/2009 2:57:32 PM (Unspecified).
'      Converted '2009-05-01T14:57:32.8375298-04:00' to 5/1/2009 11:57:32 AM (Local).
'
'      Converted '5/01/2008' to 5/1/2008 12:00:00 AM (Unspecified).
'      Converted '5/01/2008 14:57:32.80 -07:00' to 5/1/2008 2:57:32 PM (Local).
'      Converted '1 May 2008 2:57:32.8 PM' to 5/1/2008 2:57:32 PM (Unspecified).
'      Unable to parse '16-05-2009 1:00:32 PM'.
'      Converted 'Fri, 15 May 2009 20:10:57 GMT' to 5/15/2009 1:10:57 PM (Local).

Poznámky

Metoda DateTime.TryParse(String, DateTime) je podobná DateTime.Parse(String) metodě, s tím rozdílem, že TryParse(String, DateTime) metoda nevyvolá výjimku, pokud převod selže.

Řetězec s se analyzuje pomocí informací o formátování v aktuálním DateTimeFormatInfo objektu, který je poskytován implicitně aktuální jazykovou verzí.

Tato metoda se pokusí ignorovat nerozpoznaná data, pokud je to možné, a vyplní chybějící informace o měsíci, dni a roce aktuálním datem. Pokud s obsahuje pouze datum a žádný čas, tato metoda předpokládá, že čas je 12:00 půlnoc. Pokud s obsahuje součást data se dvěma číslicemi roku, převede se v aktuálním kalendáři aktuální jazykové verze na rok na základě hodnoty Calendar.TwoDigitYearMax vlastnosti. Všechny počáteční, vnitřní nebo koncové prázdné znaky s se ignorují. Datum a čas lze ohraničit dvojicí počátečních a koncových znaků MŘÍŽKA ('#', U+0023), a na konci může být ukončen jedním nebo více znaky NUL (U+0000).

DateTime.TryParse(String, DateTime) Protože metoda se pokusí analyzovat řetězcovou reprezentaci data a času pomocí pravidel formátování aktuální jazykové verze, pokus o parsování konkrétního řetězce v různých jazykových verzích může buď selhat nebo vrátit různé výsledky. Pokud se konkrétní formát data a času analyzuje v různých národních prostředích, použijte DateTime.TryParse(String, IFormatProvider, DateTimeStyles, DateTime) metodu nebo jedno z přetížení TryParseExact metody a zadejte specifikátor formátu.

Pokud s je řetězcové vyjádření přestupného dne v přestupném roce v aktuálním kalendáři, metoda úspěšně parsuje s. Pokud s je řetězcové vyjádření přestupného dne v neskočném roce v aktuálním kalendáři aktuální jazykové verze, operace analýzy selže a metoda vrátí false.

Pokud s neobsahuje žádné informace o časovém pásmu, obsahuje result hodnotu, DateTime jejíž Kind vlastnost jeDateTimeKind.Unspecified, když metoda vrátí. Pokud řetězec, který se má analyzovat, obsahuje informace o časovém pásmu, obsahuje result hodnotu, DateTime jejíž Kind vlastnost jeDateTimeKind.Local, když metoda vrátí.

Poznámky pro volající

Formátování je ovlivněno vlastnostmi aktuálního DateTimeFormatInfo objektu, které jsou ve výchozím nastavení odvozeny z položky Místní a Jazykové možnosti v Ovládacích panelech. Metoda TryParse může neočekávaně selhat a vrátit False , pokud jsou aktuální DateSeparator a TimeSeparator vlastnosti nastaveny na stejnou hodnotu.

Viz také

Parse
CultureInfo
DateTimeFormatInfo
Analýza řetězců data a času v rozhraní .NET Framework
Řetězce standardního formátu data a času
Řetězce vlastního formátu data a času
Ukázka : rozhraní .NET Core WinForms (C#)
ukázka : .NET Core WinForms Formatting Utility (Visual Basic)

Platí pro

TryParse(ReadOnlySpan<Char>, IFormatProvider, DateTime)

Zdroj:: DateTime.cs

Zdroj:: DateTime.cs

Zdroj:: DateTime.cs

Zdroj:: DateTime.cs

Zdroj:: DateTime.cs

Pokusí se analyzovat rozsah znaků do hodnoty.

public:
 static bool TryParse(ReadOnlySpan<char> s, IFormatProvider ^ provider, [Runtime::InteropServices::Out] DateTime % result) = ISpanParsable<DateTime>::TryParse;

public static bool TryParse(ReadOnlySpan<char> s, IFormatProvider? provider, out DateTime result);

static member TryParse : ReadOnlySpan<char> * IFormatProvider * DateTime -> bool

Public Shared Function TryParse (s As ReadOnlySpan(Of Char), provider As IFormatProvider, ByRef result As DateTime) As Boolean

Parametry

s: ReadOnlySpan<Char>

Rozsah znaků, které se mají analyzovat.

provider: IFormatProvider

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

result: DateTime

Pokud tato metoda vrátí, obsahuje výsledek úspěšné analýzy s, nebo nedefinovanou hodnotu při selhání.

Návraty

Boolean

true pokud s byl úspěšně analyzován; jinak , false.

Platí pro

TryParse(String, IFormatProvider, DateTime)

Zdroj:: DateTime.cs

Zdroj:: DateTime.cs

Zdroj:: DateTime.cs

Zdroj:: DateTime.cs

Zdroj:: DateTime.cs

Pokusí se analyzovat řetězec do hodnoty.

public:
 static bool TryParse(System::String ^ s, IFormatProvider ^ provider, [Runtime::InteropServices::Out] DateTime % result) = IParsable<DateTime>::TryParse;

public static bool TryParse(string? s, IFormatProvider? provider, out DateTime result);

static member TryParse : string * IFormatProvider * DateTime -> bool

Public Shared Function TryParse (s As String, provider As IFormatProvider, ByRef result As DateTime) As Boolean

Parametry

s: String

Řetězec, který se má analyzovat.

provider: IFormatProvider

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

result: DateTime

Pokud tato metoda vrátí, obsahuje výsledek úspěšné analýzy s nebo nedefinovanou hodnotu při selhání.

Návraty

Boolean

true pokud s byl úspěšně analyzován; jinak , false.

Platí pro

TryParse(String, IFormatProvider, DateTimeStyles, DateTime)

Zdroj:: DateTime.cs

Zdroj:: DateTime.cs

Zdroj:: DateTime.cs

Zdroj:: DateTime.cs

Zdroj:: DateTime.cs

Převede zadanou řetězcovou reprezentaci data a času na ekvivalent DateTime pomocí zadaných informací o formátu specifickém pro jazykovou verzi a stylu formátování a vrátí hodnotu, která určuje, zda převod proběhl úspěšně.

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

public static bool TryParse(string s, IFormatProvider provider, System.Globalization.DateTimeStyles styles, out DateTime result);

public static bool TryParse(string? s, IFormatProvider? provider, System.Globalization.DateTimeStyles styles, out DateTime result);

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

Public Shared Function TryParse (s As String, provider As IFormatProvider, styles As DateTimeStyles, ByRef result As DateTime) As Boolean

Parametry

s: String

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

provider: IFormatProvider

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

styles: 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, kterou je třeba zadat, je None.

result: DateTime

Návraty

Boolean

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

Výjimky

ArgumentException

styles není platná DateTimeStyles hodnota.

nebo

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

NotSupportedException

provider je neutrální jazyková verze a nelze ji použít v operaci analýzy.

Příklady

Následující příklad znázorňuje metodu DateTime.TryParse(String, IFormatProvider, DateTimeStyles, DateTime) .

using System;
using System.Globalization;

public class Example
{
   public static void Main()
   {
      string dateString;
      CultureInfo culture;
      DateTimeStyles styles;
      DateTime dateResult;

      // Parse a date and time with no styles.
      dateString = "03/01/2009 10:00 AM";
      culture = CultureInfo.CreateSpecificCulture("en-US");
      styles = DateTimeStyles.None;
      if (DateTime.TryParse(dateString, culture, styles, out dateResult))
         Console.WriteLine("{0} converted to {1} {2}.",
                           dateString, dateResult, dateResult.Kind);
      else
         Console.WriteLine("Unable to convert {0} to a date and time.",
                           dateString);

      // Parse the same date and time with the AssumeLocal style.
      styles = DateTimeStyles.AssumeLocal;
      if (DateTime.TryParse(dateString, culture, styles, out dateResult))
         Console.WriteLine("{0} converted to {1} {2}.",
                           dateString, dateResult, dateResult.Kind);
      else
         Console.WriteLine("Unable to convert {0} to a date and time.", dateString);

      // Parse a date and time that is assumed to be local.
      // This time is five hours behind UTC. The local system's time zone is
      // eight hours behind UTC.
      dateString = "2009/03/01T10:00:00-5:00";
      styles = DateTimeStyles.AssumeLocal;
      if (DateTime.TryParse(dateString, culture, styles, out dateResult))
         Console.WriteLine("{0} converted to {1} {2}.",
                           dateString, dateResult, dateResult.Kind);
      else
         Console.WriteLine("Unable to convert {0} to a date and time.", dateString);

      // Attempt to convert a string in improper ISO 8601 format.
      dateString = "03/01/2009T10:00:00-5:00";
      if (DateTime.TryParse(dateString, culture, styles, out dateResult))
         Console.WriteLine("{0} converted to {1} {2}.",
                           dateString, dateResult, dateResult.Kind);
      else
         Console.WriteLine("Unable to convert {0} to a date and time.", dateString);

      // Assume a date and time string formatted for the fr-FR culture is the local
      // time and convert it to UTC.
      dateString = "2008-03-01 10:00";
      culture = CultureInfo.CreateSpecificCulture("fr-FR");
      styles = DateTimeStyles.AdjustToUniversal | DateTimeStyles.AssumeLocal;
      if (DateTime.TryParse(dateString, culture, styles, out dateResult))
         Console.WriteLine("{0} converted to {1} {2}.",
                           dateString, dateResult, dateResult.Kind);
      else
         Console.WriteLine("Unable to convert {0} to a date and time.", dateString);
   }
}
// The example displays the following output to the console:
//       03/01/2009 10:00 AM converted to 3/1/2009 10:00:00 AM Unspecified.
//       03/01/2009 10:00 AM converted to 3/1/2009 10:00:00 AM Local.
//       2009/03/01T10:00:00-5:00 converted to 3/1/2009 7:00:00 AM Local.
//       Unable to convert 03/01/2009T10:00:00-5:00 to a date and time.
//       2008-03-01 10:00 converted to 3/1/2008 6:00:00 PM Utc.

open System
open System.Globalization

[<EntryPoint>]
let main _ =
    // Parse a date and time with no styles.
    let dateString = "03/01/2009 10:00 AM"
    let culture = CultureInfo.CreateSpecificCulture "en-US"
    let styles = DateTimeStyles.None
    match DateTime.TryParse(dateString, culture, styles) with
    | true, dateResult ->
        printfn $"{dateString} converted to {dateResult} {dateResult.Kind}."
    | _ -> 
        printfn $"Unable to convert {dateString} to a date and time."

    // Parse the same date and time with the AssumeLocal style.
    let styles = DateTimeStyles.AssumeLocal
    match DateTime.TryParse(dateString, culture, styles) with
    | true, dateResult ->
        printfn $"{dateString} converted to {dateResult} {dateResult.Kind}." 
    | _ ->
        printfn $"Unable to convert {dateString} to a date and time."

    // Parse a date and time that is assumed to be local.
    // This time is five hours behind UTC. The local system's time zone is
    // eight hours behind UTC.
    let dateString = "2009/03/01T10:00:00-5:00"
    let styles = DateTimeStyles.AssumeLocal
    match DateTime.TryParse(dateString, culture, styles) with
    | true, dateResult ->
        printfn $"{dateString} converted to {dateResult} {dateResult.Kind}."
    | _ ->
        printfn $"Unable to convert {dateString} to a date and time."

    // Attempt to convert a string in improper ISO 8601 format.
    let dateString = "03/01/2009T10:00:00-5:00"
    match DateTime.TryParse(dateString, culture, styles) with
    | true, dateResult ->
        printfn $"{dateString} converted to {dateResult} {dateResult.Kind}."
    | _ ->
        printfn $"Unable to convert {dateString} to a date and time."

    // Assume a date and time string formatted for the fr-FR culture is the local
    // time and convert it to UTC.
    let dateString = "2008-03-01 10:00"
    let culture = CultureInfo.CreateSpecificCulture "fr-FR"
    let styles = DateTimeStyles.AdjustToUniversal ||| DateTimeStyles.AssumeLocal
    match DateTime.TryParse(dateString, culture, styles) with
    | true, dateResult ->
        printfn $"{dateString} converted to {dateResult} {dateResult.Kind}." 
    | _ ->
        printfn $"Unable to convert {dateString} to a date and time."

    0

// The example displays the following output to the console:
//       03/01/2009 10:00 AM converted to 3/1/2009 10:00:00 AM Unspecified.
//       03/01/2009 10:00 AM converted to 3/1/2009 10:00:00 AM Local.
//       2009/03/01T10:00:00-5:00 converted to 3/1/2009 7:00:00 AM Local.
//       Unable to convert 03/01/2009T10:00:00-5:00 to a date and time.
//       2008-03-01 10:00 converted to 3/1/2008 6:00:00 PM Utc.

Imports System.Globalization

Public Module Example
   Public Sub Main()
      Dim dateString As String
      Dim culture As CultureInfo
      Dim styles As DateTimeStyles 
      Dim dateResult As DateTime
      
      ' Parse a date and time with no styles.
      dateString = "03/01/2009 10:00 AM"
      culture = CultureInfo.CreateSpecificCulture("en-US")
      styles = DateTimeStyles.None
      If DateTime.TryParse(dateString, culture, styles, dateResult) Then
         Console.WriteLine("{0} converted to {1} {2}.", _
                           dateString, dateResult, dateResult.Kind)
      Else
         Console.WriteLine("Unable to convert {0} to a date and time.", dateString)
      End If      
      
      ' Parse the same date and time with the AssumeLocal style.
      styles = DateTimeStyles.AssumeLocal
      If DateTime.TryParse(dateString, culture, styles, dateResult)
         Console.WriteLine("{0} converted to {1} {2}.", _
                           dateString, dateResult, dateResult.Kind)
      Else
         Console.WriteLine("Unable to convert {0} to a date and time.", dateString)
      End If      
      
      ' Parse a date and time that is assumed to be local.
      ' This time is five hours behind UTC. The local system's time zone is 
      ' eight hours behind UTC.
      dateString = "2009/03/01T10:00:00-5:00"
      styles = DateTimeStyles.AssumeLocal
      If DateTime.TryParse(dateString, culture, styles, dateResult)
         Console.WriteLine("{0} converted to {1} {2}.", _
                           dateString, dateResult, dateResult.Kind)
      Else
         Console.WriteLine("Unable to convert {0} to a date and time.", dateString)
      End If      
      
      ' Attempt to convert a string in improper ISO 8601 format.
      dateString = "03/01/2009T10:00:00-5:00"
      If DateTime.TryParse(dateString, culture, styles, dateResult)
         Console.WriteLine("{0} converted to {1} {2}.", _
                           dateString, dateResult, dateResult.Kind)
      Else
         Console.WriteLine("Unable to convert {0} to a date and time.", dateString)
      End If      

      ' Assume a date and time string formatted for the fr-FR culture is the local 
      ' time and convert it to UTC.
      dateString = "2008-03-01 10:00"
      culture = CultureInfo.CreateSpecificCulture("fr-FR")
      styles = DateTimeStyles.AdjustToUniversal Or DateTimeStyles.AssumeLocal
      If DateTime.TryParse(dateString, culture, styles, dateResult)
         Console.WriteLine("{0} converted to {1} {2}.", _
                           dateString, dateResult, dateResult.Kind)
      Else
         Console.WriteLine("Unable to convert {0} to a date and time.", dateString)
      End If      
   End Sub
End Module
' The example displays the following output to the console:
'       03/01/2009 10:00 AM converted to 3/1/2009 10:00:00 AM Unspecified.
'       03/01/2009 10:00 AM converted to 3/1/2009 10:00:00 AM Local.
'       2009/03/01T10:00:00-5:00 converted to 3/1/2009 7:00:00 AM Local.
'       Unable to convert 03/01/2009T10:00:00-5:00 to a date and time.
'       2008-03-01 10:00 converted to 3/1/2008 6:00:00 PM Utc.

Poznámky

Metoda DateTime.TryParse(String, IFormatProvider, DateTimeStyles, DateTime) analyzuje řetězec, který může obsahovat informace o datu, čase a časovém pásmu. Podobá se DateTime.Parse(String, IFormatProvider, DateTimeStyles) metodě, s tím rozdílem, že DateTime.TryParse(String, DateTime) metoda nevyvolá výjimku, pokud převod selže.

Tato metoda se pokusí ignorovat nerozpoznaná data a úplně parsovat vstupní řetězec (s). Pokud s obsahuje čas, ale žádné datum, metoda ve výchozím nastavení nahradí aktuální datum nebo, pokud styles obsahuje NoCurrentDateDefault příznak, nahradí DateTime.Date.MinValue. Pokud s obsahuje datum, ale bez času, použije se jako výchozí čas půlnoc 12:00. Pokud je datum přítomno, ale jeho rok se skládá pouze ze dvou číslic, převede se na rok v provider aktuálním kalendáři parametru na základě hodnoty Calendar.TwoDigitYearMax vlastnosti. Všechny počáteční, vnitřní nebo koncové prázdné znaky s se ignorují. Datum a čas lze ohraničit dvojicí počátečních a koncových znaků MŘÍŽKA ('#', U+0023), a na konci může být ukončen jedním nebo více znaky NUL (U+0000).

Konkrétní platné formáty pro prvky data a času, stejně jako názvy a symboly používané v datech a časech, jsou definovány parametrem provider , který může být libovolný z následujících:

Objekt CultureInfo, který představuje kulturu, jejíž formátování se používá v parametru s. Objekt DateTimeFormatInfo vrácený CultureInfo.DateTimeFormat vlastností definuje formátování použité v s.
Objekt DateTimeFormatInfo , který definuje formátování použité v s.
Vlastní IFormatProvider implementace. Jeho IFormatProvider.GetFormat metoda vrátí DateTimeFormatInfo objekt, který definuje formátování použité v s.

Pokud provider je null, použije se aktuální jazyková verze.

Pokud s je řetězcové vyjádření přestupného dne v přestupném roce v aktuálním kalendáři, metoda úspěšně parsuje s. Pokud je s řetězcovým vyjádřením přestupného dne v nepřestupném roce v aktuálním kalendáři provider, analýza selže a metoda vrátí false.

Parametr styles definuje přesnou interpretaci analyzovaného řetězce a způsob zpracování operace analýzy. Může to být jeden nebo více členů výčtu DateTimeStyles , jak je popsáno v následující tabulce.

DateTimeStyles – člen	Description
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` obsahuje DateTimeStyles.AssumeLocal příznak, metoda analyzuje řetězec, zavolá ToUniversalTime k převezení 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` obsahuje DateTimeStyles.AssumeUniversal příznak, metoda parsuje řetězec, neprovádí 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á vliv.
AllowInnerWhite	I když je tato hodnota platná, tato hodnota se ignoruje. Vnitřní prázdné znaky jsou povoleny v prvcích data a času.`s`
AllowLeadingWhite	I když je tato hodnota platná, tato hodnota se ignoruje. Počáteční prázdné znaky jsou povoleny v datech a časových elementech ``s``.
AllowTrailingWhite	I když je tato hodnota platná, tato hodnota se ignoruje. Koncové mezery jsou povoleny v prvcích data a času `s`.
AllowWhiteSpaces	Určuje, že `s` může obsahovat úvodní, vnitřní a koncové prázdné znaky. Toto je výchozí chování. Nelze jej přepsat zadáním přísnější DateTimeStyles hodnoty výčtu, například DateTimeStyles.None.
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í příznak DateTimeStyles.AdjustToUniversal přítomen, vlastnost Kind vrácené hodnoty DateTime je nastavena na DateTimeKind.Local.
AssumeUniversal	Určuje, že pokud `s` chybí informace o časovém pásmu, předpokládá se, že představuje UTC. DateTimeStyles.AdjustToUniversal Pokud není příznak přítomen, metoda převede vrácenou DateTime hodnotu z UTC na místní čas a nastaví jeho Kind vlastnost na DateTimeKind.Local.
None	I když je tato hodnota platná, tato hodnota se ignoruje.
RoundtripKind	U řetězců, které obsahují informace o časovém pásmu, se pokusí zabránit převodu řetězce data a času na DateTime hodnotu s jeho Kind vlastností nastavenou na DateTimeKind.Local. Takový řetězec je obvykle vytvořen voláním DateTime.ToString(String) metody pomocí specifikátorů standardního formátu "o", "r" nebo "u".

Pokud s neobsahuje žádné informace o časovém pásmu DateTime.TryParse(String, IFormatProvider, DateTimeStyles, DateTime) , metoda vrátí DateTime hodnotu, jejíž Kind vlastnost je DateTimeKind.Unspecified , pokud styles příznak indikuje jinak. Pokud s obsahuje informace o časovém pásmu nebo posunu časového pásma, metoda DateTime.TryParse(String, IFormatProvider, DateTimeStyles, DateTime) provede nezbytný časový převod a vrátí jednu z následujících možností:

Hodnota DateTime , jejíž datum a čas odráží místní čas a jehož Kind vlastnost je DateTimeKind.Local.
Nebo pokud styles obsahuje příznak AdjustToUniversal, hodnota DateTime, jejíž datum a čas odráží UTC a jehož vlastnost Kind je DateTimeKind.Utc.

Toto chování lze přepsat flagem DateTimeStyles.RoundtripKind.

Zpracování vlastních kulturních nastavení

Pokud parsujete řetězec data a času vygenerovaný pro vlastní jazykovou verzi, použijte metodu TryParseExact místo metody TryParse ke zvýšení pravděpodobnosti, že operace analýzy bude úspěšná. Řetězec data a času vlastní kultury může být složitý a obtížně interpretovatelný. Metoda TryParse se pokusí analyzovat řetězec s několika implicitními vzory analýzy, z nichž všechny můžou selhat. Naproti tomu TryParseExact metoda vyžaduje, abyste explicitně určili jeden nebo více přesných vzorů analýzy, které budou pravděpodobně úspěšné.

Další informace o vlastních jazykových verzích najdete ve System.Globalization.CultureAndRegionInfoBuilder třídě.

Poznámky pro volající

Formátování je ovlivněno vlastnostmi aktuálního DateTimeFormatInfo objektu, který je zadán parametrem provider . Metoda TryParse může neočekávaně selhat a vrátit False , pokud jsou aktuální DateSeparator a TimeSeparator vlastnosti nastaveny na stejnou hodnotu.

Viz také

Platí pro

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

Zdroj:: DateTime.cs

Zdroj:: DateTime.cs

Zdroj:: DateTime.cs

Zdroj:: DateTime.cs

Zdroj:: DateTime.cs

Převede reprezentaci rozsahu data a času na jeho DateTime ekvivalent pomocí zadaných informací o formátu specifické pro jazykovou verzi a stylu formátování a vrátí hodnotu, která označuje, zda převod proběhl úspěšně.

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

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

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

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

Public Shared Function TryParse (s As ReadOnlySpan(Of Char), provider As IFormatProvider, styles 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.

provider: IFormatProvider

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

styles: DateTimeStyles

result: DateTime

Návraty

Boolean

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

Platí pro

Váš názor

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