DateTime.ParseExact Método

Referencia

Definición

Espacio de nombres:: System

Ensamblado:: System.Runtime.dll

Ensamblado:: mscorlib.dll

Ensamblado:: netstandard.dll

Importante

Parte de la información hace referencia a la versión preliminar del producto, que puede haberse modificado sustancialmente antes de lanzar la versión definitiva. Microsoft no otorga ninguna garantía, explícita o implícita, con respecto a la información proporcionada aquí.

Convierte la representación de cadena especificada de una fecha y hora en el objeto DateTime equivalente. El formato de la representación de cadena debe coincidir exactamente con el formato especificado; de lo contrario, se produce una excepción.

Sobrecargas

ParseExact(String, String, IFormatProvider)	Convierte la representación de cadena especificada de una fecha y hora en el objeto DateTime equivalente, usando la información de formato específica de la referencia cultural y el formato que se hayan especificado. El formato de la representación de cadena debe coincidir exactamente con el formato especificado.
ParseExact(ReadOnlySpan<Char>, ReadOnlySpan<Char>, IFormatProvider, DateTimeStyles)	Convierte la representación de intervalo especificada de una fecha y hora en su valor DateTime equivalente, mediante el formato, la información de formato específica de la referencia cultural y el estilo especificados. El formato de la representación de cadena debe coincidir exactamente con el formato especificado; de lo contrario, se produce una excepción.
ParseExact(ReadOnlySpan<Char>, String[], IFormatProvider, DateTimeStyles)	Convierte la representación de intervalo especificada de una fecha y hora en su valor DateTime equivalente, mediante la matriz especificada de formatos, información de formato específica de la referencia cultural y estilo. El formato de la representación de cadena debe coincidir exactamente con, al menos, uno de los formatos especificados; de lo contrario se produce una excepción.
ParseExact(String, String, IFormatProvider, DateTimeStyles)	Convierte la representación de cadena especificada de una fecha y hora en el objeto DateTime equivalente, usando el formato, la información de formato específica de la referencia cultural y el estilo especificados. El formato de la representación de cadena debe coincidir exactamente con el formato especificado; de lo contrario, se produce una excepción.
ParseExact(String, String[], IFormatProvider, DateTimeStyles)	Convierte la representación de cadena especificada de una fecha y hora en el objeto DateTime equivalente, usando la matriz de formatos, la información de formato específica de la referencia cultural y el estilo especificados. El formato de la representación de cadena debe coincidir exactamente con, al menos, uno de los formatos especificados; de lo contrario se produce una excepción.

Comentarios

Importante

Las eras en los calendarios japoneses se basan en el reino del emperador y, por tanto, se espera que cambien. Por ejemplo, el 1 de mayo de 2019 marcaba el comienzo de la era Reiwa en JapaneseCalendar y JapaneseLunisolarCalendar. Este cambio de era afecta a todas las aplicaciones que usan estos calendarios. Para obtener más información y determinar si las aplicaciones se ven afectadas, vea Control de una nueva era en el calendario japonés en .NET. Para obtener información sobre cómo probar las aplicaciones en sistemas Windows para garantizar su preparación para el cambio de era, consulte Preparación de la aplicación para el cambio de era japonesa. Para ver las características de .NET que admiten calendarios con varias eras y procedimientos recomendados al trabajar con calendarios que admiten varias eras, consulte Trabajar con eras.

ParseExact(String, String, IFormatProvider)

Convierte la representación de cadena especificada de una fecha y hora en el objeto DateTime equivalente, usando la información de formato específica de la referencia cultural y el formato que se hayan especificado. El formato de la representación de cadena debe coincidir exactamente con el formato especificado.

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

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

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

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

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

Parámetros

s: String

Cadena que contiene una fecha y hora que se van a convertir.

format: String

Especificador de formato que define el formato requerido de s. Para obtener más información, vea la sección Comentarios.

provider: IFormatProvider

Objeto que proporciona información de formato específica de la referencia cultural acerca de s.

Devoluciones

DateTime

Objeto equivalente a la fecha y hora contenidas en s, tal como especifican format y provider.

Excepciones

ArgumentNullException

s o format es null.

FormatException

s o format es una cadena vacía.

O bien

s no contiene una fecha y hora que se correspondan con el patrón especificado en format.

O bien

El componente de hora y el designador AM/PM en s no coinciden.

Ejemplos

En el siguiente ejemplo se muestra el 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.

Comentarios

El DateTime.ParseExact(String, String, IFormatProvider) método analiza la representación de cadena de una fecha, que debe estar en el formato definido por el format parámetro . También requiere que los <Date> elementos y <Time> de la representación de cadena de una fecha y hora aparezcan en el orden especificado por formaty que s no tengan ningún espacio en blanco distinto del permitido por format. Si format define una fecha sin ningún elemento de hora y la operación de análisis se realiza correctamente, el valor resultante DateTime tiene una hora de medianoche (00:00:00). Si format define una hora sin ningún elemento date y la operación de análisis se realiza correctamente, el valor resultante DateTime tiene una fecha de DateTime.Now.Date.

Si s no representa una hora en una zona horaria determinada y la operación de análisis se realiza correctamente, la Kind propiedad del valor devuelto DateTime es DateTimeKind.Unspecified. Si s representa la hora de una zona horaria determinada y format permite que la información de la zona horaria esté presente (por ejemplo, si format es igual a los especificadores de formato estándar "o", "r" o "u", o si contiene los especificadores de formato personalizado "z", "zz" o "zzz"), la Kind propiedad del valor devuelto DateTime es DateTimeKind.Local.

El format parámetro es una cadena que contiene un único especificador de formato estándar o uno o varios especificadores de formato personalizado que definen el formato necesario de s. Para obtener más información sobre los códigos de formato válidos, vea Cadenas de formato de fecha y hora estándar o cadenas de formato de fecha y hora personalizados.

Nota

Si format es un patrón de formato personalizado que no incluye separadores de fecha u hora (como "aaaaMMddHHmm"), use la referencia cultural invariable para el provider parámetro y la forma más amplia de cada especificador de formato personalizado. Por ejemplo, si desea especificar horas en el patrón de formato, especifique el formato más ancho, "HH", en lugar del formulario más estrecho, "H".

Los símbolos y cadenas de fecha y hora concretos (como los nombres de los días de la semana en un idioma determinado) usados en s se definen mediante el provider parámetro , como es el formato preciso de si format es una cadena de s especificador de formato estándar. El provider parámetro puede ser cualquiera de los siguientes:

Objeto CultureInfo que representa la referencia cultural utilizada para interpretar s. El DateTimeFormatInfo objeto devuelto por su DateTimeFormat propiedad define los símbolos y el formato en s.
Objeto DateTimeFormatInfo que define el formato de los datos de fecha y hora.
Implementación personalizada IFormatProvider cuyo GetFormat método devuelve el CultureInfo objeto o el DateTimeFormatInfo objeto que proporciona información de formato.

Si provider es null, se usa el CultureInfo objeto que corresponde a la referencia cultural actual.

Notas a los autores de las llamadas

En .NET Framework 4, el ParseExact método produce un FormatException si la cadena que se va a analizar contiene un componente de hora y un designador am/PM que no están de acuerdo. En .NET Framework 3.5 y versiones anteriores, se omite el designador AM/PM.

Consulte también

Se aplica a

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

Convierte la representación de intervalo especificada de una fecha y hora en su valor DateTime equivalente, mediante el formato, la información de formato específica de la referencia cultural y el estilo especificados. El formato de la representación de cadena debe coincidir exactamente con el formato especificado; de lo contrario, se produce una excepción.

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

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

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

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

Parámetros

s: ReadOnlySpan<Char>

Un intervalo que contiene los caracteres que representan una fecha y hora que se van a convertir.

format: ReadOnlySpan<Char>

Un intervalo que contiene los caracteres que representan un especificador de formato que define el formato necesario de s.

provider: IFormatProvider

Objeto que proporciona información de formato específica de la referencia cultural acerca de s.

style: DateTimeStyles

Combinación bit a bit de los valores de enumeración que proporciona información adicional sobre s, los elementos de estilo que pueden estar presentes en s o sobre la conversión de s en un valor de DateTime. Un valor que se especifica de forma habitual es None.

Devoluciones

DateTime

Objeto equivalente a la fecha y hora contenidas en s, tal y como especifican format, provider y style.

Se aplica a

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

Convierte la representación de intervalo especificada de una fecha y hora en su valor DateTime equivalente, mediante la matriz especificada de formatos, información de formato específica de la referencia cultural y estilo. El formato de la representación de cadena debe coincidir exactamente con, al menos, uno de los formatos especificados; de lo contrario se produce una excepción.

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

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

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

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

Parámetros

s: ReadOnlySpan<Char>

Un intervalo que contiene los caracteres que representan una fecha y hora que se van a convertir.

formats: String[]

Matriz de formatos permitidos de s.

provider: IFormatProvider

Objeto que proporciona información de formato específica de la referencia cultural acerca de s.

style: DateTimeStyles

Combinación bit a bit de valores de enumeración que indica el formato permitido de s. Un valor que se especifica de forma habitual es None.

Devoluciones

DateTime

Objeto equivalente a la fecha y hora contenidas en s, tal y como especifican formats, provider y style.

Se aplica a

ParseExact(String, String, IFormatProvider, DateTimeStyles)

Convierte la representación de cadena especificada de una fecha y hora en el objeto DateTime equivalente, usando el formato, la información de formato específica de la referencia cultural y el estilo especificados. El formato de la representación de cadena debe coincidir exactamente con el formato especificado; de lo contrario, se produce una excepción.

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

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

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

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

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

Parámetros

s: String

Cadena que contiene una fecha y hora que se van a convertir.

format: String

Especificador de formato que define el formato requerido de s. Para obtener más información, vea la sección Comentarios.

provider: IFormatProvider

Objeto que proporciona información de formato específica de la referencia cultural acerca de s.

style: DateTimeStyles

Devoluciones

DateTime

Objeto equivalente a la fecha y hora contenidas en s, tal y como especifican format, provider y style.

Excepciones

ArgumentNullException

s o format es null.

FormatException

s o format es una cadena vacía.

O bien

s no contiene una fecha y hora que se correspondan con el patrón especificado en format.

O bien

El componente de hora y el designador AM/PM en s no coinciden.

ArgumentException

style contiene una combinación no válida de valores DateTimeStyles. Por ejemplo, AssumeLocal y AssumeUniversal.

Ejemplos

En el siguiente ejemplo se muestra el ParseExact(String, String, IFormatProvider) método. Tenga en cuenta que la cadena " 5/01/2009 8:30 AM" no se puede analizar correctamente cuando el styles parámetro es igual a porque los espacios iniciales no están permitidos DateTimeStyles.None por format. Además, la cadena "5/01/2009 09:00" no se puede analizar correctamente con un format valor de "MM/dd/aaaah:mm" porque la cadena de fecha no precede al número de mes con un cero a la izquierda, como format es necesario.

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

Comentarios

El DateTime.ParseExact(String, String, IFormatProvider, DateTimeStyles) método analiza la representación de cadena de una fecha, que debe estar en un formato definido por el format parámetro . También requiere que los elementos de fecha y hora aparezcan s en el orden especificado por format. Si s no coincide con el patrón del format parámetro , con las variaciones definidas por el style parámetro , el método produce un FormatException. En cambio, el DateTime.Parse(String, IFormatProvider, DateTimeStyles) método analiza la representación de cadena de una fecha en cualquiera de los formatos reconocidos por el objeto del proveedor de DateTimeFormatInfo formato. El DateTime.Parse(String, IFormatProvider, DateTimeStyles) método también permite que los elementos de fecha y hora aparezcan s en cualquier orden.

Si el s parámetro contiene solo una hora y ninguna fecha, se usa la fecha actual a menos que el style parámetro incluya la DateTimeStyles.NoCurrentDateDefault marca , en cuyo caso se usa la fecha predeterminada (DateTime.Date.MinValue). Si el s parámetro contiene solo una fecha y ninguna hora, se usa medianoche (00:00:00). El style parámetro también determina si el s parámetro puede contener caracteres de espacio en blanco inicial, interno o final.

Si s no contiene información de zona horaria, la Kind propiedad del objeto devuelto DateTime es DateTimeKind.Unspecified. Este comportamiento se puede cambiar mediante la DateTimeStyles.AssumeLocal marca , que devuelve un DateTime valor cuya Kind propiedad es DateTimeKind.Local, o mediante las DateTimeStyles.AssumeUniversal marcas y DateTimeStyles.AdjustToUniversal , que devuelve un DateTime valor cuya Kind propiedad es DateTimeKind.Utc. Si s contiene información de zona horaria, la hora se convierte en hora local, si es necesario, y la Kind propiedad del objeto devuelto DateTime se establece DateTimeKind.Localen . Este comportamiento se puede cambiar mediante la DateTimeStyles.RoundtripKind marca para no convertir la hora universal coordinada (UTC) en una hora local y para establecer la Kind propiedad DateTimeKind.Utcen .

El format parámetro define el patrón necesario del s parámetro . Puede constar de uno o varios especificadores de formato personalizado de la tabla Cadenas de formato de fecha y hora personalizados , o de un único especificador de formato estándar, que identifica un patrón predefinido, de la tabla Cadenas de formato de fecha y hora estándar .

Si no usa separadores de fecha u hora en un patrón de formato personalizado, use la referencia cultural invariable para el provider parámetro y la forma más amplia de cada especificador de formato personalizado. Por ejemplo, si desea especificar horas en el patrón, especifique el formato más ancho, "HH", en lugar del formulario más estrecho, "H".

Nota

En lugar de requerir que se ajuste a un único formato para que s la operación de análisis se realice correctamente, puede llamar al DateTime.ParseExact(String, String[], IFormatProvider, DateTimeStyles) método y especificar varios formatos permitidos. Esto hace que la operación de análisis sea más probable que se realice correctamente.

El styles parámetro incluye uno o varios miembros de la DateTimeStyles enumeración que determinan si y dónde pueden aparecer espacios en blanco no definidos por s format y que controlan el comportamiento preciso de la operación de análisis. En la tabla siguiente se describe cómo cada miembro de la DateTimeStyles enumeración afecta al funcionamiento del ParseExact(String, String, IFormatProvider, DateTimeStyles) método .

Miembro DateTimeStyles	Descripción
AdjustToUniversal	Analiza y, si es `s` necesario, lo convierte en UTC. Si `s` incluye un desplazamiento de zona horaria o si `s` no contiene información de zona horaria, pero `styles` incluye la DateTimeStyles.AssumeLocal marca , el método analiza la cadena, llama ToUniversalTime a para convertir el valor devuelto DateTime en UTC y establece la Kind propiedad DateTimeKind.Utcen . Si `s` indica que representa UTC o si `s` no contiene información de zona horaria, pero `styles` incluye la DateTimeStyles.AssumeUniversal marca , el método analiza la cadena, no realiza ninguna conversión de zona horaria en el valor devuelto DateTime y establece la Kind propiedad DateTimeKind.Utcen . En todos los demás casos, la marca no tiene ningún efecto.
AllowInnerWhite	Especifica que el espacio en blanco no definido por `format` puede aparecer entre cualquier elemento de fecha u hora individual.
AllowLeadingWhite	Especifica que el espacio en blanco no definido por `format` puede aparecer al principio de `s`.
AllowTrailingWhite	Especifica que el espacio en blanco no definido por `format` puede aparecer al final de `s`.
AllowWhiteSpaces	Especifica que `s` puede contener espacios en blanco iniciales, internos y finales no definidos por `format`.
AssumeLocal	Especifica que si `s` carece de información de zona horaria, se supone que representa una hora local. A menos que la DateTimeStyles.AdjustToUniversal marca esté presente, la Kind propiedad del valor devuelto DateTime se establece DateTimeKind.Localen .
AssumeUniversal	Especifica que si `s` carece de información de zona horaria, se supone que representa utc. A menos que la DateTimeStyles.AdjustToUniversal marca esté presente, el método convierte el valor devuelto DateTime de UTC a la hora local y establece su Kind propiedad DateTimeKind.Localen .
NoCurrentDateDefault	Si `s` contiene la hora sin información de fecha, la fecha del valor devuelto se establece en `DateTime.MinValue.Date`.
None	El `s` parámetro se analiza mediante valores predeterminados. No se permite ningún espacio en blanco que no esté presente en `format` . Si `s` carece de un componente de fecha, la fecha del valor devuelto DateTime se establece en 1/1/0001. Si `s` no contiene información de zona horaria, la Kind propiedad del objeto devuelto DateTime se establece DateTimeKind.Unspecifieden . Si la información de zona horaria está presente en `s`, la hora se convierte en hora local y la Kind propiedad del objeto devuelto DateTime se establece DateTimeKind.Localen .
RoundtripKind	En el caso de las cadenas que contienen información de zona horaria, intenta evitar la conversión a una DateTime fecha y hora de valor con su Kind propiedad establecida en DateTimeKind.Local. Esta marca evita principalmente la conversión de las horas UTC a las horas locales.

Objeto CultureInfo que representa la referencia cultural utilizada para interpretar s. El DateTimeFormatInfo objeto devuelto por su DateTimeFormat propiedad define los símbolos y el formato en s.
Objeto DateTimeFormatInfo que define el formato de los datos de fecha y hora.
Implementación personalizada IFormatProvider cuyo GetFormat método devuelve el CultureInfo objeto o el DateTimeFormatInfo objeto que proporciona información de formato.

Si provider es null, se usa el CultureInfo objeto que corresponde a la referencia cultural actual.

Notas a los autores de las llamadas

Consulte también

Se aplica a

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

Convierte la representación de cadena especificada de una fecha y hora en el objeto DateTime equivalente, usando la matriz de formatos, la información de formato específica de la referencia cultural y el estilo especificados. El formato de la representación de cadena debe coincidir exactamente con, al menos, uno de los formatos especificados; de lo contrario se produce una excepción.

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

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

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

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

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

Parámetros

s: String

Cadena que contiene una fecha y hora que se van a convertir.

formats: String[]

Matriz de formatos permitidos de s. Para obtener más información, vea la sección Comentarios.

provider: IFormatProvider

Objeto que proporciona información de formato específica de la referencia cultural acerca de s.

style: DateTimeStyles

Combinación bit a bit de valores de enumeración que indica el formato permitido de s. Un valor que se especifica de forma habitual es None.

Devoluciones

DateTime

Objeto equivalente a la fecha y hora contenidas en s, tal y como especifican formats, provider y style.

Excepciones

ArgumentNullException

s o formats es null.

FormatException

s es una cadena vacía.

o bien

un elemento de formats es una cadena vacía.

O bien

s no contiene una fecha y hora que se correspondan con ningún elemento de formats.

O bien

El componente de hora y el designador AM/PM en s no coinciden.

ArgumentException

style contiene una combinación no válida de valores DateTimeStyles. Por ejemplo, AssumeLocal y AssumeUniversal.

Ejemplos

En el ejemplo siguiente se usa el DateTime.ParseExact(String, String[], IFormatProvider, DateTimeStyles) método para asegurarse de que se puede analizar correctamente una cadena en varios formatos posibles.

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.

Comentarios

El DateTime.ParseExact(String, String[], IFormatProvider, DateTimeStyles) método analiza la representación de cadena de una fecha que coincide con cualquiera de los patrones asignados al formats parámetro . Si la cadena s no coincide con ninguno de estos patrones con ninguna de las variaciones definidas por el styles parámetro , el método produce una FormatExceptionexcepción . Además de comparar s con varios patrones de formato, en lugar de con un único patrón de formato, esta sobrecarga se comporta de forma idéntica al DateTime.ParseExact(String, String, IFormatProvider, DateTimeStyles) método .

El s parámetro contiene la fecha y hora que se va a analizar. Si el s parámetro contiene solo una hora y ninguna fecha, se usa la fecha actual a menos que el style parámetro incluya la DateTimeStyles.NoCurrentDateDefault marca , en cuyo caso se usa la fecha predeterminada (DateTime.Date.MinValue). Si el s parámetro contiene solo una fecha y ninguna hora, se usa la medianoche (00:00:00). El style parámetro también determina si el s parámetro puede contener caracteres de espacio en blanco iniciales, internos o finales distintos de los permitidos por una de las cadenas de formato de formats.

El formats parámetro contiene una matriz de patrones, uno de los cuales s debe coincidir exactamente si la operación de análisis es correcta. Los patrones del formats parámetro constan de uno o varios especificadores de formato personalizado de la tabla Cadenas de formato de fecha y hora personalizados , o un único especificador de formato estándar, que identifica un patrón predefinido, de la tabla Cadenas de formato de fecha y hora estándar .

Si no usa separadores de fecha u hora en un patrón de formato personalizado, use la referencia cultural invariable para el provider parámetro y la forma más amplia de cada especificador de formato personalizado. Por ejemplo, si desea especificar horas en el patrón, especifique la forma más ancha, "HH", en lugar del formato más estrecho, "H".

El styles parámetro incluye uno o varios miembros de la DateTimeStyles enumeración que determinan si y dónde pueden aparecer espacios en s blanco no definidos por format y que controlan el comportamiento preciso de la operación de análisis. En la tabla siguiente se describe cómo afecta cada miembro de la DateTimeStyles enumeración al funcionamiento del ParseExact(String, String, IFormatProvider, DateTimeStyles) método .

Miembro DateTimeStyles	Descripción
AdjustToUniversal	`s` Analiza y, si es necesario, lo convierte en UTC. Si `s` incluye un desplazamiento de zona horaria, o si `s` no contiene información de zona horaria, pero `styles` incluye la DateTimeStyles.AssumeLocal marca , el método analiza la cadena, llama ToUniversalTime a para convertir el valor devuelto DateTime a UTC y establece la Kind propiedad DateTimeKind.Utcen . Si `s` indica que representa utc o si `s` no contiene información de zona horaria, pero `styles` incluye la DateTimeStyles.AssumeUniversal marca , el método analiza la cadena, no realiza ninguna conversión de zona horaria en el valor devuelto DateTime y establece la Kind propiedad DateTimeKind.Utcen . En todos los demás casos, la marca no tiene ningún efecto.
AllowInnerWhite	Especifica que el espacio en blanco no definido por `format` puede aparecer entre cualquier elemento de fecha u hora individual.
AllowLeadingWhite	Especifica que el espacio en blanco no definido por `format` puede aparecer al principio de `s`.
AllowTrailingWhite	Especifica que el espacio en blanco no definido por `format` puede aparecer al final de `s`.
AllowWhiteSpaces	Especifica que `s` puede contener espacios en blanco iniciales, internos y finales no definidos por `format`.
AssumeLocal	Especifica que si `s` carece de información de zona horaria, se supone que representa una hora local. A menos que la DateTimeStyles.AdjustToUniversal marca esté presente, la Kind propiedad del valor devuelto DateTime se establece DateTimeKind.Localen .
AssumeUniversal	Especifica que si `s` carece de información de zona horaria, se supone que representa utc. A menos que la DateTimeStyles.AdjustToUniversal marca esté presente, el método convierte el valor devuelto DateTime de UTC a hora local y establece su Kind propiedad en DateTimeKind.Local.
NoCurrentDateDefault	Si `s` contiene la hora sin información de fecha, la fecha del valor devuelto se establece `DateTime.MinValue.Date`en .
None	El `s` parámetro se analiza mediante valores predeterminados. No se permite ningún espacio en blanco que no esté presente en `format` . Si `s` no tiene un componente de fecha, la fecha del valor devuelto DateTime se establece en 1/1/0001. Si `s` no contiene información de zona horaria, la Kind propiedad del objeto devuelto DateTime se establece DateTimeKind.Unspecifieden . Si la información de zona horaria está presente en , la hora se convierte en hora local y la Kind propiedad del objeto devuelto DateTime se establece DateTimeKind.Localen `s`.
RoundtripKind	En el caso de las cadenas que contienen información de zona horaria, intenta evitar la conversión a una fecha y hora con su Kind propiedad establecida en DateTimeKind.Local. Esta marca evita principalmente la conversión de las horas UTC a las horas locales.

Los símbolos y cadenas de fecha y hora concretos (como los nombres de los días de la semana en un idioma determinado) usados en s se definen mediante el provider parámetro , como es el formato preciso de s si format es una cadena de especificador de formato estándar. El provider parámetro puede ser cualquiera de los siguientes:

Objeto CultureInfo que representa la referencia cultural utilizada para interpretar s. El DateTimeFormatInfo objeto devuelto por su DateTimeFormat propiedad define los símbolos y el formato en s.
Objeto DateTimeFormatInfo que define el formato de los datos de fecha y hora.
Una implementación personalizada IFormatProvider cuyo GetFormat método devuelve el CultureInfo objeto o el DateTimeFormatInfo objeto que proporciona información de formato.

Si provider es null, se usa el CultureInfo objeto que corresponde a la referencia cultural actual.

Notas a los autores de las llamadas

En .NET Framework 4, el ParseExact método produce si FormatException la cadena que se va a analizar contiene un componente de hora y un designador am/PM que no están de acuerdo. En .NET Framework 3.5 y versiones anteriores, se omite el designador am/PM.

Consulte también

Se aplica a

Compartir vía

DateTime.ParseExact Método

Definición

Sobrecargas

Comentarios

ParseExact(String, String, IFormatProvider)

Parámetros

Devoluciones

Excepciones

Ejemplos

Comentarios

Notas a los autores de las llamadas

Consulte también

Se aplica a

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

Parámetros

Devoluciones

Se aplica a

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

Parámetros

Devoluciones

Se aplica a

ParseExact(String, String, IFormatProvider, DateTimeStyles)

Parámetros

Devoluciones

Excepciones

Ejemplos

Comentarios

Notas a los autores de las llamadas

Consulte también

Se aplica a

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

Parámetros

Devoluciones

Excepciones

Ejemplos

Comentarios

Notas a los autores de las llamadas

Consulte también

Se aplica a

Recursos adicionales