DateTime.ParseExact Método

public:
 static DateTime ParseExact(System::String ^ s, System::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

Devoluções

Um objeto que é equivalente à data e hora contidas em s, conforme especificado por format e provider.

Exceções

Exemplos

O exemplo seguinte 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.

open System
open System.Globalization

[<EntryPoint>]
let main _ =
    let provider = CultureInfo.InvariantCulture

    // Parse date-only value with invariant culture.
    let dateString = "06/15/2008"
    let format = "d"
    try
        let result = DateTime.ParseExact(dateString, format, provider)
        printfn $"{dateString} converts to {result}."
    with :? FormatException ->
        printfn $"{dateString} is not in the correct format."

    // 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.
    let dateString = "6/15/2008"
    try
        let result = DateTime.ParseExact(dateString, format, provider)
        printfn $"{dateString} converts to {result}."
    with :? FormatException ->
        printfn $"{dateString} is not in the correct format."

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

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

    let dateString = "15/06/2008 08:30"
    let format = "g"
    let provider = CultureInfo "fr-FR"
    try
        let result = DateTime.ParseExact(dateString, format, provider)
        printfn $"{dateString} converts to {result}."
    with :? FormatException ->
        printfn $"{dateString} is not in the correct format."

    // Parse a date that includes seconds and milliseconds
    // by using the French (France) and invariant cultures.
    let dateString = "18/08/2015 06:30:15.006542"
    let format = "dd/MM/yyyy HH:mm:ss.ffffff"
    try
        let result = DateTime.ParseExact(dateString, format, provider)
        printfn $"{dateString} converts to {result}."
    with :? FormatException ->
        printfn $"{dateString} is not in the correct format."

    0

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

Observações

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

Se s não representa uma hora num determinado fuso horário e a operação de análise sintática tem sucesso, a Kind propriedade do valor devolvido DateTime é DateTimeKind.Unspecified. Se s representa a hora num determinado fuso horário e format permite a presença de informação sobre o fuso horário (por exemplo, se format for igual aos especificadores de formato padrão "o", "r" ou "u", ou se contiver os especificadores personalizados de formato "z", "zz" ou "zzz"), a Kind propriedade do valor devolvido DateTime é DateTimeKind.Local.

O format parâmetro é uma cadeia que contém ou um único especificador de formato padrão, ou um ou mais especificadores de formato personalizados que definem o formato necessário de s. Para detalhes sobre códigos de formatação válidos, consulte Strings de Formato de Data e Hora Padrão ou Strings de Formato de Data e Hora Personalizados.

Os símbolos e cadeias particulares de data e hora (como nomes dos dias da semana numa determinada língua) usados em s são definidos pelo provider parâmetro, assim como o formato preciso de s se format for uma cadeia de especificação de formato padrão. O provider parâmetro pode ser qualquer um dos seguintes:

• Um CultureInfo objeto que representa a cultura usada para interpretar s. O DateTimeFormatInfo objeto devolvido pela sua DateTimeFormat propriedade define os símbolos e a formatação em s.

• Um DateTimeFormatInfo objeto que define o formato dos dados de data e hora.

• Uma implementação personalizada IFormatProvider cujo GetFormat método devolve ou o CultureInfo objeto ou o DateTimeFormatInfo objeto que fornece informação de formatação.

Se provider for null, o CultureInfo objeto que corresponde à cultura atual é usado.

Notas para Chamadores

No .NET Framework 4, o método ParseExact lança um FormatException se a cadeia a analisar contiver um componente de hora e um designador AM/PM que não estejam em concordância. No .NET Framework 3.5 e versões anteriores, o designador AM/PM é ignorado.

Ver também

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

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

Devoluções

Um objeto que é equivalente à data e hora contidas em s, conforme especificado por format, provider, e style.

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

Devoluções

Um objeto que é equivalente à data e hora contidas em s, conforme especificado por formats, provider, e style.

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

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

Devoluções

Um objeto que é equivalente à data e hora contidas em s, conforme especificado por format, provider, e style.

Exceções

Exemplos

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

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

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"
    try
        let dateValue = DateTime.ParseExact(dateString, "g", enUS, DateTimeStyles.None)
        printfn $"Converted '{dateString}' to {dateValue} ({dateValue.Kind})."
    with :? FormatException ->
        printfn $"'{dateString}' is not in an acceptable format."
    
    // Allow a leading space in the date string.
    try
        let dateValue = DateTime.ParseExact(dateString, "g", enUS, DateTimeStyles.AllowLeadingWhite)
        printfn $"Converted '{dateString}' to {dateValue} ({dateValue.Kind})."
    with :? FormatException ->
        printfn $"'{dateString}' is not in an acceptable format."

    // Use custom formats with M and MM.
    let dateString = "5/01/2009 09:00"
    try
        let dateValue = DateTime.ParseExact(dateString, "M/dd/yyyy hh:mm", enUS, DateTimeStyles.None)
        printfn $"Converted '{dateString}' to {dateValue} ({dateValue.Kind})."
    with :? FormatException ->
        printfn $"'{dateString}' is not in an acceptable format."

    // Allow a leading space in the date string.
    try
        let dateValue = DateTime.ParseExact(dateString, "MM/dd/yyyy hh:mm", enUS, DateTimeStyles.None)
        printfn $"Converted '{dateString}' to {dateValue} ({dateValue.Kind})."
    with :? FormatException ->
        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"
    try
        let dateValue = DateTime.ParseExact(dateString, "MM/dd/yyyy hh:mm:ss tt zzz", enUS, DateTimeStyles.None)
        printfn $"Converted '{dateString}' to {dateValue} ({dateValue.Kind})."
    with :? FormatException ->
        printfn $"'{dateString}' is not in an acceptable format."

    // Allow a leading space in the date string.
    try
        let dateValue = DateTime.ParseExact(dateString, "MM/dd/yyyy hh:mm:ss tt zzz", enUS, DateTimeStyles.AdjustToUniversal)
        printfn $"Converted '{dateString}' to {dateValue} ({dateValue.Kind})."
    with :? FormatException ->
        printfn $"'{dateString}' is not in an acceptable format."

    // Parse a string representing UTC.
    let dateString = "2008-06-11T16:11:20.0904778Z"
    try
        let dateValue = DateTime.ParseExact(dateString, "o", CultureInfo.InvariantCulture, DateTimeStyles.None)
        printfn $"Converted '{dateString}' to {dateValue} ({dateValue.Kind})."
    with :? FormatException ->
        printfn $"'{dateString}' is not in an acceptable format."

    try
        let dateValue = DateTime.ParseExact(dateString, "o", CultureInfo.InvariantCulture, DateTimeStyles.RoundtripKind)
        printfn $"Converted '{dateString}' to {dateValue} ({dateValue.Kind})."
    with :? FormatException ->
        printfn $"'{dateString}' is not in an acceptable format."


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

Observações

O DateTime.ParseExact(String, String, IFormatProvider, DateTimeStyles) método analisa a representação da string de uma data, que deve estar num formato definido pelo format parâmetro. 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 format parâmetro, com quaisquer variações definidas pelo style parâmetro, o método gera um FormatException. Em contraste, o DateTime.Parse(String, IFormatProvider, DateTimeStyles) método analisa a representação da string de uma data em qualquer um dos formatos reconhecidos pelo objeto do DateTimeFormatInfo fornecedor de formatos. O DateTime.Parse(String, IFormatProvider, DateTimeStyles) método também permite que os elementos de data e hora apareçam s em qualquer ordem.

Se o s parâmetro contiver apenas uma hora e nenhuma data, a data atual é usada, a menos que o style parâmetro inclua a DateTimeStyles.NoCurrentDateDefault bandeira, caso em que é usada a data padrão (DateTime.Date.MinValue). Se o s parâmetro contiver apenas uma data e nenhuma hora, usa-se a meia-noite (00:00:00). O style parâmetro também determina se pode s conter caracteres de espaço em branco à frente, interior ou final.

Se s não contiver informação de fuso horário, a Kind propriedade do objeto devolvido DateTime é DateTimeKind.Unspecified. Este comportamento pode ser alterado usando o DateTimeStyles.AssumeLocal flag, que devolve um DateTime valor cuja Kind propriedade é DateTimeKind.Local, ou usando os DateTimeStyles.AssumeUniversal flags e DateTimeStyles.AdjustToUniversal , que devolve um DateTime valor cuja Kind propriedade é DateTimeKind.Utc. Se s contiver informação de fuso horário, a hora é convertida para hora local, se necessário, e a Kind propriedade do objeto devolvido DateTime é definida para DateTimeKind.Local. Este comportamento pode ser alterado usando o DateTimeStyles.RoundtripKind flag para não converter o Tempo Universal Coordenado (UTC) para uma hora local e definindo a Kind propriedade para DateTimeKind.Utc.

O format parâmetro define o padrão necessário do s parâmetro. Pode consistir num ou mais especificadores de formato personalizados da tabela de Cadeias de Formato de Data e Hora Personalizadas , ou num único especificador de formato padrão, que identifica um padrão pré-definido, a partir da tabela de Cadeias de Formato de Data e Hora Padrão .

Se não usar separadores de data ou hora num padrão de formato personalizado, use a cultura invariante para o provider parâmetro e a forma mais larga de cada especificador de formato personalizado. Por exemplo, se quiseres especificar as horas no padrão, especifica a forma mais ampla, "HH", em vez da forma mais estreita, "H".

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

Membro DateTimeStyles	Description
AdjustToUniversal	Analisa s e, se necessário, converte-o para UTC. Se s incluir um deslocamento de fuso horário, ou se s não contiver informações de fuso horário, mas styles incluir o DateTimeStyles.AssumeLocal sinalizador, o método analisará a cadeia de caracteres, chamará ToUniversalTime para converter o valor retornado DateTime em UTC e definirá a Kind propriedade como DateTimeKind.Utc. Se s indicar que ele representa UTC, ou se s não contém informações de fuso horário, mas styles inclui o DateTimeStyles.AssumeUniversal sinalizador, o método analisa a cadeia de caracteres, não executa nenhuma conversão de fuso horário no valor retornado DateTime e define a Kind propriedade como DateTimeKind.Utc. Em todos os outros casos, a bandeira não tem efeito.
AllowInnerWhite	Especifica que um espaço em branco não definido por format pode aparecer entre qualquer elemento individual de data ou hora.
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 pode conter espaços brancos à frente, interior e final não definidos por format.
AssumeLocal	Especifica que, se s não houver informações de fuso horário, presume-se que elas representem uma hora local. A menos que o DateTimeStyles.AdjustToUniversal sinalizador esteja presente, a Kind propriedade do valor retornado DateTime é definida como DateTimeKind.Local.
AssumeUniversal	Especifica que, se s não contiver informações de fuso horário, presume-se que representa UTC. A menos que o DateTimeStyles.AdjustToUniversal sinalizador esteja presente, o método converte o valor retornado DateTime de UTC para a hora local e define sua Kind propriedade como DateTimeKind.Local.
NoCurrentDateDefault	Se s contiver tempo sem informação de data, a data do valor de retorno é definida para DateTime.MinValue.Date.
None	O s parâmetro é analisado usando valores padrão. Não é permitido nenhum espaço em branco além do presente em format . Se s não houver componente de data, a data do valor devolvido DateTime é definida como 1/1/0001. Se s não contiver informação de fuso horário, a Kind propriedade do objeto devolvido DateTime é definida para DateTimeKind.Unspecified. Se a informação do fuso horário estiver presente em s, a hora é convertida para hora local e a Kind propriedade do objeto devolvido DateTime é definida para DateTimeKind.Local.
RoundtripKind	Para strings que contêm informação de fuso horário, tenta impedir a conversão para uma DateTime data e hora de valor com a sua Kind propriedade definida para DateTimeKind.Local. Esta bandeira impede principalmente a conversão dos horários UTC para os horários locais.

Os símbolos e cadeias de data e hora em particular (como os nomes dos dias da semana numa determinada língua) usados em s são definidos pelo provider parâmetro, assim como o formato preciso de s se format for uma cadeia de especificação de formato padrão. O provider parâmetro pode ser qualquer um dos seguintes:

• Um CultureInfo objeto que representa a cultura usada para interpretar s. O DateTimeFormatInfo objeto devolvido pela sua DateTimeFormat propriedade define os símbolos e a formatação em s.

• Um DateTimeFormatInfo objeto que define o formato dos dados de data e hora.

• Uma implementação personalizada IFormatProvider cujo GetFormat método devolve ou o CultureInfo objeto ou o DateTimeFormatInfo objeto que fornece informação de formatação.

Se provider for null, o CultureInfo objeto que corresponde à cultura atual é usado.

Notas para Chamadores

No .NET Framework 4, o método ParseExact lança um FormatException se a cadeia a analisar contiver um componente de hora e um designador AM/PM que não estejam em concordância. No .NET Framework 3.5 e versões anteriores, o designador AM/PM é ignorado.

Ver também

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

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

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

Devoluções

Um objeto que é equivalente à data e hora contidas em s, conforme especificado por formats, provider, e style.

Exceções

Exemplos

O exemplo seguinte utiliza o DateTime.ParseExact(String, String[], IFormatProvider, DateTimeStyles) método para garantir que uma cadeia em vários formatos possíveis pode ser analisada com sucesso.

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.

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"
       "MM/d/yyyy HH:mm:ss.ffffff" |]

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"
      "08/28/2015 16:17:39.125"; "08/28/2015 16:17:39.125000" ]

for dateString in dateStrings do
    try
        let dateValue = DateTime.ParseExact(dateString, formats, CultureInfo "en-US", DateTimeStyles.None)
        printfn $"Converted '{dateString}' to {dateValue}."
    with :? FormatException ->
        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.
//       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.

Observações

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

O s parâmetro contém a data e a hora para analisar. Se o s parâmetro contiver apenas uma hora e nenhuma data, a data atual é usada, a menos que o style parâmetro inclua a DateTimeStyles.NoCurrentDateDefault bandeira, caso em que é usada a data padrão (DateTime.Date.MinValue). Se o s parâmetro contiver apenas uma data e nenhuma hora, usa-se a meia-noite (00:00:00). O style parâmetro também determina se o s parâmetro pode conter caracteres de espaço em branco à frente, interior ou final diferentes daqueles permitidos por uma das cadeias de formato em formats.

Se s não contiver informação de fuso horário, a Kind propriedade do objeto devolvido DateTime é DateTimeKind.Unspecified. Este comportamento pode ser alterado usando o DateTimeStyles.AssumeLocal flag, que devolve um DateTime valor cuja Kind propriedade é DateTimeKind.Local, ou usando os DateTimeStyles.AssumeUniversal flags e DateTimeStyles.AdjustToUniversal , que devolve um DateTime valor cuja Kind propriedade é DateTimeKind.Utc. Se s contiver informação de fuso horário, a hora é convertida para hora local, se necessário, e a Kind propriedade do objeto devolvido DateTime é definida para DateTimeKind.Local. Este comportamento pode ser alterado usando a DateTimeStyles.RoundtripKind flag para não converter o Tempo Universal Coordenado (UTC) para uma hora local e definir a Kind propriedade para DateTimeKind.Utc.

O formats parâmetro contém um array de padrões, um dos quais s deve corresponder exatamente para que a operação de análise sintética tenha sucesso. Os padrões no formats parâmetro consistem num ou mais especificadores de formato personalizados da tabela de Cadeias de Formato de Data e Hora Personalizadas , ou num único especificador de formato padrão, que identifica um padrão pré-definido, a partir da tabela de Strings de Formato de Data e Hora Padrão .

Se não usar separadores de data ou hora num padrão de formato personalizado, use a cultura invariante para o provider parâmetro e a forma mais larga de cada especificador de formato personalizado. Por exemplo, se quiseres especificar as horas no padrão, especifica a forma mais ampla, "HH", em vez da forma mais estreita, "H".

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

Membro DateTimeStyles	Description
AdjustToUniversal	Analisa s e, se necessário, converte-o para UTC. Se s incluir um deslocamento de fuso horário, ou se s não contiver informações de fuso horário, mas styles incluir o DateTimeStyles.AssumeLocal sinalizador, o método analisará a cadeia de caracteres, chamará ToUniversalTime para converter o valor retornado DateTime em UTC e definirá a Kind propriedade como DateTimeKind.Utc. Se s indicar que ele representa UTC, ou se s não contém informações de fuso horário, mas styles inclui o DateTimeStyles.AssumeUniversal sinalizador, o método analisa a cadeia de caracteres, não executa nenhuma conversão de fuso horário no valor retornado DateTime e define a Kind propriedade como DateTimeKind.Utc. Em todos os outros casos, a bandeira não tem efeito.
AllowInnerWhite	Especifica que um espaço em branco não definido por format pode aparecer entre qualquer elemento individual de data ou hora.
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 pode conter espaços brancos à frente, interior e final não definidos por format.
AssumeLocal	Especifica que, se s não houver informações de fuso horário, presume-se que elas representem uma hora local. A menos que o DateTimeStyles.AdjustToUniversal sinalizador esteja presente, a Kind propriedade do valor retornado DateTime é definida como DateTimeKind.Local.
AssumeUniversal	Especifica que, se s não contiver informações de fuso horário, presume-se que representa UTC. A menos que o DateTimeStyles.AdjustToUniversal sinalizador esteja presente, o método converte o valor retornado DateTime de UTC para a hora local e define sua Kind propriedade como DateTimeKind.Local.
NoCurrentDateDefault	Se s contiver tempo sem informação de data, a data do valor de retorno é definida para DateTime.MinValue.Date.
None	O s parâmetro é analisado usando valores padrão. Não é permitido nenhum espaço em branco além do presente em format . Se s não houver componente de data, a data do valor devolvido DateTime é definida como 1/1/0001. Se s não contiver informação de fuso horário, a Kind propriedade do objeto devolvido DateTime é definida para DateTimeKind.Unspecified. Se a informação do fuso horário estiver presente em s, a hora é convertida para hora local e a Kind propriedade do objeto devolvido DateTime é definida para DateTimeKind.Local.
RoundtripKind	Para strings que contêm informação de fuso horário, tenta impedir a conversão para uma data e hora com a sua Kind propriedade definida como DateTimeKind.Local. Esta bandeira impede principalmente a conversão dos horários UTC para os horários locais.

Os símbolos e cadeias de data e hora em particular (como os nomes dos dias da semana numa determinada língua) usados em s são definidos pelo provider parâmetro, assim como o formato preciso de s se format for uma cadeia de especificação de formato padrão. O provider parâmetro pode ser qualquer um dos seguintes:

• Um CultureInfo objeto que representa a cultura usada para interpretar s. O DateTimeFormatInfo objeto devolvido pela sua DateTimeFormat propriedade define os símbolos e a formatação em s.

• Um DateTimeFormatInfo objeto que define o formato dos dados de data e hora.

• Uma implementação personalizada IFormatProvider cujo GetFormat método devolve ou o CultureInfo objeto ou o DateTimeFormatInfo objeto que fornece informação de formatação.

Se provider for null, o CultureInfo objeto que corresponde à cultura atual é usado.

Notas para Chamadores

No .NET Framework 4, o método ParseExact lança um FormatException se a cadeia a analisar contiver um componente de hora e um designador AM/PM que não estejam em concordância. No .NET Framework 3.5 e versões anteriores, o designador AM/PM é ignorado.

Ver também

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