DateTime.ParseExact Método

Origem:

DateTime.cs

Origem:

DateTime.cs

Origem:

DateTime.cs

Origem:

DateTime.cs

Origem:

DateTime.cs

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

Retornos

Um objeto equivalente à data e hora contidas, sconforme especificado por format e provider.

Exceções

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.

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.

Comentários

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

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

O format parâmetro é uma cadeia de caracteres que contém um único especificador de formato padrão ou um ou mais especificadores de formato personalizado que definem o formato necessário 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.

Os símbolos e cadeias de caracteres de data e hora específicos (como nomes dos dias da semana em um idioma específico) usados s são definidos pelo provider parâmetro, assim como o formato preciso de se format for uma cadeia de caracteres do especificador de s 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 retornado por 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 retorna o CultureInfo objeto ou o DateTimeFormatInfo objeto que fornece informações de formatação.

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

Notas aos Chamadores

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

Confira também

• TryParseExact
• CultureInfo
• DateTimeFormatInfo
• Analisando cadeias de caracteres de data e hora no .NET Framework
• Cadeias de Caracteres de Formato de Data e Hora Padrão
• Personalizar a cadeia de caracteres de formato de data e hora

Origem:

DateTime.cs

Origem:

DateTime.cs

Origem:

DateTime.cs

Origem:

DateTime.cs

Origem:

DateTime.cs

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

Retornos

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

Origem:

DateTime.cs

Origem:

DateTime.cs

Origem:

DateTime.cs

Origem:

DateTime.cs

Origem:

DateTime.cs

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

Retornos

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

Origem:

DateTime.cs

Origem:

DateTime.cs

Origem:

DateTime.cs

Origem:

DateTime.cs

Origem:

DateTime.cs

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

Retornos

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

Exceções

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 porque espaços à esquerda não são permitidos DateTimeStyles.None por format. Além disso, a cadeia de caracteres "01/05/2009 09:00" não pode ser analisada com êxito com um format "MM/dd/yyyyhh:mm" porque a cadeia de caracteres de data não precede o número do mês com um zero à esquerda, conforme format necessário.

using System;
using System.Globalization;

public class Example
{
   public static void Main()
   {
      CultureInfo enUS = new CultureInfo("en-US");
      string dateString;
      DateTime dateValue;

      // Parse date with no style flags.
      dateString = " 5/01/2009 8:30 AM";
      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).

Comentários

O DateTime.ParseExact(String, String, IFormatProvider, DateTimeStyles) método analisa a representação de cadeia de caracteres de uma data, que deve estar em um formato definido pelo format parâmetro. Também requer que os elementos s de data e hora 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 gerará um FormatException. Por outro lado, o DateTime.Parse(String, IFormatProvider, DateTimeStyles) método analisa a representação de cadeia de caracteres de uma data em qualquer um dos 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 apareçam em s 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, internos ou à direita.

Se s não contiver informações de fuso horário, a Kind propriedade do objeto retornado DateTime será DateTimeKind.Unspecified. Esse comportamento pode ser alterado usando o DateTimeStyles.AssumeLocal sinalizador, que retorna um DateTime valor cuja Kind propriedade é DateTimeKind.Local, ou usando o e DateTimeStyles.AdjustToUniversal sinalizadoresDateTimeStyles.AssumeUniversal, que retorna um DateTime valor cuja Kind propriedade é DateTimeKind.Utc. Se s contiver informações de fuso horário, a hora será convertida em hora local, se necessário, e a Kind propriedade do objeto retornado DateTime será definida como DateTimeKind.Local. Esse comportamento pode ser alterado usando o DateTimeStyles.RoundtripKind sinalizador para não converter UTC (Tempo Universal Coordenado) em uma hora local e 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 personalizado da tabela Cadeias de Caracteres de Formato de Data e Hora Personalizado ou um único especificador de formato padrão, que identifica um padrão predefinido, na tabela Cadeias de Caracteres de Formato de Data e Hora Padrão .

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

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

Os símbolos e cadeias de caracteres de data e hora específicos (como os nomes dos dias da semana em um idioma específico) usados s são definidos pelo provider parâmetro, assim como o formato preciso de se format for uma cadeia de caracteres do especificador de s 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 retornado por 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 retorna o CultureInfo objeto ou o DateTimeFormatInfo objeto que fornece informações de formatação.

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

Notas aos Chamadores

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

Confira também

• TryParseExact
• CultureInfo
• DateTimeFormatInfo
• Analisando cadeias de caracteres de data e hora no .NET Framework
• Cadeias de Caracteres de Formato de Data e Hora Padrão
• Personalizar a cadeia de caracteres de formato de data e hora

Origem:

DateTime.cs

Origem:

DateTime.cs

Origem:

DateTime.cs

Origem:

DateTime.cs

Origem:

DateTime.cs

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

Retornos

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

Exceções

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.

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.

Comentários

O DateTime.ParseExact(String, String[], IFormatProvider, DateTimeStyles) método analisa a representação de cadeia de caracteres de uma data que corresponde a qualquer um dos padrões atribuídos ao formats parâmetro. Se a cadeia s de caracteres não corresponder a nenhum desses padrões com qualquer uma das variações definidas pelo styles parâmetro, o método gerará um FormatException. Além de comparar com s 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 analisadas. Se o s parâmetro contiver apenas uma hora e nenhuma data, a data atual será usada, a menos que o style parâmetro inclua o DateTimeStyles.NoCurrentDateDefault sinalizador, nesse caso, a data padrão (DateTime.Date.MinValue) será usada. Se o s parâmetro contiver apenas uma data e nenhuma hora, meia-noite (00:00:00) será usada. O style parâmetro também determina se o s parâmetro pode conter caracteres de espaço em branco à esquerda, internos ou à direita diferentes daqueles permitidos por uma das cadeias de caracteres de formato em formats.

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

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

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

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

Os símbolos e cadeias de caracteres de data e hora específicos (como os nomes dos dias da semana em um idioma específico) usados s são definidos pelo provider parâmetro, assim como o formato preciso de se format for uma cadeia de caracteres do especificador de s 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 retornado por 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 retorna o CultureInfo objeto ou o DateTimeFormatInfo objeto que fornece informações de formatação.

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

Notas aos Chamadores

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

Confira também

• TryParseExact
• CultureInfo
• DateTimeFormatInfo
• Analisando cadeias de caracteres de data e hora no .NET Framework
• Cadeias de Caracteres de Formato de Data e Hora Padrão
• Personalizar a cadeia de caracteres de formato de data e hora