DateTime.TryParse Método

Origem:

DateTime.cs

Origem:

DateTime.cs

Origem:

DateTime.cs

Origem:

DateTime.cs

Origem:

DateTime.cs

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

Parâmetros

Retornos

true se o s parâmetro tiver sido convertido com êxito; caso contrário, false.

Origem:

DateTime.cs

Origem:

DateTime.cs

Origem:

DateTime.cs

Origem:

DateTime.cs

Origem:

DateTime.cs

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

Parâmetros

Retornos

true se o s parâmetro tiver sido convertido com êxito; caso contrário, false.

Exemplos

O exemplo a seguir passa várias cadeias de caracteres de data e hora para o DateTime.TryParse(String, DateTime) método.

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).

Comentários

O DateTime.TryParse(String, DateTime) método é semelhante ao DateTime.Parse(String) método, exceto que o TryParse(String, DateTime) método não gera uma exceção se a conversão falhar.

A cadeia de caracteres s é analisada usando informações de formatação no objeto atual DateTimeFormatInfo , que é fornecido implicitamente pela cultura atual.

Esse método tenta ignorar dados não reconhecidos, se possível, e preenche as informações de mês, dia e ano ausentes com a data atual. Se s contiver apenas uma data e nenhuma hora, esse método pressupõe que a hora seja 12:00 meia-noite. Se s incluir um componente de data com um ano de dois dígitos, ele será convertido em um ano no calendário atual da cultura atual com base no valor da Calendar.TwoDigitYearMax propriedade. Qualquer caractere s de espaço em branco à esquerda, interno ou à direita é ignorado. A data e a hora podem ser colocadas entre um par de caracteres SIGNO DE NÚMERO à esquerda e à direita ('#', U+0023) e podem ter um ou mais caracteres NULL ao final (U+0000).

Como o DateTime.TryParse(String, DateTime) método tenta analisar a representação de cadeia de caracteres de uma data e hora usando as regras de formatação da cultura atual, tentar analisar uma cadeia de caracteres específica entre diferentes culturas pode falhar ou retornar resultados diferentes. Se um formato de data e hora específico for analisado entre diferentes localidades, use o DateTime.TryParse(String, IFormatProvider, DateTimeStyles, DateTime) método ou uma das sobrecargas do método e forneça um especificador de TryParseExact formato.

Se s é a representação em forma de cadeia de caracteres de um dia bissexto em um ano bissexto no calendário atual, s, o método faz a análise com êxito. Se s for a representação de cadeia de caracteres de um dia bissexto em um ano não bissexto no calendário atual da cultura atual, a operação de análise falhará e o método retornará false.

Se s não contiver informações de fuso horário, result conterá um DateTime valor cuja Kind propriedade é DateTimeKind.Unspecified quando o método retorna. Se a cadeia de caracteres a ser analisada contiver informações de fuso horário, result conterá um DateTime valor cuja Kind propriedade é DateTimeKind.Local quando o método retorna.

Notas aos Chamadores

A formatação é influenciada por propriedades do objeto atual DateTimeFormatInfo , que por padrão são derivadas do item Opções regionais e de idioma no Painel de Controle. O TryParse método pode falhar inesperadamente e retornar False se a corrente DateSeparator e TimeSeparator as propriedades estiverem definidas com o mesmo valor.

Confira também

• Parse
• CultureInfo
• DateTimeFormatInfo
• Analisando cadeias de caracteres de data e hora no .NET Framework
• Cadeias de caracteres de formato de data e hora padrão
• Cadeias de caracteres de formato de data e hora personalizado
• Exemplo: Utilitário de Formatação WinForms do .NET Core (C#)
• Exemplo: Utilitário de Formatação WinForms do .NET Core (Visual Basic)

Origem:

DateTime.cs

Origem:

DateTime.cs

Origem:

DateTime.cs

Origem:

DateTime.cs

Origem:

DateTime.cs

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

Parâmetros

Retornos

true se s foi analisado com êxito; caso contrário, false.

Origem:

DateTime.cs

Origem:

DateTime.cs

Origem:

DateTime.cs

Origem:

DateTime.cs

Origem:

DateTime.cs

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

Parâmetros

Retornos

true se s foi analisado com êxito; caso contrário, false.

Origem:

DateTime.cs

Origem:

DateTime.cs

Origem:

DateTime.cs

Origem:

DateTime.cs

Origem:

DateTime.cs

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

Parâmetros

Retornos

true se o s parâmetro tiver sido convertido com êxito; caso contrário, false.

Exceções

Exemplos

O exemplo a seguir ilustra o método 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.

Comentários

O DateTime.TryParse(String, IFormatProvider, DateTimeStyles, DateTime) método analisa uma cadeia de caracteres que pode conter informações de data, hora e fuso horário. É semelhante ao DateTime.Parse(String, IFormatProvider, DateTimeStyles) método, exceto que o DateTime.TryParse(String, DateTime) método não gera uma exceção se a conversão falhar.

Esse método tenta ignorar dados não reconhecidos e analisar a cadeia de caracteres de entrada (s) completamente. Se s contiver uma hora, mas nenhuma data, o método por padrão substituirá a data atual ou, se styles incluir o NoCurrentDateDefault sinalizador, ele substituirá DateTime.Date.MinValue. Se s contiver uma data, mas sem hora, 12:00 meia-noite será usada como a hora padrão. Se uma data estiver presente, mas seu componente de ano consistir em apenas dois dígitos, ela será convertida em um ano no provider calendário atual do parâmetro com base no valor da Calendar.TwoDigitYearMax propriedade. Qualquer caractere de espaço em branco inicial, interno ou final em s será ignorado. A data e a hora podem ser colocadas entre um par de caracteres SIGNO DE NÚMERO à esquerda e à direita ('#', U+0023) e podem ter um ou mais caracteres NULL ao final (U+0000).

Formatos válidos específicos para elementos de data e hora, bem como os nomes e símbolos usados em datas e horas, são definidos pelo provider parâmetro, que pode ser qualquer um dos seguintes:

• Um CultureInfo objeto que representa a cultura cuja formatação é usada no s parâmetro. O DateTimeFormatInfo objeto retornado pela CultureInfo.DateTimeFormat propriedade define a formatação usada em s.
• Um DateTimeFormatInfo objeto que define a formatação usada em s.
• Uma implementação personalizada IFormatProvider : Seu IFormatProvider.GetFormat método retorna um DateTimeFormatInfo objeto que define a formatação usada em s.

Se provider for null, a cultura atual será usada.

Se s é a representação em forma de cadeia de caracteres de um dia bissexto em um ano bissexto no calendário atual, s, o método faz a análise com êxito. Se s for a representação de cadeia de caracteres de um dia bissexto em um ano não bissexto no calendário atual de provider, a operação de análise falhará e o método retornará false.

O styles parâmetro define a interpretação precisa da cadeia de caracteres analisada e como a operação de análise deve lidar com ela. Pode ser um ou mais membros da DateTimeStyles enumeração, conforme descrito na tabela a seguir.

Membro DateTimeStyles	Description
AdjustToUniversal	Analisa s e, se necessário, converte para UTC. Se s incluir um deslocamento de fuso horário ou se s não contiver informações de fuso horário, mas styles incluir o DateTimeStyles.AssumeLocal sinalizador, o método analisará a cadeia de caracteres, chamará ToUniversalTime para converter o valor retornado DateTime em UTC e definirá a Kind propriedade como DateTimeKind.Utc. Se s indicar que ele representa UTC ou se s não contiver informações de fuso horário, mas styles incluir o DateTimeStyles.AssumeUniversal sinalizador, o método analisará a cadeia de caracteres, não executará nenhuma conversão de fuso horário no valor retornado DateTime e definirá a Kind propriedade como DateTimeKind.Utc. Em todos os outros casos, a bandeira não tem efeito.
AllowInnerWhite	Embora seja válido, esse valor é ignorado. O espaço em branco interno é permitido nos elementos de data e hora de s.
AllowLeadingWhite	Embora seja válido, esse valor é ignorado. O espaço em branco à esquerda é permitido nos elementos de data e hora de s.
AllowTrailingWhite	Embora seja válido, esse valor é ignorado. O espaço em branco após o texto é permitido nos elementos de data e hora de s.
AllowWhiteSpaces	Especifica que s pode conter espaços em branco à esquerda, internos e à direita. Esse é o comportamento padrão. Ele não pode ser substituído fornecendo um valor de enumeração mais restritivo DateTimeStyles , como DateTimeStyles.None.
AssumeLocal	Especifica que, se s não houver informações de fuso horário, será assumido que ele represente uma hora local. A menos que o DateTimeStyles.AdjustToUniversal sinalizador esteja presente, a Kind propriedade do valor retornado DateTime será definida como DateTimeKind.Local.
AssumeUniversal	Especifica que, se s não houver informações de fuso horário, será assumido que ele represente UTC. A menos que o DateTimeStyles.AdjustToUniversal sinalizador esteja presente, o método converterá o valor retornado DateTime de UTC para hora local e definirá sua Kind propriedade como DateTimeKind.Local.
None	Embora seja válido, esse valor é ignorado.
RoundtripKind	Para cadeias de caracteres que contêm informações de fuso horário, tenta impedir a conversão de uma cadeia de caracteres de data e hora em um DateTime valor com sua Kind propriedade definida como DateTimeKind.Local. Normalmente, essa cadeia de caracteres é criada chamando o DateTime.ToString(String) método usando os especificadores de formato padrão "o", "r" ou "u".

Se s não contiver informações de fuso horário, o DateTime.TryParse(String, IFormatProvider, DateTimeStyles, DateTime) método retornará um DateTime valor cuja Kind propriedade é DateTimeKind.Unspecified , a menos que um styles sinalizador indique o contrário. Se s incluir informações de fuso horário ou de deslocamento de fuso horário, o método DateTime.TryParse(String, IFormatProvider, DateTimeStyles, DateTime) realiza as conversões de tempo necessárias e retorna um dos seguintes:

• Um DateTime valor cuja data e hora refletem a hora local e cuja Kind propriedade é DateTimeKind.Local.
• Ou, se styles incluir o AdjustToUniversal sinalizador, um DateTime valor cuja data e hora refletem UTC e cuja Kind propriedade é DateTimeKind.Utc.

Esse comportamento pode ser substituído usando o DateTimeStyles.RoundtripKind sinalizador.

Analisar culturas personalizadas

Se você analisar uma cadeia de caracteres de data e hora gerada para uma cultura personalizada, use o TryParseExact método em vez do TryParse método para melhorar a probabilidade de que a operação de análise seja bem-sucedida. Uma cadeia de caracteres de data e hora de cultura personalizada pode ser complicada e difícil de analisar. O TryParse método tenta analisar uma cadeia de caracteres com vários padrões de análise implícitos, que podem falhar. Por outro lado, o TryParseExact método exige que você designe explicitamente um ou mais padrões exatos de análise que provavelmente serão bem-sucedidos.

Para obter mais informações sobre culturas personalizadas, consulte a System.Globalization.CultureAndRegionInfoBuilder classe.

Notas aos Chamadores

A formatação é influenciada por propriedades do objeto atual DateTimeFormatInfo , que é fornecido pelo provider parâmetro. O TryParse método pode falhar inesperadamente e retornar False se a corrente DateSeparator e TimeSeparator as propriedades estiverem definidas com o mesmo valor.

Confira também

• Parse
• CultureInfo
• DateTimeFormatInfo
• Analisando cadeias de caracteres de data e hora no .NET Framework
• Cadeias de caracteres de formato de data e hora padrão
• Cadeias de caracteres de formato de data e hora personalizado

Origem:

DateTime.cs

Origem:

DateTime.cs

Origem:

DateTime.cs

Origem:

DateTime.cs

Origem:

DateTime.cs

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

Parâmetros

Retornos

true se o s parâmetro tiver sido convertido com êxito; caso contrário, false.