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

Devoluções

true se o s parâmetro foi convertido com sucesso; 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

Devoluções

true se o s parâmetro foi convertido com sucesso; caso contrário, false.

Exemplos

O exemplo seguinte passa várias cadeias de data e hora ao 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).

Observações

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

A cadeia s é analisada usando a informação de formatação no objeto atual DateTimeFormatInfo , que é fornecida implicitamente pela cultura atual.

Este método tenta ignorar dados não reconhecidos, se possível, e preenche as informações de mês, dia e ano em falta com a data atual. Se s contiver apenas uma data e nenhuma hora, este método assume que a hora é meia-noite. Se s incluir um componente de data com um ano de dois dígitos, é convertido para um ano no calendário atual da cultura atual com base no valor da Calendar.TwoDigitYearMax propriedade. Qualquer caractere de espaço branco inicial, interno ou posterior é s ignorado. A data e a hora podem ser colocadas entre parênteses com um par de caracteres NUMBER SIGN à esquerda e à direita ('#', U+0023), e podem ser rastreadas com um ou mais caracteres NULL (U+0000).

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

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

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

Notas para Chamadores

A formatação é influenciada pelas propriedades do objeto atual DateTimeFormatInfo, que por defeito derivam do item Regional e Language Options em Painel de Controlo. O TryParse método pode falhar inesperadamente e regressar False se a corrente DateSeparator e TimeSeparator as propriedades estiverem definidas para o mesmo valor.

Ver também

• Parse
• CultureInfo
• DateTimeFormatInfo
• Análise das Cadeias de Data e Hora na .NET Framework
• Cadeias de Formatos de Data e Hora Padrão
• Cadeias de Formato de Data e Hora Personalizadas
• Exemplo: Utilitário de formatação WinForms .NET Core (C#)
• Exemplo: Utilitário de formatação do .NET Core WinForms (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

Devoluções

true se s foi analisado com sucesso; 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

Devoluções

true se s foi analisado com sucesso; 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

Devoluções

true se o s parâmetro foi convertido com sucesso; caso contrário, false.

Exceções

Exemplos

O exemplo seguinte ilustra o DateTime.TryParse(String, IFormatProvider, DateTimeStyles, DateTime) método.

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.

Observações

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 lança uma exceção se a conversão falhar.

Este 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, substituirá DateTime.Date.MinValue. Se s contiver uma data, mas nenhuma hora, 12:00 meia-noite é usada como a hora padrão. Se uma data estiver presente, mas seu componente 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. Em s, todos os caracteres de espaço em branco à esquerda, internos ou à direita são ignorados. A data e a hora podem ser colocadas entre parênteses com um par de caracteres NUMBER SIGN à esquerda e à direita ('#', U+0023), e podem ser rastreadas com um ou mais caracteres NULL (U+0000).

Os 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 no s.
• Um DateTimeFormatInfo objeto que define a formatação usada no s.
• Uma IFormatProvider implementação personalizada. Seu IFormatProvider.GetFormat método retorna um DateTimeFormatInfo objeto que define a formatação usada no s.

Se provider for igual a null, a cultura atual é usada.

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

O styles parâmetro define a interpretação precisa da cadeia de caracteres analisada e como a operação de análise deve manipulá-la. 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-o 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 contém informações de fuso horário, mas styles inclui o DateTimeStyles.AssumeUniversal sinalizador, o método analisa a cadeia de caracteres, não executa nenhuma conversão de fuso horário no valor retornado DateTime e define a Kind propriedade como DateTimeKind.Utc. Em todos os outros casos, a bandeira não tem efeito.
AllowInnerWhite	Embora válido, esse valor é ignorado. O espaço em branco interno é permitido nos elementos de data e hora do s.
AllowLeadingWhite	Embora válido, esse valor é ignorado. O espaço em branco à esquerda é permitido nos elementos de data e hora do s.
AllowTrailingWhite	Embora válido, esse valor é ignorado. O espaço em branco final é permitido nos elementos de data e hora do s.
AllowWhiteSpaces	Especifica que s pode conter espaços em branco internos, à esquerda e à direita. Este é 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, presume-se que elas representem uma hora local. A menos que o DateTimeStyles.AdjustToUniversal sinalizador esteja presente, a Kind propriedade do valor retornado DateTime é definida como DateTimeKind.Local.
AssumeUniversal	Especifica que, se s não contiver informações de fuso horário, presume-se que representa UTC. A menos que o DateTimeStyles.AdjustToUniversal sinalizador esteja presente, o método converte o valor retornado DateTime de UTC para a hora local e define sua Kind propriedade como DateTimeKind.Local.
None	Embora 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 para um valor DateTime com a sua propriedade Kind configurada para 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 método DateTime.TryParse(String, IFormatProvider, DateTimeStyles, DateTime) retornará um valor DateTime cuja propriedade Kind é DateTimeKind.Unspecified, a menos que um sinalizador styles 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) executa qualquer conversão de tempo necessária e retorna uma das seguintes opções:

• 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 reflitam UTC e cuja Kind propriedade seja DateTimeKind.Utc.

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

Analise culturas personalizadas

Para interpretar uma cadeia de caracteres de data e hora gerada para uma cultura personalizada, use o método TryParseExact em vez do método TryParse para aumentar 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, todos os quais podem falhar. Por outro lado, o TryParseExact método requer que você designe explicitamente um ou mais padrões de análise exatos que provavelmente terão êxito.

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

Notas para Chamadores

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

Ver também

• Parse
• CultureInfo
• DateTimeFormatInfo
• Análise das Cadeias de Data e Hora na .NET Framework
• Cadeias de Formatos de Data e Hora Padrão
• Cadeias de Formato de Data e Hora Personalizadas

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

Devoluções

true se o s parâmetro foi convertido com sucesso; caso contrário, false.