DateTime.ParseExact 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 de cadeia de caracteres deverá corresponder exatamente a um formato especificado ou uma exceção será gerada.

Sobrecargas

ParseExact(String, String, IFormatProvider)	Converte a representação de cadeia de caracteres especificada de data e hora em seu equivalente DateTime usando o formato especificado e as informações de formato específicas da cultura. O formato de representação da cadeia de caracteres deve corresponder exatamente ao formato especificado.
ParseExact(ReadOnlySpan<Char>, ReadOnlySpan<Char>, IFormatProvider, DateTimeStyles)	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 da representação de cadeia de caracteres deverá corresponder exatamente ao formato especificado ou uma exceção será gerada.
ParseExact(ReadOnlySpan<Char>, String[], IFormatProvider, DateTimeStyles)	Converte a representação de intervalo especificada de data e hora em seu equivalente DateTime usando a matriz de formatos especificada, as informações de formato específicas da cultura e o estilo. O formato da representação de cadeia de caracteres deverá corresponder a, pelo menos, um dos formatos especificados exatamente ou uma exceção será gerada.
ParseExact(String, String, IFormatProvider, DateTimeStyles)	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 da representação de cadeia de caracteres deverá corresponder exatamente ao formato especificado ou uma exceção será gerada.
ParseExact(String, String[], IFormatProvider, DateTimeStyles)	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 de cadeia de caracteres deverá corresponder a, pelo menos, um dos formatos especificados exatamente ou uma exceção será gerada.

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 Tratamento de 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 suportam calendários com várias eras e para práticas recomendadas ao trabalhar com calendários que suportam várias eras,consulte Trabalhando com eras .

ParseExact(String, String, IFormatProvider)

Converte a representação de cadeia de caracteres especificada de data e hora em seu equivalente DateTime usando o formato especificado e as informações de formato específicas da cultura. O formato de representação da cadeia de caracteres deve corresponder exatamente ao formato especificado.

public:
 static DateTime ParseExact(System::String ^ s, System::String ^ format, IFormatProvider ^ provider);

public static DateTime ParseExact (string s, string format, IFormatProvider provider);

public static DateTime ParseExact (string s, string format, IFormatProvider? provider);

static member ParseExact : string * string * IFormatProvider -> DateTime

Public Shared Function ParseExact (s As String, format As String, provider As IFormatProvider) As DateTime

Parâmetros

s: String

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

format: String

Um especificador de formato que define o formato obrigatório de s. Para obter mais informações, consulte a seção Comentários.

provider: IFormatProvider

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

Retornos

DateTime

Um objeto equivalente à data e hora contida no s, conforme especificado por format e provider.

Exceções

ArgumentNullException

s ou format é null.

FormatException

s ou format é uma cadeia de caracteres vazia.

ou -

s não contém uma data e hora correspondente ao padrão especificado em format.

ou -

O componente de hora e o designador AM/PM no s não concordam.

Exemplos

O exemplo a seguir demonstra o ParseExact método.

using System;
using System.Globalization;

public class Example
{
   public static void Main()
   {
      string dateString, format;
      DateTime result;
      CultureInfo provider = CultureInfo.InvariantCulture;

      // Parse date-only value with invariant culture.
      dateString = "06/15/2008";
      format = "d";
      try {
         result = DateTime.ParseExact(dateString, format, provider);
         Console.WriteLine("{0} converts to {1}.", dateString, result.ToString());
      }
      catch (FormatException) {
         Console.WriteLine("{0} is not in the correct format.", dateString);
      }

      // Parse date-only value without leading zero in month using "d" format.
      // Should throw a FormatException because standard short date pattern of
      // invariant culture requires two-digit month.
      dateString = "6/15/2008";
      try {
         result = DateTime.ParseExact(dateString, format, provider);
         Console.WriteLine("{0} converts to {1}.", dateString, result.ToString());
      }
      catch (FormatException) {
         Console.WriteLine("{0} is not in the correct format.", dateString);
      }

      // Parse date and time with custom specifier.
      dateString = "Sun 15 Jun 2008 8:30 AM -06:00";
      format = "ddd dd MMM yyyy h:mm tt zzz";
      try {
         result = DateTime.ParseExact(dateString, format, provider);
         Console.WriteLine("{0} converts to {1}.", dateString, result.ToString());
      }
      catch (FormatException) {
         Console.WriteLine("{0} is not in the correct format.", dateString);
      }

      // Parse date and time with offset but without offset's minutes.
      // Should throw a FormatException because "zzz" specifier requires leading
      // zero in hours.
      dateString = "Sun 15 Jun 2008 8:30 AM -06";
      try {
         result = DateTime.ParseExact(dateString, format, provider);
         Console.WriteLine("{0} converts to {1}.", dateString, result.ToString());
      }
      catch (FormatException) {
         Console.WriteLine("{0} is not in the correct format.", dateString);
      }

      dateString = "15/06/2008 08:30";
      format = "g";
      provider = new CultureInfo("fr-FR");
      try {
         result = DateTime.ParseExact(dateString, format, provider);
         Console.WriteLine("{0} converts to {1}.", dateString, result.ToString());
      }
      catch (FormatException) {
         Console.WriteLine("{0} is not in the correct format.", dateString);
      }

      // Parse a date that includes seconds and milliseconds
      // by using the French (France) and invariant cultures.
      dateString = "18/08/2015 06:30:15.006542";
      format = "dd/MM/yyyy HH:mm:ss.ffffff";
      try {
         result = DateTime.ParseExact(dateString, format, provider);
         Console.WriteLine("{0} converts to {1}.", dateString, result.ToString());
      }
      catch (FormatException) {
         Console.WriteLine("{0} is not in the correct format.", dateString);
      }
   }
}
// The example displays the following output:
//       06/15/2008 converts to 6/15/2008 12:00:00 AM.
//       6/15/2008 is not in the correct format.
//       Sun 15 Jun 2008 8:30 AM -06:00 converts to 6/15/2008 7:30:00 AM.
//       Sun 15 Jun 2008 8:30 AM -06 is not in the correct format.
//       15/06/2008 08:30 converts to 6/15/2008 8:30:00 AM.
//       18/08/2015 06:30:15.006542 converts to 8/18/2015 6:30:15 AM.

Imports System.Globalization

Module Example
   Public Sub Main()
      Dim dateString, format As String  
      Dim result As Date
      Dim provider As CultureInfo = CultureInfo.InvariantCulture

      ' Parse date-only value with invariant culture.
      dateString = "06/15/2008"
      format = "d"
      Try
         result = Date.ParseExact(dateString, format, provider)
         Console.WriteLine("{0} converts to {1}.", dateString, result.ToString())
      Catch e As FormatException
         Console.WriteLine("{0} is not in the correct format.", dateString)
      End Try 

      ' Parse date-only value without leading zero in month using "d" format.
      ' Should throw a FormatException because standard short date pattern of 
      ' invariant culture requires two-digit month.
      dateString = "6/15/2008"
      Try
         result = Date.ParseExact(dateString, format, provider)
         Console.WriteLine("{0} converts to {1}.", dateString, result.ToString())
      Catch e As FormatException
         Console.WriteLine("{0} is not in the correct format.", dateString)
      End Try 
      
      ' Parse date and time with custom specifier.
      dateString = "Sun 15 Jun 2008 8:30 AM -06:00"
      format = "ddd dd MMM yyyy h:mm tt zzz"        
      Try
         result = Date.ParseExact(dateString, format, provider)
         Console.WriteLine("{0} converts to {1}.", dateString, result.ToString())
      Catch e As FormatException
         Console.WriteLine("{0} is not in the correct format.", dateString)
      End Try 
      
      ' Parse date and time with offset but without offset's minutes.
      ' Should throw a FormatException because "zzz" specifier requires leading  
      ' zero in hours.
      dateString = "Sun 15 Jun 2008 8:30 AM -06"
      Try
         result = Date.ParseExact(dateString, format, provider)
         Console.WriteLine("{0} converts to {1}.", dateString, result.ToString())
      Catch e As FormatException
         Console.WriteLine("{0} is not in the correct format.", dateString)
      End Try 
      
      ' Parse a date string using the French (France) culture.
      dateString = "15/06/2008 08:30"
      format = "g"
      provider = New CultureInfo("fr-FR")
      Try
         result = Date.ParseExact(dateString, format, provider)
         Console.WriteLine("{0} converts to {1}.", dateString, result.ToString())
      Catch e As FormatException
         Console.WriteLine("{0} is not in the correct format.", dateString)
      End Try

      ' Parse a date that includes seconds and milliseconds
      ' by using the French (France) and invariant cultures.
      dateString = "18/08/2015 06:30:15.006542"
      format = "dd/MM/yyyy HH:mm:ss.ffffff"
      Try
         result = Date.ParseExact(dateString, format, provider)
         Console.WriteLine("{0} converts to {1}.", dateString, result.ToString())
      Catch e As FormatException
         Console.WriteLine("{0} is not in the correct format.", dateString)
      End Try
   End Sub
End Module
' The example displays the following output:
'       06/15/2008 converts to 6/15/2008 12:00:00 AM.
'       6/15/2008 is not in the correct format.
'       Sun 15 Jun 2008 8:30 AM -06:00 converts to 6/15/2008 7:30:00 AM.
'       Sun 15 Jun 2008 8:30 AM -06 is not in the correct format.
'       15/06/2008 08:30 converts to 6/15/2008 8:30:00 AM.
'       18/08/2015 06:30:15.006542 converts to 8/18/2015 6:30:15 AM.

Comentários

O DateTime.ParseExact(String, String, IFormatProvider) método analisará a representação de cadeia de caracteres de uma data, que deve estar no formato definido pelo format parâmetro . Ele também requer que os elementos e da representação de cadeia de caracteres de uma data e hora apareçam na ordem especificada por e que não tenham nenhum espaço em branco diferente do <Date> <Time> permitido por format s format . Se definir uma data sem elemento de hora e a operação de análise for bem-sucedida, o valor resultante terá uma hora de meia-noite format DateTime (00:00:00). Se definir uma hora sem elemento de data e a operação de análise for bem-sucedida, o format valor resultante terá uma data de DateTime DateTime.Now.Date .

Se não representar uma hora em um fuso horário específico e a operação de análise for bem-sucedida, a propriedade do s Kind valor retornado será DateTime DateTimeKind.Unspecified . Se representar o tempo em um fuso horário específico e permitir que as informações de fuso horário sejam presentes (por exemplo, se for igual aos especificadores de formato padrão "o", "r" ou "u" ou se contiver os especificadores de formato personalizado s format format "z", "zz" ou "zzz"), a propriedade do valor retornado Kind DateTime será DateTimeKind.Local .

O parâmetro format é uma cadeia de caracteres que contém um único especificador de formato padrão ou um ou mais especificadores de formato que definem o formato exigido de s. Para obter detalhes sobre códigos de formatação válidos, consulte Cadeias de caracteres de formato de data e hora padrão ou Cadeias de caracteres de formato de data e hora personalizadas.

Observação

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

Os símbolos de data e hora específicos e cadeias de caracteres (como nomes dos dias da semana em um idioma específico) usados em são definidos pelo parâmetro , assim como o formato preciso de se é uma cadeia de caracteres do especificador de formato s provider s format 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.

Notas aos Chamadores

No .NET Framework 4, o método lança um se a cadeia de caracteres a ser analisado contiver um componente de hora e um ParseExact designador AM/PM que não FormatException estão em acordo. No .NET Framework 3.5 e versões anteriores, o designador AM/PM é ignorado.

Confira também

Aplica-se a

ParseExact(ReadOnlySpan<Char>, ReadOnlySpan<Char>, IFormatProvider, DateTimeStyles)

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 da representação de cadeia de caracteres deverá corresponder exatamente ao formato especificado ou uma exceção será gerada.

public static DateTime ParseExact (ReadOnlySpan<char> s, ReadOnlySpan<char> format, IFormatProvider? provider, System.Globalization.DateTimeStyles style = System.Globalization.DateTimeStyles.None);

public static DateTime ParseExact (ReadOnlySpan<char> s, ReadOnlySpan<char> format, IFormatProvider provider, System.Globalization.DateTimeStyles style = System.Globalization.DateTimeStyles.None);

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

Public Shared Function ParseExact (s As ReadOnlySpan(Of Char), format As ReadOnlySpan(Of Char), provider As IFormatProvider, Optional style As DateTimeStyles = System.Globalization.DateTimeStyles.None) As DateTime

Parâmetros

s: ReadOnlySpan<Char>

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

format: ReadOnlySpan<Char>

Um intervalo que contém os caracteres que representam um especificador de formato que define 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 dos valores de enumeração que fornece informações adicionais sobre s, sobre elementos de estilo que podem estar presentes em s ou sobre a conversão de s para um valor de DateTime. Um valor típico a ser especificado é None.

Retornos

DateTime

Um objeto equivalente à data e hora contida no s, conforme especificado por format, provider e style.

Aplica-se a

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

Converte a representação de intervalo especificada de data e hora em seu equivalente DateTime usando a matriz de formatos especificada, as informações de formato específicas da cultura e o estilo. O formato da representação de cadeia de caracteres deverá corresponder a, pelo menos, um dos formatos especificados exatamente ou uma exceção será gerada.

public static DateTime ParseExact (ReadOnlySpan<char> s, string[] formats, IFormatProvider? provider, System.Globalization.DateTimeStyles style = System.Globalization.DateTimeStyles.None);

public static DateTime ParseExact (ReadOnlySpan<char> s, string[] formats, IFormatProvider provider, System.Globalization.DateTimeStyles style = System.Globalization.DateTimeStyles.None);

static member ParseExact : ReadOnlySpan<char> * string[] * IFormatProvider * System.Globalization.DateTimeStyles -> DateTime

Public Shared Function ParseExact (s As ReadOnlySpan(Of Char), formats As String(), provider As IFormatProvider, Optional style As DateTimeStyles = System.Globalization.DateTimeStyles.None) As DateTime

Parâmetros

s: ReadOnlySpan<Char>

Um intervalo que contém os caracteres que representam 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 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.

Retornos

DateTime

Um objeto equivalente à data e hora contida no s, conforme especificado por formats, provider e style.

Aplica-se a

ParseExact(String, String, IFormatProvider, DateTimeStyles)

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 da representação de cadeia de caracteres deverá corresponder exatamente ao formato especificado ou uma exceção será gerada.

public:
 static DateTime ParseExact(System::String ^ s, System::String ^ format, IFormatProvider ^ provider, System::Globalization::DateTimeStyles style);

public static DateTime ParseExact (string s, string format, IFormatProvider provider, System.Globalization.DateTimeStyles style);

public static DateTime ParseExact (string s, string format, IFormatProvider? provider, System.Globalization.DateTimeStyles style);

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

Public Shared Function ParseExact (s As String, format As String, provider As IFormatProvider, style As DateTimeStyles) As DateTime

Parâmetros

s: String

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

format: String

Um especificador de formato que define o formato obrigatório de s. Para obter mais informações, consulte a seção Comentários.

provider: IFormatProvider

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

style: DateTimeStyles

Retornos

DateTime

Um objeto equivalente à data e hora contida no s, conforme especificado por format, provider e style.

Exceções

ArgumentNullException

s ou format é null.

FormatException

s ou format é uma cadeia de caracteres vazia.

ou -

s não contém uma data e hora correspondente ao padrão especificado em format.

ou -

O componente de hora e o designador AM/PM no s não concordam.

ArgumentException

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

Exemplos

O exemplo a seguir demonstra o ParseExact(String, String, IFormatProvider) 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 DateTimeStyles.None , pois os espaços à esquerda não são permitidos pelo 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/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";
      try {
         dateValue = DateTime.ParseExact(dateString, "g", enUS, DateTimeStyles.None);
         Console.WriteLine("Converted '{0}' to {1} ({2}).", dateString, dateValue,
                           dateValue.Kind);
      }
      catch (FormatException) {
         Console.WriteLine("'{0}' is not in an acceptable format.", dateString);
      }
      // Allow a leading space in the date string.
      try {
         dateValue = DateTime.ParseExact(dateString, "g", enUS, DateTimeStyles.AllowLeadingWhite);
         Console.WriteLine("Converted '{0}' to {1} ({2}).", dateString, dateValue,
                           dateValue.Kind);
      }
      catch (FormatException) {
         Console.WriteLine("'{0}' is not in an acceptable format.", dateString);
      }

      // Use custom formats with M and MM.
      dateString = "5/01/2009 09:00";
      try {
         dateValue = DateTime.ParseExact(dateString, "M/dd/yyyy hh:mm", enUS, DateTimeStyles.None);
         Console.WriteLine("Converted '{0}' to {1} ({2}).", dateString, dateValue,
                           dateValue.Kind);
      }
      catch (FormatException) {
         Console.WriteLine("'{0}' is not in an acceptable format.", dateString);
      }
      // Allow a leading space in the date string.
      try {
         dateValue = DateTime.ParseExact(dateString, "MM/dd/yyyy hh:mm", enUS, DateTimeStyles.None);
         Console.WriteLine("Converted '{0}' to {1} ({2}).", dateString, dateValue,
                           dateValue.Kind);
      }
      catch (FormatException) {
         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";
      try {
         dateValue = DateTime.ParseExact(dateString, "MM/dd/yyyy hh:mm:ss tt zzz", enUS, DateTimeStyles.None);
         Console.WriteLine("Converted '{0}' to {1} ({2}).", dateString, dateValue,
                           dateValue.Kind);
      }
      catch (FormatException) {
         Console.WriteLine("'{0}' is not in an acceptable format.", dateString);
      }
      // Allow a leading space in the date string.
      try {
         dateValue = DateTime.ParseExact(dateString, "MM/dd/yyyy hh:mm:ss tt zzz", enUS,
                                     DateTimeStyles.AdjustToUniversal);
         Console.WriteLine("Converted '{0}' to {1} ({2}).", dateString, dateValue,
                           dateValue.Kind);
      }
      catch (FormatException) {
         Console.WriteLine("'{0}' is not in an acceptable format.", dateString);
      }

      // Parse a string representing UTC.
      dateString = "2008-06-11T16:11:20.0904778Z";
      try {
         dateValue = DateTime.ParseExact(dateString, "o", CultureInfo.InvariantCulture,
                                     DateTimeStyles.None);
         Console.WriteLine("Converted '{0}' to {1} ({2}).", dateString, dateValue,
                           dateValue.Kind);
      }
      catch (FormatException) {
         Console.WriteLine("'{0}' is not in an acceptable format.", dateString);
      }
      try {
         dateValue = DateTime.ParseExact(dateString, "o", CultureInfo.InvariantCulture,
                                     DateTimeStyles.RoundtripKind);
         Console.WriteLine("Converted '{0}' to {1} ({2}).", dateString, dateValue,
                           dateValue.Kind);
      }
      catch (FormatException) {
         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).

Imports System.Globalization

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"
      Try
         dateValue = Date.ParseExact(dateString, "g", enUS, DateTimeStyles.None)
         Console.WriteLine("Converted '{0}' to {1} ({2}).", dateString, dateValue, _
                           dateValue.Kind)
      Catch e As FormatException
         Console.WriteLine("'{0}' is not in an acceptable format.", dateString)
      End Try
      ' Allow a leading space in the date string.
      Try
         dateValue = Date.ParseExact(dateString, "g", enUS, DateTimeStyles.AllowLeadingWhite)
         Console.WriteLine("Converted '{0}' to {1} ({2}).", dateString, dateValue, _
                           dateValue.Kind)
      Catch e As FormatException
         Console.WriteLine("'{0}' is not in an acceptable format.", dateString)
      End Try
      
      ' Use custom formats with M and MM.
      dateString = "5/01/2009 09:00"
      Try
         dateValue = Date.ParseExact(dateString, "M/dd/yyyy hh:mm", enUS, DateTimeStyles.None)
         Console.WriteLine("Converted '{0}' to {1} ({2}).", dateString, dateValue, _
                           dateValue.Kind)
      Catch e As FormatException
         Console.WriteLine("'{0}' is not in an acceptable format.", dateString)
      End Try
      ' Allow a leading space in the date string.
      Try
         dateValue = Date.ParseExact(dateString, "MM/dd/yyyy hh:mm", enUS, DateTimeStyles.None)
         Console.WriteLine("Converted '{0}' to {1} ({2}).", dateString, dateValue, _
                           dateValue.Kind)
      Catch e As FormatException
         Console.WriteLine("'{0}' is not in an acceptable format.", dateString)
      End Try

      ' Parse a string with time zone information.
      dateString = "05/01/2009 01:30:42 PM -05:00" 
      Try
         dateValue = Date.ParseExact(dateString, "MM/dd/yyyy hh:mm:ss tt zzz", enUS, DateTimeStyles.None)
         Console.WriteLine("Converted '{0}' to {1} ({2}).", dateString, dateValue, _
                           dateValue.Kind)
      Catch e As FormatException
         Console.WriteLine("'{0}' is not in an acceptable format.", dateString)
      End Try
      ' Allow a leading space in the date string.
      Try
         dateValue = Date.ParseExact(dateString, "MM/dd/yyyy hh:mm:ss tt zzz", enUS, _
                                     DateTimeStyles.AdjustToUniversal)
         Console.WriteLine("Converted '{0}' to {1} ({2}).", dateString, dateValue, _
                           dateValue.Kind)
      Catch e As FormatException
         Console.WriteLine("'{0}' is not in an acceptable format.", dateString)
      End Try
           
      ' Parse a string representing UTC.
      dateString = "2008-06-11T16:11:20.0904778Z"
      Try
         dateValue = Date.ParseExact(dateString, "o", CultureInfo.InvariantCulture, _
                                     DateTimeStyles.None)
         Console.WriteLine("Converted '{0}' to {1} ({2}).", dateString, dateValue, _
                           dateValue.Kind)
      Catch e As FormatException
         Console.WriteLine("'{0}' is not in an acceptable format.", dateString)
      End Try
      Try
         dateValue = Date.ParseExact(dateString, "o", CultureInfo.InvariantCulture, _
                                     DateTimeStyles.RoundtripKind)
         Console.WriteLine("Converted '{0}' to {1} ({2}).", dateString, dateValue, _
                           dateValue.Kind)
      Catch e As FormatException
         Console.WriteLine("'{0}' is not in an acceptable format.", dateString)
      End Try
   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.ParseExact(String, String, IFormatProvider, DateTimeStyles) método analisará a representação de cadeia de caracteres de uma data, que deve estar em um formato definido pelo format parâmetro . Ele também requer que os elementos de data e hora em s apareçam na ordem especificada por format . Se s não corresponder ao padrão do parâmetro, com as variações definidas pelo parâmetro format , o método style lançará um FormatException . Por outro lado, o método analisará a representação de cadeia de caracteres de uma data em qualquer um dos DateTime.Parse(String, IFormatProvider, DateTimeStyles) formatos reconhecidos pelo objeto do provedor de DateTimeFormatInfo formato. O DateTime.Parse(String, IFormatProvider, DateTimeStyles) método também permite que os elementos de data e hora em s apareçam em qualquer ordem.

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, interna 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 DateTime objeto retornado 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 para definir a Kind propriedade como DateTimeKind.Utc .

O format parâmetro define o padrão necessário do s parâmetro. Ele pode consistir em um ou mais especificadores de formato personalizados da tabela personalizada de cadeias de caracteres de formato de data e hora , ou um único especificador de formato padrão, que identifica um padrão predefinido, da tabela de 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 esteja em s conformidade com um único formato para que a operação de análise seja bem sucedido, você pode chamar o DateTime.ParseExact(String, String[], IFormatProvider, DateTimeStyles) método e especificar vários formatos permitidos. Isso torna a operação de análise mais provável de ser bem sucedido.

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 ParseExact(String, String, IFormatProvider, DateTimeStyles) 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, o tenta impedir a conversão em uma DateTime data e hora de valor com sua Kind propriedade definida como DateTimeKind.Local . Este sinalizador impede principalmente a conversão de horas UTC em horas locais.

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.

Notas aos Chamadores

no .NET Framework 4, o ParseExact método gera um FormatException se a cadeia de caracteres a ser analisada contém um componente de hora e um designador AM/PM que não estão no contrato. no .NET Framework 3,5 e versões anteriores, o designador AM/PM é ignorado.

Confira também

Aplica-se a

ParseExact(String, String[], IFormatProvider, DateTimeStyles)

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 de cadeia de caracteres deverá corresponder a, pelo menos, um dos formatos especificados exatamente ou uma exceção será gerada.

public:
 static DateTime ParseExact(System::String ^ s, cli::array <System::String ^> ^ formats, IFormatProvider ^ provider, System::Globalization::DateTimeStyles style);

public static DateTime ParseExact (string s, string[] formats, IFormatProvider provider, System.Globalization.DateTimeStyles style);

public static DateTime ParseExact (string s, string[] formats, IFormatProvider? provider, System.Globalization.DateTimeStyles style);

static member ParseExact : string * string[] * IFormatProvider * System.Globalization.DateTimeStyles -> DateTime

Public Shared Function ParseExact (s As String, formats As String(), provider As IFormatProvider, style As DateTimeStyles) As DateTime

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. Para obter mais informações, consulte a seção Comentários.

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.

Retornos

DateTime

Um objeto equivalente à data e hora contida no s, conforme especificado por formats, provider e style.

Exceções

ArgumentNullException

s ou formats é null.

FormatException

s é uma cadeia de caracteres vazia.

ou -

um elemento de formats é uma cadeia de caracteres vazia.

ou -

s não contém uma data e hora que corresponde a nenhum elemento de formats.

ou -

O componente de hora e o designador AM/PM no s não concordam.

ArgumentException

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

Exemplos

O exemplo a seguir usa o DateTime.ParseExact(String, String[], IFormatProvider, DateTimeStyles) 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",
                         "MM/d/yyyy HH:mm:ss.ffffff" };
      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",
                              "08/28/2015 16:17:39.125", "08/28/2015 16:17:39.125000" };
      DateTime dateValue;

      foreach (string dateString in dateStrings)
      {
         try {
            dateValue = DateTime.ParseExact(dateString, formats,
                                            new CultureInfo("en-US"),
                                            DateTimeStyles.None);
            Console.WriteLine("Converted '{0}' to {1}.", dateString, dateValue);
         }
         catch (FormatException) {
            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.
//       Unable to convert '08/28/2015 16:17:39.125' to a date.
//       Converted '08/28/2015 16:17:39.125000' to 8/28/2015 4:17:39 PM.

Imports System.Globalization

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",
                                 "MM/d/yyyy HH:mm:ss.ffffff" }
      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",
                                     "08/28/2015 16:17:39.125", "08/28/2015 16:17:39.125000" }

      Dim dateValue As DateTime
      
      For Each dateString As String In dateStrings
         Try
            dateValue = DateTime.ParseExact(dateString, formats, _
                                            New CultureInfo("en-US"), _
                                            DateTimeStyles.None)
            Console.WriteLine("Converted '{0}' to {1}.", dateString, dateValue)
         Catch e As FormatException
            Console.WriteLine("Unable to convert '{0}' to a date.", dateString)
         End Try                                               
      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.
'       Unable to convert '08/28/2015 16:17:39.125' to a date.
'       Converted '08/28/2015 16:17:39.125000' to 8/28/2015 4:17:39 PM.

Comentários

O DateTime.ParseExact(String, String[], IFormatProvider, DateTimeStyles) método analisa a representação da cadeia de caracteres de uma data que corresponde a qualquer um dos padrões atribuídos ao formats parâmetro. Se a cadeia de caracteres não s corresponder a um desses padrões com nenhuma das variações definidas pelo styles parâmetro, o método lançará um FormatException . Além de comparar s com vários padrões de formatação, em vez de um único padrão de formatação, essa sobrecarga se comporta de forma idêntica ao DateTime.ParseExact(String, String, IFormatProvider, DateTimeStyles) método.

O s parâmetro contém a data e a hora a serem analisados. 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, interna ou à direita além daqueles permitidos por uma das cadeias de formato no formats .

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 com sucesso. Os padrões no formats parâmetro consistem em um ou mais especificadores de formato personalizado da tabela personalizada de cadeias de caracteres de formato de data e hora , ou um único especificador de formato padrão, que identifica um padrão predefinido, da tabela de cadeias de caracteres de formato de data e hora padrão .

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, o tenta impedir a conversão em uma data e hora com sua Kind propriedade definida como DateTimeKind.Local . Este sinalizador impede principalmente a conversão de horas UTC em horas locais.

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.

Notas aos Chamadores

Confira também

Aplica-se a

Compartilhar via

DateTime.ParseExact Método

Definição

Sobrecargas

Comentários

ParseExact(String, String, IFormatProvider)

Parâmetros

Retornos

Exceções

Exemplos

Comentários

Notas aos Chamadores

Confira também

Aplica-se a

ParseExact(ReadOnlySpan<Char>, ReadOnlySpan<Char>, IFormatProvider, DateTimeStyles)

Parâmetros

Retornos

Aplica-se a

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

Parâmetros

Retornos

Aplica-se a

ParseExact(String, String, IFormatProvider, DateTimeStyles)

Parâmetros

Retornos

Exceções

Exemplos

Comentários

Notas aos Chamadores

Confira também

Aplica-se a

ParseExact(String, String[], IFormatProvider, DateTimeStyles)

Parâmetros

Retornos

Exceções

Exemplos

Comentários

Notas aos Chamadores

Confira também

Aplica-se a

Recursos adicionais