DateTime.TryParseExact Método

Referência

Definição

Namespace:: System

Assembly:: System.Runtime.dll

Assembly:: netstandard.dll

Assembly:: mscorlib.dll

Importante

Algumas informações se referem a produtos de pré-lançamento que podem ser substancialmente modificados antes do lançamento. A Microsoft não oferece garantias, expressas ou implícitas, das informações aqui fornecidas.

Converte a representação da cadeia de caracteres especificada de uma data e hora no DateTime equivalente. O formato da representação da cadeia de caracteres deve corresponder exatamente a um formato especificado. O método retorna um valor que indica se a conversão foi bem-sucedida.

Sobrecargas

TryParseExact(ReadOnlySpan<Char>, ReadOnlySpan<Char>, IFormatProvider, DateTimeStyles, DateTime)	Converte a representação de intervalo especificada de data e hora em seu equivalente DateTime usando o formato especificado, as informações de formato específicas da cultura e o estilo. O formato de representação da cadeia de caracteres deve corresponder exatamente ao formato especificado. O método retorna um valor que indica se a conversão foi bem-sucedida.
TryParseExact(ReadOnlySpan<Char>, String[], IFormatProvider, DateTimeStyles, DateTime)	Converte o intervalo de caracteres especificado de uma data e hora no equivalente de DateTime e retorna um valor que indica se a conversão foi bem-sucedida.
TryParseExact(String, String, IFormatProvider, DateTimeStyles, DateTime)	Converte a representação de cadeia de caracteres especificada de data e hora em seu equivalente DateTime usando o formato especificado, as informações de formato específicas da cultura e o estilo. O formato de representação da cadeia de caracteres deve corresponder exatamente ao formato especificado. O método retorna um valor que indica se a conversão foi bem-sucedida.
TryParseExact(String, String[], IFormatProvider, DateTimeStyles, DateTime)	Converte a representação de cadeia de caracteres especificada de um data e hora no equivalente de DateTime usando a matriz de formatos, informações de formato específicas da cultura e estilo especificados. O formato da representação da cadeia de caracteres deve corresponder exatamente a um dos formatos especificados pelo menos. O método retorna um valor que indica se a conversão foi bem-sucedida.

Comentários

Importante

As eras nos calendários japoneses se baseiam no reinado do Imperador e, portanto, estão sujeitas a alterações. Por exemplo, 1º de maio de 2019 marcou o início da era Reiwa no JapaneseCalendar e no JapaneseLunisolarCalendar. Tal alteração de eras afeta todos os aplicativos que usam esses calendários. Para obter mais informações e determinar se seus aplicativos são afetados, consulte Manipulando uma nova era no calendário japonês no .NET. Para obter informações sobre como testar seus aplicativos em sistemas Windows para garantir sua preparação para a alteração da era, consulte Preparar seu aplicativo para a alteração da era japonesa. Para recursos no .NET que dão suporte a calendários com várias eras e para práticas recomendadas ao trabalhar com calendários que dão suporte a várias eras, consulte Trabalhando com eras.

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

Origem:: DateTime.cs

Origem:: DateTime.cs

Origem:: DateTime.cs

Converte a representação de intervalo especificada de data e hora em seu equivalente DateTime usando o formato especificado, as informações de formato específicas da cultura e o estilo. O formato de representação da cadeia de caracteres deve corresponder exatamente ao formato especificado. O método retorna um valor que indica se a conversão foi bem-sucedida.

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

Parâmetros

s: ReadOnlySpan<Char>

Um intervalo que contém os caracteres que representam uma data e hora a serem convertidas.

format: ReadOnlySpan<Char>

O formato obrigatório de s.

provider: IFormatProvider

Um objeto que fornece informações de formatação específicas da cultura sobre s.

style: DateTimeStyles

Uma combinação bit a bit de um ou mais valores de enumeração que indica o formato permitido de s.

result: DateTime

Quando esse método retorna, contém o DateTime valor equivalente à data e hora contidas em s, se a conversão foi bem-sucedida ou DateTime.MinValue se a conversão falhou. A conversão falhará se o parâmetro s ou format for null, for uma cadeia de caracteres vazia ou não contiver uma data e hora que correspondem ao padrão especificado em format. Este parâmetro é passado não inicializado.

Retornos

Boolean

true caso s tenha sido convertido com êxito; do contrário, false.

Aplica-se a

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

Origem:: DateTime.cs

Origem:: DateTime.cs

Origem:: DateTime.cs

Converte o intervalo de caracteres especificado de uma data e hora no equivalente de DateTime e retorna um valor que indica se a conversão foi bem-sucedida.

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

Parâmetros

s: ReadOnlySpan<Char>

O intervalo que contém a cadeia de caracteres a analisar.

formats: String[]

Uma matriz de formatos permitidos de s.

provider: IFormatProvider

Um objeto que fornece informações de formatação específicas da cultura sobre s.

style: DateTimeStyles

Uma combinação bit a bit dos valores de enumeração que define como interpretar a data analisada em relação ao fuso horário atual ou à data atual. Um valor típico a ser especificado é None.

result: DateTime

Quando esse método retorna, contém o DateTime valor equivalente à data e hora contidas em s, se a conversão foi bem-sucedida ou DateTime.MinValue se a conversão falhou. A conversão falhará se o parâmetro s for null, for Empty ou não contiver uma representação de cadeia de caracteres válida de uma data e hora. Este parâmetro é passado não inicializado.

Retornos

Boolean

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

Aplica-se a

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

Origem:: DateTime.cs

Origem:: DateTime.cs

Origem:: DateTime.cs

Converte a representação de cadeia de caracteres especificada de data e hora em seu equivalente DateTime usando o formato especificado, as informações de formato específicas da cultura e o estilo. O formato de representação da cadeia de caracteres deve corresponder exatamente ao formato especificado. O método retorna um valor que indica se a conversão foi bem-sucedida.

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

Parâmetros

s: String

Uma cadeia de caracteres contendo uma data e hora a ser convertida.

format: String

O formato obrigatório de s.

provider: IFormatProvider

Um objeto que fornece informações de formatação específicas da cultura sobre s.

style: DateTimeStyles

Uma combinação bit a bit de um ou mais valores de enumeração que indica o formato permitido de s.

result: DateTime

Retornos

Boolean

true caso s tenha sido convertido com êxito; do contrário, false.

Exceções

ArgumentException

styles não é um valor DateTimeStyles válido.

- ou -

styles contém uma combinação inválida de valores DateTimeStyles (por exemplo, AssumeLocal e AssumeUniversal).

Exemplos

O exemplo a seguir demonstra o DateTime.TryParseExact(String, String, IFormatProvider, DateTimeStyles, DateTime) método. Observe que a cadeia de caracteres " 5/01/2009 8:30 AM" não pode ser analisada com êxito quando o styles parâmetro é igual a porque espaços à esquerda não são permitidos DateTimeStyles.None por format. Além disso, a cadeia de caracteres "5/01/2009 09:00" não pode ser analisada com êxito com um format de "MM/dd/aaaah:mm" porque a cadeia de caracteres de data não precede o número do mês com um zero à esquerda, conforme format necessário.

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

Comentários

O DateTime.TryParseExact(String, String, IFormatProvider, DateTimeStyles, DateTime) método analisa a representação de cadeia de caracteres de uma data, que deve estar no formato definido pelo format parâmetro . É semelhante ao DateTime.ParseExact(String, String, IFormatProvider, DateTimeStyles) método , exceto que o TryParseExact(String, String, IFormatProvider, DateTimeStyles, DateTime) método não gera uma exceção se a conversão falhar.

O s parâmetro contém a data e a hora a serem analisadas e deve estar em um formato definido pelo format parâmetro . Se os elementos de data, hora e fuso horário estiverem presentes no s, eles também deverão aparecer na ordem especificada por format. Se format definir uma data sem elemento de hora e a operação de análise for bem-sucedida, o valor resultante DateTime terá uma hora da meia-noite (00:00:00). Se format definir uma hora sem nenhum elemento de data e a operação de análise for bem-sucedida, o valor resultante DateTime por padrão terá uma data de DateTime.Now.Dateou terá uma data de DateTime.MinValue.Date se styles incluir o DateTimeStyles.NoCurrentDateDefault sinalizador . O style parâmetro determina se o s parâmetro pode conter caracteres de espaço em branco à esquerda, internos ou à direita.

Caso s não contenha informações de fuso horário, a propriedade Kind do objeto DateTime retornado é DateTimeKind.Unspecified. Este comportamento pode ser alterado usando-se o sinalizador DateTimeStyles.AssumeLocal, que retorna um valor DateTime cuja propriedade Kind é DateTimeKind.Local ou usando-se os sinalizadores DateTimeStyles.AssumeUniversal e DateTimeStyles.AdjustToUniversal, que retorna um valor DateTime cuja propriedade Kind é DateTimeKind.Utc. Se s contiver informações de fuso horário, a hora será convertida em hora local, se necessário, e a Kind propriedade do objeto retornado DateTime será definida DateTimeKind.Localcomo . Esse comportamento pode ser alterado usando o DateTimeStyles.RoundtripKind sinalizador para não converter o UTC (Tempo Universal Coordenado) em uma hora local e definir a Kind propriedade DateTimeKind.Utccomo .

O format parâmetro contém um padrão que corresponde ao formato esperado do s parâmetro. O padrão no parâmetro consiste em format um ou mais especificadores de formato personalizado da tabela Cadeias de Caracteres de Formato de Data e Hora Personalizadas ou um único especificador de formato padrão, que identifica um padrão predefinido, da tabela Cadeias de Caracteres de Formato de Data e Hora Padrão .

Caso você não use separadores de data ou hora em um padrão de formato personalizado, use a cultura invariável do parâmetro provider e a forma mais ampla de cada especificador de formato personalizado. Por exemplo, caso você queira especificar horas no padrão, especifique a forma mais ampla, "HH", em vez da forma mais estreita, "H".

Observação

Em vez de exigir que s esteja em conformidade com um único formato para que a operação de análise seja bem-sucedida, você pode chamar o DateTime.TryParseExact(String, String[], IFormatProvider, DateTimeStyles, DateTime) método e especificar vários formatos permitidos. Isso torna a operação de análise mais provável de ter êxito.

Os símbolos de data e hora e as cadeias de caracteres específicos (como os nomes dos dias da semana em um idioma específico) usados em s são definidos pelo parâmetro provider, como o formato preciso de s caso format seja uma cadeia de caracteres do especificador de formato padrão. O parâmetro provider pode ser um dos seguintes:

Um objeto CultureInfo que representa a cultura usada para interpretar s. O objeto DateTimeFormatInfo retornado pela propriedade DateTimeFormat define os símbolos e a formatação em s.
Um objeto DateTimeFormatInfo que define o formato dos dados de data e hora.
Uma implementação de IFormatProvider personalizada cujo método GetFormat retorna o objeto CultureInfo ou o objeto DateTimeFormatInfo que fornece informações de formatação.

Caso provider seja null, o objeto CultureInfo que corresponde à cultura atual é usado.

O parâmetro styles inclui um ou mais membros da enumeração DateTimeStyles que determinam se e onde o espaço em branco não definido por format pode aparecer em s e que controlam o comportamento preciso da operação de análise. A tabela a seguir descreve como cada membro da DateTimeStyles enumeração afeta a operação do TryParseExact(String, String, IFormatProvider, DateTimeStyles, DateTime) método .

Membro DateTimeStyles	Descrição
AdjustToUniversal	Analisa `s` e, caso necessário, converte-o em UTC. Caso `s` inclua um deslocamento de fuso horário ou caso `s` não contenha informações de fuso horário, mas `styles` inclua o sinalizador DateTimeStyles.AssumeLocal, o método analisa a cadeia de caracteres, chama ToUniversalTime para converter o valor DateTime retornado em UTC e define a propriedade Kind como DateTimeKind.Utc. Caso `s` indique que ele representa o UTC ou caso `s` não contenha informações de fuso horário, mas `styles` inclua o sinalizador DateTimeStyles.AssumeUniversal, o método analisa a cadeia de caracteres, não executa nenhuma conversão de fuso horário no valor DateTime retornado e define a propriedade Kind a DateTimeKind.Utc. Em todos os outros casos, o sinalizador não entra em vigor.
AllowInnerWhite	Especifica que o espaço em branco não definido por `format` pode ser exibido entre qualquer elemento de data ou hora individual.
AllowLeadingWhite	Especifica que o espaço em branco não definido por `format` pode ser exibido no início de `s`.
AllowTrailingWhite	Especifica que o espaço em branco não definido por `format` pode ser exibido no final de `s`.
AllowWhiteSpaces	Especifica que `s` pode conter espaços em branco à esquerda, internos, e à direita não definidos por `format`.
AssumeLocal	Especifica que, caso `s` não tenha informações de fuso horário, pressupõe-se que ele represente uma hora local. A menos que o sinalizador DateTimeStyles.AdjustToUniversal esteja presente, a propriedade Kind do valor DateTime retornado é definida como DateTimeKind.Local.
AssumeUniversal	Especifica que, caso `s` não tenha informações de fuso horário, pressupõe-se que ele represente o UTC. A menos que o sinalizador DateTimeStyles.AdjustToUniversal esteja presente, o método converte o valor DateTime retornado do UTC na hora local e define a propriedade Kind como DateTimeKind.Local.
NoCurrentDateDefault	Caso `s` contenha hora sem informações de data, a data do valor de retorno é definida como `DateTime.MinValue.Date`.
None	O parâmetro `s` é analisado usando-se valores padrão. Nenhum espaço em branco senão presente em `format` é permitido. Caso `s` não tenha um componente de data, a data do valor DateTime retornado é definida como 1/1/0001. Caso `s` não contenha informações de fuso horário, a propriedade Kind do objeto DateTime retornado é definida como DateTimeKind.Unspecified. Caso informações de fuso horário estejam presentes em `s`, a hora é convertida na hora local e a propriedade Kind do objeto DateTime retornado é definida como DateTimeKind.Local.
RoundtripKind	Para cadeias de caracteres que contêm informações de fuso horário, tenta impedir a conversão em um DateTime valor com sua Kind propriedade definida como DateTimeKind.Local. Este sinalizador impede principalmente a conversão de horas UTC em horas locais.

Notas aos Chamadores

No .NET Framework 4, o TryParseExact método retornará false se a cadeia de caracteres a ser analisada contiver um componente de hora e um designador AM/PM que não estejam de acordo. No .NET Framework 3.5 e versões anteriores, o designador AM/PM é ignorado.

Confira também

Aplica-se a

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

Origem:: DateTime.cs

Origem:: DateTime.cs

Origem:: DateTime.cs

Converte a representação de cadeia de caracteres especificada de um data e hora no equivalente de DateTime usando a matriz de formatos, informações de formato específicas da cultura e estilo especificados. O formato da representação da cadeia de caracteres deve corresponder exatamente a um dos formatos especificados pelo menos. O método retorna um valor que indica se a conversão foi bem-sucedida.

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

Parâmetros

s: String

Uma cadeia de caracteres que contém uma data e hora a ser convertida.

formats: String[]

Uma matriz de formatos permitidos de s.

provider: IFormatProvider

Um objeto que fornece informações de formato específicas de cultura sobre s.

style: DateTimeStyles

Um combinação bit a bit de valores de enumeração que indica o formato permitido de s. Um valor típico a ser especificado é None.

result: DateTime

Quando esse método retorna, contém o DateTime valor equivalente à data e hora contidas em s, se a conversão foi bem-sucedida ou DateTime.MinValue se a conversão falhou. A conversão falhará se s ou formats for null, s, se um elemento de formats for uma cadeia de caracteres vazia ou se o formato de s não for exatamente conforme especificado por pelo menos um dos padrões de formato em formats. Este parâmetro é passado não inicializado.

Retornos

Boolean

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

Exceções

ArgumentException

styles não é um valor DateTimeStyles válido.

- ou -

styles contém uma combinação inválida de valores DateTimeStyles (por exemplo, AssumeLocal e AssumeUniversal).

Exemplos

O exemplo a seguir usa o DateTime.TryParseExact(String, String, IFormatProvider, DateTimeStyles, DateTime) método para garantir que uma cadeia de caracteres em vários formatos possíveis possa ser analisada com êxito.

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.

Comentários

O DateTime.TryParseExact(String, String[], IFormatProvider, DateTimeStyles, DateTime) método analisa a representação de cadeia de caracteres de uma data que corresponde a qualquer um dos padrões atribuídos ao formats parâmetro . É como o DateTime.ParseExact(String, String[], IFormatProvider, DateTimeStyles) método , exceto que o TryParseExact método não gera uma exceção se a conversão falhar.

O s parâmetro contém a data e a hora a serem analisadas. Se o s parâmetro contiver apenas uma hora e nenhuma data, a data atual será usada, a menos que o style parâmetro inclua o DateTimeStyles.NoCurrentDateDefault sinalizador, nesse caso, a data padrão (DateTime.Date.MinValue) será usada. Se o s parâmetro contiver apenas uma data e nenhuma hora, meia-noite (00:00:00) será usada. O style parâmetro também determina se o s parâmetro pode conter caracteres de espaço em branco à esquerda, interno ou à direita diferentes daqueles permitidos por uma das cadeias de caracteres de formato em formats.

Caso s não contenha informações de fuso horário, a propriedade Kind do objeto DateTime retornado é DateTimeKind.Unspecified. Este comportamento pode ser alterado usando-se o sinalizador DateTimeStyles.AssumeLocal, que retorna um valor DateTime cuja propriedade Kind é DateTimeKind.Local ou usando-se os sinalizadores DateTimeStyles.AssumeUniversal e DateTimeStyles.AdjustToUniversal, que retorna um valor DateTime cuja propriedade Kind é DateTimeKind.Utc. Se s contiver informações de fuso horário, a hora será convertida em hora local, se necessário, e a Kind propriedade do objeto retornado DateTime será definida como DateTimeKind.Local. Esse comportamento pode ser alterado usando o DateTimeStyles.RoundtripKind sinalizador para não converter o UTC (Tempo Universal Coordenado) em uma hora local e definir a Kind propriedade como DateTimeKind.Utc.

O formats parâmetro contém uma matriz de padrões, um dos quais s deve corresponder exatamente se a operação de análise for bem-sucedida. Os padrões no parâmetro consistem em formats um ou mais especificadores de formato personalizado da tabela Cadeias de Caracteres de Formato de Data e Hora Personalizadas ou um único especificador de formato padrão, que identifica um padrão predefinido, na tabela Cadeias de Caracteres de Formato de Data e Hora Padrão .

Um objeto CultureInfo que representa a cultura usada para interpretar s. O objeto DateTimeFormatInfo retornado pela propriedade DateTimeFormat define os símbolos e a formatação em s.
Um objeto DateTimeFormatInfo que define o formato dos dados de data e hora.
Uma implementação de IFormatProvider personalizada cujo método GetFormat retorna o objeto CultureInfo ou o objeto DateTimeFormatInfo que fornece informações de formatação.

Caso provider seja null, o objeto CultureInfo que corresponde à cultura atual é usado.

O parâmetro styles inclui um ou mais membros da enumeração DateTimeStyles que determinam se e onde o espaço em branco não definido por format pode aparecer em s e que controlam o comportamento preciso da operação de análise. A tabela a seguir descreve como cada membro da DateTimeStyles enumeração afeta a operação do TryParseExact(String, String[], IFormatProvider, DateTimeStyles, DateTime) método .

Membro DateTimeStyles	Descrição
AdjustToUniversal	Analisa `s` e, caso necessário, converte-o em UTC. Caso `s` inclua um deslocamento de fuso horário ou caso `s` não contenha informações de fuso horário, mas `styles` inclua o sinalizador DateTimeStyles.AssumeLocal, o método analisa a cadeia de caracteres, chama ToUniversalTime para converter o valor DateTime retornado em UTC e define a propriedade Kind como DateTimeKind.Utc. Caso `s` indique que ele representa o UTC ou caso `s` não contenha informações de fuso horário, mas `styles` inclua o sinalizador DateTimeStyles.AssumeUniversal, o método analisa a cadeia de caracteres, não executa nenhuma conversão de fuso horário no valor DateTime retornado e define a propriedade Kind a DateTimeKind.Utc. Em todos os outros casos, o sinalizador não entra em vigor.
AllowInnerWhite	Especifica que o espaço em branco não definido por `format` pode ser exibido entre qualquer elemento de data ou hora individual.
AllowLeadingWhite	Especifica que o espaço em branco não definido por `format` pode ser exibido no início de `s`.
AllowTrailingWhite	Especifica que o espaço em branco não definido por `format` pode ser exibido no final de `s`.
AllowWhiteSpaces	Especifica que `s` pode conter espaços em branco à esquerda, internos, e à direita não definidos por `format`.
AssumeLocal	Especifica que, caso `s` não tenha informações de fuso horário, pressupõe-se que ele represente uma hora local. A menos que o sinalizador DateTimeStyles.AdjustToUniversal esteja presente, a propriedade Kind do valor DateTime retornado é definida como DateTimeKind.Local.
AssumeUniversal	Especifica que, caso `s` não tenha informações de fuso horário, pressupõe-se que ele represente o UTC. A menos que o sinalizador DateTimeStyles.AdjustToUniversal esteja presente, o método converte o valor DateTime retornado do UTC na hora local e define a propriedade Kind como DateTimeKind.Local.
NoCurrentDateDefault	Caso `s` contenha hora sem informações de data, a data do valor de retorno é definida como `DateTime.MinValue.Date`.
None	O parâmetro `s` é analisado usando-se valores padrão. Nenhum espaço em branco senão presente em `format` é permitido. Caso `s` não tenha um componente de data, a data do valor DateTime retornado é definida como 1/1/0001. Caso `s` não contenha informações de fuso horário, a propriedade Kind do objeto DateTime retornado é definida como DateTimeKind.Unspecified. Caso informações de fuso horário estejam presentes em `s`, a hora é convertida na hora local e a propriedade Kind do objeto DateTime retornado é definida como DateTimeKind.Local.
RoundtripKind	Para cadeias de caracteres que contêm informações de fuso horário, tenta impedir a conversão em um DateTime valor com sua Kind propriedade definida como DateTimeKind.Local. Este sinalizador impede principalmente a conversão de horas UTC em horas locais.

Notas aos Chamadores

No .NET Framework 4, o TryParseExact método retornará false se a cadeia de caracteres a ser analisada contiver um componente de hora e um designador AM/PM que não estão de acordo. No .NET Framework 3.5 e versões anteriores, o designador AM/PM é ignorado.

Confira também

Aplica-se a

DateTime.TryParseExact Método

Definição

Sobrecargas

Comentários

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

Parâmetros

Retornos

Aplica-se a

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

Parâmetros

Retornos

Aplica-se a

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

Parâmetros

Retornos

Exceções

Exemplos

Comentários

Notas aos Chamadores

Confira também

Aplica-se a

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

Parâmetros

Retornos

Exceções

Exemplos

Comentários

Notas aos Chamadores

Confira também

Aplica-se a

Comentários

Recursos adicionais