Compartilhar via

DateTime.TryParseExact Método

  • Referência

Definição

Namespace:
System
Assembly:
System.Runtime.dll
Assembly:
netstandard.dll
Assembly:
mscorlib.dll

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

Comentários

Importante

Eras nos calendários japoneses são baseadas no reinado do imperador e, portanto, espera-se que mudem. Por exemplo, 1º de maio de 2019 marcou o início da era Reiwa no JapaneseCalendar e JapaneseLunisolarCalendar. Essa mudança de era afeta todos os aplicativos que usam esses calendários. Para obter mais informações e determinar se seus aplicativos são afetados, consulte Tratando 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 obter recursos no .NET que dão suporte a calendários com várias eras e 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 uma data e hora em seu DateTime equivalente usando o formato especificado, as informações de formato específicas da cultura e o estilo. O formato da representação de 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 convertidos.

format
ReadOnlySpan<Char>

O formato necessá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 indicam o formato permitido de s.

result
DateTime

Quando esse método é retornado, contém o valor DateTime equivalente à data e hora contidas no 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 correspondam ao padrão especificado em format. Esse parâmetro é passado sem inicialização.

Retornos

Boolean

true se s foi convertido com êxito; caso 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 em seu DateTime equivalente 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 ser analisada.

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 de 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 é retornado, contém o valor DateTime equivalente à data e hora contidas no 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 Emptyou não contiver uma representação de cadeia de caracteres válida de uma data e hora. Esse parâmetro é passado sem inicialização.

Retornos

Boolean

true se o parâmetro s tiver sido convertido com êxito; caso 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 uma data e hora em seu DateTime equivalente usando o formato especificado, as informações de formato específicas da cultura e o estilo. O formato da representação de 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 que contém uma data e hora a serem convertidas.

format
String

O formato necessá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 indicam o formato permitido de s.

result
DateTime

Quando esse método é retornado, contém o valor DateTime equivalente à data e hora contidas no 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 correspondam ao padrão especificado em format. Esse parâmetro é passado sem inicialização.

Retornos

Boolean

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

Exceções

ArgumentException

style não é um valor de DateTimeStyles válido.

-ou-

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

Exemplos

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

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

O parâmetro s contém a data e a hora a serem analisadas e deve estar em um formato definido pelo parâmetro format. 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 DateTime resultante terá uma hora de meia-noite (00:00:00). Se format definir uma hora sem elemento de data e a operação de análise for bem-sucedida, o valor DateTime resultante por padrão terá uma data de DateTime.Now.Dateou terá uma data de DateTime.MinValue.Date se styles incluir o sinalizador DateTimeStyles.NoCurrentDateDefault. O parâmetro style determina se o parâmetro s pode conter caracteres de espaço em branco à esquerda, internos ou à direita.

Se s não contiver informações de fuso horário, a propriedade Kind do objeto DateTime retornado será DateTimeKind.Unspecified. Esse comportamento pode ser alterado usando o sinalizador DateTimeStyles.AssumeLocal, que retorna um valor DateTime cuja propriedade Kind é DateTimeKind.Localou usando 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 propriedade Kind do objeto DateTime retornado será definida como DateTimeKind.Local. Esse comportamento pode ser alterado usando o sinalizador DateTimeStyles.RoundtripKind para não converter UTC (Tempo Universal Coordenado) em uma hora local e definir a propriedade Kind como DateTimeKind.Utc.

O parâmetro format contém um padrão que corresponde ao formato esperado do parâmetro s. O padrão no parâmetro format consiste em 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.

Se você não usar separadores de data ou hora em um padrão de formato personalizado, use a cultura invariável para o parâmetro provider e a forma mais ampla de cada especificador de formato personalizado. Por exemplo, se você quiser especificar horas no padrão, especifique o formato mais amplo, "HH", em vez do formato mais estreito, "H".

Nota

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

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

Se provider for null, o objeto CultureInfo que corresponde à cultura atual será 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 enumeração DateTimeStyles afeta a operação do método TryParseExact(String, String, IFormatProvider, DateTimeStyles, DateTime).

Membro DateTimeStyles Descrição
AdjustToUniversal Analisa s e, se necessário, converte-o em 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 sinalizador DateTimeStyles.AssumeLocal, o método analisará a cadeia de caracteres, chamará ToUniversalTime para converter o valor de DateTime retornado em UTC e definirá a propriedade Kind 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 sinalizador DateTimeStyles.AssumeUniversal, o método analisará a cadeia de caracteres, não executará nenhuma conversão de fuso horário no valor de DateTime retornado e definirá a propriedade Kind como DateTimeKind.Utc. Em todos os outros casos, o sinalizador não tem efeito.
AllowInnerWhite Especifica que o espaço em branco não definido por format pode aparecer entre qualquer elemento de data ou hora individual.
AllowLeadingWhite Especifica que o espaço em branco não definido por format pode aparecer no início de s.
AllowTrailingWhite Especifica que o espaço em branco não definido por format pode aparecer no final de s.
AllowWhiteSpaces Especifica que s podem conter espaços em branco à esquerda, internos e à direita não definidos por format.
AssumeLocal Especifica que, se s não tiver nenhuma informação de fuso horário, será considerado representar uma hora local. A menos que o sinalizador DateTimeStyles.AdjustToUniversal esteja presente, a propriedade Kind do valor de DateTime retornado será definida como DateTimeKind.Local.
AssumeUniversal Especifica que, se s não tiver nenhuma informação de fuso horário, será considerado representar UTC. A menos que o sinalizador DateTimeStyles.AdjustToUniversal esteja presente, o método converterá o valor de DateTime retornado de UTC para hora local e definirá sua propriedade Kind como DateTimeKind.Local.
NoCurrentDateDefault Se s contiver a hora sem informações de data, a data do valor retornado será definida como DateTime.MinValue.Date.
None O parâmetro s é analisado usando valores padrão. Nenhum espaço em branco diferente daquele presente em format é permitido. Se s não tiver um componente de data, a data do valor de DateTime retornado será definida como 1/1/0001. Se s não contiver informações de fuso horário, a propriedade Kind do objeto DateTime retornado será definida como DateTimeKind.Unspecified. Se as informações de fuso horário estiverem presentes no s, a hora será convertida em hora local e a propriedade Kind do objeto DateTime retornado será 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 valor de DateTime com sua propriedade Kind definida como DateTimeKind.Local. Esse sinalizador impede principalmente a conversão de horários UTC em horários locais.

Notas aos Chamadores

No .NET Framework 4, o método TryParseExact 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

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 uma data e hora em seu DateTime equivalente usando a matriz especificada de formatos, informações de formato específicas da cultura e estilo. O formato da representação de cadeia de caracteres deve corresponder exatamente a pelo menos um dos formatos especificados. 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 serem convertidas.

formats
String[]

Uma matriz de formatos permitidos de s.

provider
IFormatProvider

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

style
DateTimeStyles

Uma 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 é retornado, contém o valor DateTime equivalente à data e hora contidas no 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 ou um elemento de formats for uma cadeia de caracteres vazia ou o formato de s não for exatamente como especificado por pelo menos um dos padrões de formato em formats. Esse parâmetro é passado sem inicialização.

Retornos

Boolean

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

Exceções

ArgumentException

style não é um valor de DateTimeStyles válido.

-ou-

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

Exemplos

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

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

Se s não contiver informações de fuso horário, a propriedade Kind do objeto DateTime retornado será DateTimeKind.Unspecified. Esse comportamento pode ser alterado usando o sinalizador DateTimeStyles.AssumeLocal, que retorna um valor DateTime cuja propriedade Kind é DateTimeKind.Localou usando 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 propriedade Kind do objeto DateTime retornado será definida como DateTimeKind.Local. Esse comportamento pode ser alterado usando o sinalizador DateTimeStyles.RoundtripKind para não converter UTC (Tempo Universal Coordenado) em uma hora local e definir a propriedade Kind como DateTimeKind.Utc.

O parâmetro formats 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 formats consistem em 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.

Se você não usar separadores de data ou hora em um padrão de formato personalizado, use a cultura invariável para o parâmetro provider e a forma mais ampla de cada especificador de formato personalizado. Por exemplo, se você quiser especificar horas no padrão, especifique o formato mais amplo, "HH", em vez do formato mais estreito, "H".

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

Se provider for null, o objeto CultureInfo que corresponde à cultura atual será 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 enumeração DateTimeStyles afeta a operação do método TryParseExact(String, String[], IFormatProvider, DateTimeStyles, DateTime).

Membro DateTimeStyles Descrição
AdjustToUniversal Analisa s e, se necessário, converte-o em 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 sinalizador DateTimeStyles.AssumeLocal, o método analisará a cadeia de caracteres, chamará ToUniversalTime para converter o valor de DateTime retornado em UTC e definirá a propriedade Kind 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 sinalizador DateTimeStyles.AssumeUniversal, o método analisará a cadeia de caracteres, não executará nenhuma conversão de fuso horário no valor de DateTime retornado e definirá a propriedade Kind como DateTimeKind.Utc. Em todos os outros casos, o sinalizador não tem efeito.
AllowInnerWhite Especifica que o espaço em branco não definido por format pode aparecer entre qualquer elemento de data ou hora individual.
AllowLeadingWhite Especifica que o espaço em branco não definido por format pode aparecer no início de s.
AllowTrailingWhite Especifica que o espaço em branco não definido por format pode aparecer no final de s.
AllowWhiteSpaces Especifica que s podem conter espaços em branco à esquerda, internos e à direita não definidos por format.
AssumeLocal Especifica que, se s não tiver nenhuma informação de fuso horário, será considerado representar uma hora local. A menos que o sinalizador DateTimeStyles.AdjustToUniversal esteja presente, a propriedade Kind do valor de DateTime retornado será definida como DateTimeKind.Local.
AssumeUniversal Especifica que, se s não tiver nenhuma informação de fuso horário, será considerado representar UTC. A menos que o sinalizador DateTimeStyles.AdjustToUniversal esteja presente, o método converterá o valor de DateTime retornado de UTC para hora local e definirá sua propriedade Kind como DateTimeKind.Local.
NoCurrentDateDefault Se s contiver a hora sem informações de data, a data do valor retornado será definida como DateTime.MinValue.Date.
None O parâmetro s é analisado usando valores padrão. Nenhum espaço em branco diferente daquele presente em format é permitido. Se s não tiver um componente de data, a data do valor de DateTime retornado será definida como 1/1/0001. Se s não contiver informações de fuso horário, a propriedade Kind do objeto DateTime retornado será definida como DateTimeKind.Unspecified. Se as informações de fuso horário estiverem presentes no s, a hora será convertida em hora local e a propriedade Kind do objeto DateTime retornado será 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 valor de DateTime com sua propriedade Kind definida como DateTimeKind.Local. Esse sinalizador impede principalmente a conversão de horários UTC em horários locais.

Notas aos Chamadores

No .NET Framework 4, o método TryParseExact 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