DateTime.TryParseExact Método

Definición

Espacio de nombres:

System

Ensamblado:

System.Runtime.dll

Convierte la representación de cadena especificada de una fecha y hora en su DateTime equivalente. El formato de la representación de cadena debe coincidir exactamente con un formato especificado. El método devuelve un valor que indica si la conversión se realizó correctamente.

Sobrecargas

TryParseExact(ReadOnlySpan<Char>, ReadOnlySpan<Char>, IFormatProvider, DateTimeStyles, DateTime)	Convierte la representación de intervalo especificada de una fecha y hora en su DateTime equivalente mediante el formato especificado, la información de formato específica de la referencia cultural y el estilo. El formato de la representación de cadena debe coincidir exactamente con el formato especificado. El método devuelve un valor que indica si la conversión se realizó correctamente.
TryParseExact(ReadOnlySpan<Char>, String[], IFormatProvider, DateTimeStyles, DateTime)	Convierte el intervalo de caracteres especificado de una fecha y hora en su DateTime equivalente y devuelve un valor que indica si la conversión se realizó correctamente.
TryParseExact(String, String, IFormatProvider, DateTimeStyles, DateTime)	Convierte la representación de cadena especificada de una fecha y hora en su DateTime equivalente con el formato especificado, 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. El método devuelve un valor que indica si la conversión se realizó correctamente.
TryParseExact(String, String[], IFormatProvider, DateTimeStyles, DateTime)	Convierte la representación de cadena especificada de una fecha y hora en su 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. El método devuelve un valor que indica si la conversión se realizó correctamente.

Comentarios

Importante

Las eras en los calendarios japoneses se basan en el reinado del emperador y, por tanto, se espera que cambien. Por ejemplo, el 1 de mayo de 2019 marcó el comienzo de la era Reiwa en el 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, consulte 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 Preparar la aplicación para el cambio de la era japonesa. Para ver las características de .NET que admiten calendarios con varias eras y para obtener procedimientos recomendados al trabajar con calendarios que admiten varias eras, consulte Working with eras.

TryParseExact(ReadOnlySpan<Char>, ReadOnlySpan<Char>, IFormatProvider, DateTimeStyles, DateTime)

Source:

DateTime.cs

Convierte la representación de intervalo especificada de una fecha y hora en su DateTime equivalente mediante el formato especificado, la información de formato específica de la referencia cultural y el estilo. El formato de la representación de cadena debe coincidir exactamente con el formato especificado. El método devuelve un valor que indica si la conversión se realizó correctamente.

public:
 static bool TryParseExact(ReadOnlySpan<char> s, ReadOnlySpan<char> format, IFormatProvider ^ provider, System::Globalization::DateTimeStyles style, [Runtime::InteropServices::Out] DateTime % result);

public static bool TryParseExact (ReadOnlySpan<char> s, ReadOnlySpan<char> format, IFormatProvider? provider, System.Globalization.DateTimeStyles style, out DateTime result);

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

Public Shared Function TryParseExact (s As ReadOnlySpan(Of Char), format As ReadOnlySpan(Of Char), provider As IFormatProvider, style As DateTimeStyles, ByRef result As DateTime) As Boolean

Parámetros

s

ReadOnlySpan<Char>

Intervalo que contiene los caracteres que representan una fecha y hora que se va a convertir.

format

ReadOnlySpan<Char>

El formato necesario de s.

provider

IFormatProvider

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

style

DateTimeStyles

Combinación bit a bit de uno o varios valores de enumeración que indican el formato permitido de s.

result

DateTime

Cuando este método devuelve , contiene el valor de DateTime equivalente a la fecha y hora contenida en s, si la conversión se realizó correctamente o DateTime.MinValue si se produjo un error en la conversión. Se produce un error en la conversión si el parámetro s o format es null, es una cadena vacía o no contiene una fecha y hora que se corresponda con el patrón especificado en format. Este parámetro se pasa sin inicializar.

Devoluciones

Boolean

true si s se convirtió correctamente; de lo contrario, false.

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

Source:

DateTime.cs

Convierte el intervalo de caracteres especificado de una fecha y hora en su DateTime equivalente y devuelve un valor que indica si la conversión se realizó correctamente.

public:
 static bool TryParseExact(ReadOnlySpan<char> s, cli::array <System::String ^> ^ formats, IFormatProvider ^ provider, System::Globalization::DateTimeStyles style, [Runtime::InteropServices::Out] DateTime % result);

public static bool TryParseExact (ReadOnlySpan<char> s, string?[]? formats, IFormatProvider? provider, System.Globalization.DateTimeStyles style, out DateTime result);

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

Public Shared Function TryParseExact (s As ReadOnlySpan(Of Char), formats As String(), provider As IFormatProvider, style As DateTimeStyles, ByRef result As DateTime) As Boolean

Parámetros

s

ReadOnlySpan<Char>

Intervalo que contiene la cadena que se va a analizar.

formats

String[]

Matriz de formatos permitidos de s.

provider

IFormatProvider

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

style

DateTimeStyles

Combinación bit a bit de valores de enumeración que define cómo interpretar la fecha analizada en relación con la zona horaria actual o la fecha actual. Un valor típico que se debe especificar es None.

result

DateTime

Cuando este método devuelve , contiene el valor de DateTime equivalente a la fecha y hora contenida en s, si la conversión se realizó correctamente o DateTime.MinValue si se produjo un error en la conversión. Se produce un error en la conversión si el parámetro s es null, es Emptyo no contiene una representación de cadena válida de una fecha y hora. Este parámetro se pasa sin inicializar.

Devoluciones

Boolean

true si el parámetro s se convirtió correctamente; de lo contrario, false.

TryParseExact(String, String, IFormatProvider, DateTimeStyles, DateTime)

Source:

DateTime.cs

Convierte la representación de cadena especificada de una fecha y hora en su DateTime equivalente con el formato especificado, 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. El método devuelve un valor que indica si la conversión se realizó correctamente.

public:
 static bool TryParseExact(System::String ^ s, System::String ^ format, IFormatProvider ^ provider, System::Globalization::DateTimeStyles style, [Runtime::InteropServices::Out] DateTime % result);

public static bool TryParseExact (string? s, string? format, IFormatProvider? provider, System.Globalization.DateTimeStyles style, out DateTime result);

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

Public Shared Function TryParseExact (s As String, format As String, provider As IFormatProvider, style As DateTimeStyles, ByRef result As DateTime) As Boolean

Parámetros

s

String

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

format

String

El formato necesario de s.

provider

IFormatProvider

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

style

DateTimeStyles

Combinación bit a bit de uno o varios valores de enumeración que indican el formato permitido de s.

result

DateTime

Cuando este método devuelve , contiene el valor de DateTime equivalente a la fecha y hora contenida en s, si la conversión se realizó correctamente o DateTime.MinValue si se produjo un error en la conversión. Se produce un error en la conversión si el parámetro s o format es null, es una cadena vacía o no contiene una fecha y hora que se corresponda con el patrón especificado en format. Este parámetro se pasa sin inicializar.

Devoluciones

Boolean

true si s se convirtió correctamente; de lo contrario, false.

Excepciones

ArgumentException

style no es un valor de DateTimeStyles válido.

-o-

style contiene una combinación no válida de valores de DateTimeStyles (por ejemplo, tanto AssumeLocal como AssumeUniversal).

Ejemplos

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

using System;
using System.Globalization;

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

      // Parse date with no style flags.
      dateString = " 5/01/2009 8:30 AM";
      if (DateTime.TryParseExact(dateString, "g", enUS,
                                 DateTimeStyles.None, out dateValue))
         Console.WriteLine("Converted '{0}' to {1} ({2}).", dateString, dateValue,
                           dateValue.Kind);
      else
         Console.WriteLine("'{0}' is not in an acceptable format.", dateString);

      // Allow a leading space in the date string.
      if (DateTime.TryParseExact(dateString, "g", enUS,
                                 DateTimeStyles.AllowLeadingWhite, out dateValue))
         Console.WriteLine("Converted '{0}' to {1} ({2}).", dateString, dateValue,
                           dateValue.Kind);
      else
         Console.WriteLine("'{0}' is not in an acceptable format.", dateString);

      // Use custom formats with M and MM.
      dateString = "5/01/2009 09:00";
      if (DateTime.TryParseExact(dateString, "M/dd/yyyy hh:mm", enUS,
                                 DateTimeStyles.None, out dateValue))
         Console.WriteLine("Converted '{0}' to {1} ({2}).", dateString, dateValue,
                           dateValue.Kind);
      else
         Console.WriteLine("'{0}' is not in an acceptable format.", dateString);

      // Allow a leading space in the date string.
      if (DateTime.TryParseExact(dateString, "MM/dd/yyyy hh:mm", enUS,
                              DateTimeStyles.None, out dateValue))
         Console.WriteLine("Converted '{0}' to {1} ({2}).", dateString, dateValue,
                           dateValue.Kind);
      else
         Console.WriteLine("'{0}' is not in an acceptable format.", dateString);

      // Parse a string with time zone information.
      dateString = "05/01/2009 01:30:42 PM -05:00";
      if (DateTime.TryParseExact(dateString, "MM/dd/yyyy hh:mm:ss tt zzz", enUS,
                              DateTimeStyles.None, out dateValue))
         Console.WriteLine("Converted '{0}' to {1} ({2}).", dateString, dateValue,
                           dateValue.Kind);
      else
         Console.WriteLine("'{0}' is not in an acceptable format.", dateString);

      // Allow a leading space in the date string.
      if (DateTime.TryParseExact(dateString, "MM/dd/yyyy hh:mm:ss tt zzz", enUS,
                              DateTimeStyles.AdjustToUniversal, out dateValue))
         Console.WriteLine("Converted '{0}' to {1} ({2}).", dateString, dateValue,
                           dateValue.Kind);
      else
         Console.WriteLine("'{0}' is not in an acceptable format.", dateString);

      // Parse a string representing UTC.
      dateString = "2008-06-11T16:11:20.0904778Z";
      if (DateTime.TryParseExact(dateString, "o", CultureInfo.InvariantCulture,
                                     DateTimeStyles.None, out dateValue))
         Console.WriteLine("Converted '{0}' to {1} ({2}).", dateString, dateValue,
                           dateValue.Kind);
      else
         Console.WriteLine("'{0}' is not in an acceptable format.", dateString);

      if (DateTime.TryParseExact(dateString, "o", CultureInfo.InvariantCulture,
                                 DateTimeStyles.RoundtripKind, out dateValue))
         Console.WriteLine("Converted '{0}' to {1} ({2}).", dateString, dateValue,
                           dateValue.Kind);
      else
         Console.WriteLine("'{0}' is not in an acceptable format.", dateString);
   }
}
// The example displays the following output:
//    ' 5/01/2009 8:30 AM' is not in an acceptable format.
//    Converted ' 5/01/2009 8:30 AM' to 5/1/2009 8:30:00 AM (Unspecified).
//    Converted '5/01/2009 09:00' to 5/1/2009 9:00:00 AM (Unspecified).
//    '5/01/2009 09:00' is not in an acceptable format.
//    Converted '05/01/2009 01:30:42 PM -05:00' to 5/1/2009 11:30:42 AM (Local).
//    Converted '05/01/2009 01:30:42 PM -05:00' to 5/1/2009 6:30:42 PM (Utc).
//    Converted '2008-06-11T16:11:20.0904778Z' to 6/11/2008 9:11:20 AM (Local).
//    Converted '2008-06-11T16:11:20.0904778Z' to 6/11/2008 4:11:20 PM (Utc).

open System
open System.Globalization

[<EntryPoint>]
let main _ =
    let enUS = CultureInfo "en-US"

    // Parse date with no style flags.
    let dateString = " 5/01/2009 8:30 AM"
    match DateTime.TryParseExact(dateString, "g", enUS, DateTimeStyles.None) with
    | true, dateValue ->
        printfn $"Converted '{dateString}' to {dateValue} ({dateValue.Kind})."              
    | _ ->
        printfn $"'{dateString}' is not in an acceptable format."

    // Allow a leading space in the date string.
    match DateTime.TryParseExact(dateString, "g", enUS, DateTimeStyles.AllowLeadingWhite) with
    | true, dateValue ->
        printfn $"Converted '{dateString}' to {dateValue} ({dateValue.Kind})."
    | _ ->
        printfn $"'{dateString}' is not in an acceptable format."

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

    // Allow a leading space in the date string.
    match DateTime.TryParseExact(dateString, "MM/dd/yyyy hh:mm", enUS, DateTimeStyles.None) with
    | true, dateValue ->
        printfn $"Converted '{dateString}' to {dateValue} ({dateValue.Kind})."
    | _ ->
        printfn $"'{dateString}' is not in an acceptable format."

    // Parse a string with time zone information.
    let dateString = "05/01/2009 01:30:42 PM -05:00"
    match DateTime.TryParseExact(dateString, "MM/dd/yyyy hh:mm:ss tt zzz", enUS, DateTimeStyles.None) with
    | true, dateValue ->
        printfn $"Converted '{dateString}' to {dateValue} ({dateValue.Kind})."
    | _ ->
        printfn $"'{dateString}' is not in an acceptable format."

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

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

    match DateTime.TryParseExact(dateString, "o", CultureInfo.InvariantCulture, DateTimeStyles.RoundtripKind) with
    | true, dateValue ->
        printfn $"Converted '{dateString}' to {dateValue} ({dateValue.Kind})."
    | _ ->
        printfn $"'{dateString}' is not in an acceptable format."

    0

    // The example displays the following output:
    //    ' 5/01/2009 8:30 AM' is not in an acceptable format.
    //    Converted ' 5/01/2009 8:30 AM' to 5/1/2009 8:30:00 AM (Unspecified).
    //    Converted '5/01/2009 09:00' to 5/1/2009 9:00:00 AM (Unspecified).
    //    '5/01/2009 09:00' is not in an acceptable format.
    //    Converted '05/01/2009 01:30:42 PM -05:00' to 5/1/2009 11:30:42 AM (Local).
    //    Converted '05/01/2009 01:30:42 PM -05:00' to 5/1/2009 6:30:42 PM (Utc).
    //    Converted '2008-06-11T16:11:20.0904778Z' to 6/11/2008 9:11:20 AM (Local).
    //    Converted '2008-06-11T16:11:20.0904778Z' to 6/11/2008 4:11:20 PM (Utc).

Imports System.Globalization

Public Module Example
   Public Sub Main()
      Dim enUS As New CultureInfo("en-US") 
      Dim dateString As String
      Dim dateValue As Date
      
      ' Parse date with no style flags.
      dateString = " 5/01/2009 8:30 AM"
      If Date.TryParseExact(dateString, "g", enUS, _
                            DateTimeStyles.None, dateValue) Then
         Console.WriteLine("Converted '{0}' to {1} ({2}).", dateString, dateValue, _
                           dateValue.Kind)
      Else
         Console.WriteLine("'{0}' is not in an acceptable format.", dateString)
      End If
      ' Allow a leading space in the date string.
      If Date.TryParseExact(dateString, "g", enUS, _
                            DateTimeStyles.AllowLeadingWhite, dateValue) Then
         Console.WriteLine("Converted '{0}' to {1} ({2}).", dateString, dateValue, _
                           dateValue.Kind)
      Else
         Console.WriteLine("'{0}' is not in an acceptable format.", dateString)
      End If
      
      ' Use custom formats with M and MM.
      dateString = "5/01/2009 09:00"
      If Date.TryParseExact(dateString, "M/dd/yyyy hh:mm", enUS, _
                            DateTimeStyles.None, dateValue) Then
         Console.WriteLine("Converted '{0}' to {1} ({2}).", dateString, dateValue, _
                           dateValue.Kind)
      Else
         Console.WriteLine("'{0}' is not in an acceptable format.", dateString)
      End If
      ' Allow a leading space in the date string.
      If Date.TryParseExact(dateString, "MM/dd/yyyy hh:mm", enUS, _
                            DateTimeStyles.None, dateValue) Then
         Console.WriteLine("Converted '{0}' to {1} ({2}).", dateString, dateValue, _
                           dateValue.Kind)
      Else
         Console.WriteLine("'{0}' is not in an acceptable format.", dateString)
      End If

      ' Parse a string with time zone information.
      dateString = "05/01/2009 01:30:42 PM -05:00" 
      If Date.TryParseExact(dateString, "MM/dd/yyyy hh:mm:ss tt zzz", enUS, _
                            DateTimeStyles.None, dateValue) Then
         Console.WriteLine("Converted '{0}' to {1} ({2}).", dateString, dateValue, _
                           dateValue.Kind)
      Else
         Console.WriteLine("'{0}' is not in an acceptable format.", dateString)
      End If
      ' Allow a leading space in the date string.
      If Date.TryParseExact(dateString, "MM/dd/yyyy hh:mm:ss tt zzz", enUS, _
                            DateTimeStyles.AdjustToUniversal, dateValue) Then
         Console.WriteLine("Converted '{0}' to {1} ({2}).", dateString, dateValue, _
                           dateValue.Kind)
      Else
         Console.WriteLine("'{0}' is not in an acceptable format.", dateString)
      End If
           
      ' Parse a string representing UTC.
      dateString = "2008-06-11T16:11:20.0904778Z"
      If Date.TryParseExact(dateString, "o", CultureInfo.InvariantCulture, _
                                     DateTimeStyles.None, dateValue) Then
         Console.WriteLine("Converted '{0}' to {1} ({2}).", dateString, dateValue, _
                           dateValue.Kind)
      Else
         Console.WriteLine("'{0}' is not in an acceptable format.", dateString)
      End If
      
      If Date.TryParseExact(dateString, "o", CultureInfo.InvariantCulture, _
                            DateTimeStyles.RoundtripKind, dateValue) Then
         Console.WriteLine("Converted '{0}' to {1} ({2}).", dateString, dateValue, _
                           dateValue.Kind)
      Else
         Console.WriteLine("'{0}' is not in an acceptable format.", dateString)
      End If
   End Sub
End Module
' The example displays the following output:
'    ' 5/01/2009 8:30 AM' is not in an acceptable format.
'    Converted ' 5/01/2009 8:30 AM' to 5/1/2009 8:30:00 AM (Unspecified).
'    Converted '5/01/2009 09:00' to 5/1/2009 9:00:00 AM (Unspecified).
'    '5/01/2009 09:00' is not in an acceptable format.
'    Converted '05/01/2009 01:30:42 PM -05:00' to 5/1/2009 11:30:42 AM (Local).
'    Converted '05/01/2009 01:30:42 PM -05:00' to 5/1/2009 6:30:42 PM (Utc).
'    Converted '2008-06-11T16:11:20.0904778Z' to 6/11/2008 9:11:20 AM (Local).
'    Converted '2008-06-11T16:11:20.0904778Z' to 6/11/2008 4:11:20 PM (Utc).

Comentarios

El método DateTime.TryParseExact(String, String, IFormatProvider, DateTimeStyles, DateTime) analiza la representación de cadena de una fecha, que debe estar en el formato definido por el parámetro format. Es similar al método DateTime.ParseExact(String, String, IFormatProvider, DateTimeStyles), salvo que el método TryParseExact(String, String, IFormatProvider, DateTimeStyles, DateTime) no produce una excepción si se produce un error en la conversión.

El parámetro s contiene la fecha y hora para analizar y debe estar en un formato definido por el parámetro format. Si los elementos de fecha, hora y zona horaria están presentes en s, también deben aparecer en el orden especificado 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 de DateTime resultante tiene una hora de medianoche (00:00:00). Si format define una hora sin elemento date y la operación de análisis se realiza correctamente, el valor de DateTime resultante tiene de forma predeterminada una fecha de DateTime.Now.Dateo tiene una fecha de DateTime.MinValue.Date si styles incluye la marca DateTimeStyles.NoCurrentDateDefault. El parámetro style determina si el parámetro s puede contener caracteres de espacio en blanco iniciales, internos o finales.

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

El parámetro format contiene un patrón que corresponde al formato esperado del parámetro s. El patrón del parámetro format consta de uno o varios especificadores de formato personalizado de la tabla Cadenas de formato de fecha y hora personalizados tabla, 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 parámetro provider 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 amplio, "HH", en lugar del formato más estrecho, "H".

Nota

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

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 parámetro provider, tal como es el formato preciso de s si format es una cadena de especificador de formato estándar. El parámetro provider puede ser cualquiera de los siguientes:

• Objeto CultureInfo que representa la referencia cultural utilizada para interpretar s. El objeto DateTimeFormatInfo devuelto por su propiedad DateTimeFormat 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 de IFormatProvider personalizada cuyo método GetFormat devuelve el objeto CultureInfo o el objeto DateTimeFormatInfo que proporciona información de formato.

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

El parámetro styles incluye uno o varios miembros de la enumeración DateTimeStyles que determinan si y dónde pueden aparecer espacios en blanco no definidos por format en s 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 enumeración DateTimeStyles afecta al funcionamiento del método TryParseExact(String, String, IFormatProvider, DateTimeStyles, DateTime).

Miembro DateTimeStyles	Descripción
AdjustToUniversal	Analiza s 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 marca DateTimeStyles.AssumeLocal, el método analiza la cadena, llama a ToUniversalTime para convertir el valor de DateTime devuelto a UTC y establece la propiedad Kind en DateTimeKind.Utc. Si s indica que representa UTC, o si s no contiene información de zona horaria, pero styles incluye la marca DateTimeStyles.AssumeUniversal, el método analiza la cadena, no realiza ninguna conversión de zona horaria en el valor de DateTime devuelto y establece la propiedad Kind en DateTimeKind.Utc. 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 o 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 pueden 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 marca de DateTimeStyles.AdjustToUniversal esté presente, la propiedad Kind del valor de DateTime devuelto se establece en DateTimeKind.Local.
AssumeUniversal	Especifica que si s carece de información de zona horaria, se supone que representa utc. A menos que la marca DateTimeStyles.AdjustToUniversal esté presente, el método convierte el valor de DateTime devuelto de UTC a hora local y establece su propiedad Kind en DateTimeKind.Local.
NoCurrentDateDefault	Si s contiene la hora sin información de fecha, la fecha del valor devuelto se establece en DateTime.MinValue.Date.
None	El parámetro s se analiza mediante valores predeterminados. No se permite ningún espacio en blanco distinto del 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 propiedad Kind del objeto de DateTime devuelto se establece en DateTimeKind.Unspecified. Si la información de zona horaria está presente en s, la hora se convierte en hora local y la propiedad Kind del objeto de DateTime devuelto se establece en DateTimeKind.Local.
RoundtripKind	En el caso de las cadenas que contienen información de zona horaria, intenta evitar la conversión a un valor de DateTime con su propiedad Kind establecida en DateTimeKind.Local. Esta marca evita principalmente la conversión de las horas UTC a las horas locales.

Notas a los autores de las llamadas

En .NET Framework 4, el método TryParseExact devuelve false 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

• ParseExact
• CultureInfo
• DateTimeFormatInfo
• analizar cadenas de fecha y hora en el de .NET Framework
• cadenas de formato de fecha y hora estándar
• cadenas de formato de fecha y hora personalizados

TryParseExact(String, String[], IFormatProvider, DateTimeStyles, DateTime)

Source:

DateTime.cs

Convierte la representación de cadena especificada de una fecha y hora en su 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. El método devuelve un valor que indica si la conversión se realizó correctamente.

public:
 static bool TryParseExact(System::String ^ s, cli::array <System::String ^> ^ formats, IFormatProvider ^ provider, System::Globalization::DateTimeStyles style, [Runtime::InteropServices::Out] DateTime % result);

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

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

Public Shared Function TryParseExact (s As String, formats As String(), provider As IFormatProvider, style As DateTimeStyles, ByRef result As DateTime) As Boolean

Parámetros

s

String

Cadena que contiene una fecha y hora que se va 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 sobre s.

style

DateTimeStyles

Combinación bit a bit de valores de enumeración que indica el formato permitido de s. Un valor típico que se debe especificar es None.

result

DateTime

Cuando este método devuelve , contiene el valor de DateTime equivalente a la fecha y hora contenida en s, si la conversión se realizó correctamente o DateTime.MinValue si se produjo un error en la conversión. Se produce un error en la conversión si s o formats es null, s o un elemento de formats es una cadena vacía o el formato de s no es exactamente el especificado por al menos uno de los patrones de formato en formats. Este parámetro se pasa sin inicializar.

Devoluciones

Boolean

true si el parámetro s se convirtió correctamente; de lo contrario, false.

Excepciones

ArgumentException

style no es un valor de DateTimeStyles válido.

-o-

style contiene una combinación no válida de valores de DateTimeStyles (por ejemplo, tanto AssumeLocal como AssumeUniversal).

Ejemplos

En el ejemplo siguiente se usa el método DateTime.TryParseExact(String, String, IFormatProvider, DateTimeStyles, DateTime) para asegurarse de que una cadena en un número de formatos posibles se puede analizar correctamente.

using System;
using System.Globalization;

public class Example
{
   public static void Main()
   {
      string[] formats= {"M/d/yyyy h:mm:ss tt", "M/d/yyyy h:mm tt",
                         "MM/dd/yyyy hh:mm:ss", "M/d/yyyy h:mm:ss",
                         "M/d/yyyy hh:mm tt", "M/d/yyyy hh tt",
                         "M/d/yyyy h:mm", "M/d/yyyy h:mm",
                         "MM/dd/yyyy hh:mm", "M/dd/yyyy hh:mm"};
      string[] dateStrings = {"5/1/2009 6:32 PM", "05/01/2009 6:32:05 PM",
                              "5/1/2009 6:32:00", "05/01/2009 06:32",
                              "05/01/2009 06:32:00 PM", "05/01/2009 06:32:00"};
      DateTime dateValue;

      foreach (string dateString in dateStrings)
      {
         if (DateTime.TryParseExact(dateString, formats,
                                    new CultureInfo("en-US"),
                                    DateTimeStyles.None,
                                    out dateValue))
            Console.WriteLine("Converted '{0}' to {1}.", dateString, dateValue);
         else
            Console.WriteLine("Unable to convert '{0}' to a date.", dateString);
      }
   }
}
// The example displays the following output:
//       Converted '5/1/2009 6:32 PM' to 5/1/2009 6:32:00 PM.
//       Converted '05/01/2009 6:32:05 PM' to 5/1/2009 6:32:05 PM.
//       Converted '5/1/2009 6:32:00' to 5/1/2009 6:32:00 AM.
//       Converted '05/01/2009 06:32' to 5/1/2009 6:32:00 AM.
//       Converted '05/01/2009 06:32:00 PM' to 5/1/2009 6:32:00 PM.
//       Converted '05/01/2009 06:32:00' to 5/1/2009 6:32:00 AM.

open System
open System.Globalization

let formats= 
    [| "M/d/yyyy h:mm:ss tt"; "M/d/yyyy h:mm tt"
       "MM/dd/yyyy hh:mm:ss"; "M/d/yyyy h:mm:ss"
       "M/d/yyyy hh:mm tt"; "M/d/yyyy hh tt"
       "M/d/yyyy h:mm"; "M/d/yyyy h:mm"
       "MM/dd/yyyy hh:mm"; "M/dd/yyyy hh:mm" |]

let dateStrings = 
    [ "5/1/2009 6:32 PM"; "05/01/2009 6:32:05 PM"
      "5/1/2009 6:32:00"; "05/01/2009 06:32"
      "05/01/2009 06:32:00 PM"; "05/01/2009 06:32:00" ]

for dateString in dateStrings do
    match DateTime.TryParseExact(dateString, formats, CultureInfo "en-US", DateTimeStyles.None) with
    | true, dateValue ->
        printfn $"Converted '{dateString}' to {dateValue}."
    | _ ->
        printfn $"Unable to convert '{dateString}' to a date."


// The example displays the following output:
//       Converted '5/1/2009 6:32 PM' to 5/1/2009 6:32:00 PM.
//       Converted '05/01/2009 6:32:05 PM' to 5/1/2009 6:32:05 PM.
//       Converted '5/1/2009 6:32:00' to 5/1/2009 6:32:00 AM.
//       Converted '05/01/2009 06:32' to 5/1/2009 6:32:00 AM.
//       Converted '05/01/2009 06:32:00 PM' to 5/1/2009 6:32:00 PM.
//       Converted '05/01/2009 06:32:00' to 5/1/2009 6:32:00 AM.

Imports System.Globalization

Public Module Example
   Public Sub Main()
      Dim formats() As String = {"M/d/yyyy h:mm:ss tt", "M/d/yyyy h:mm tt", _
                                 "MM/dd/yyyy hh:mm:ss", "M/d/yyyy h:mm:ss", _
                                 "M/d/yyyy hh:mm tt", "M/d/yyyy hh tt", _
                                 "M/d/yyyy h:mm", "M/d/yyyy h:mm", _
                                 "MM/dd/yyyy hh:mm", "M/dd/yyyy hh:mm"}
      Dim dateStrings() As String = {"5/1/2009 6:32 PM", "05/01/2009 6:32:05 PM", _
                                     "5/1/2009 6:32:00", "05/01/2009 06:32", _
                                     "05/01/2009 06:32:00 PM", "05/01/2009 06:32:00"} 

      Dim dateValue As DateTime
      
      For Each dateString As String In dateStrings
         If Date.TryParseExact(dateString, formats, _
                               New CultureInfo("en-US"), _
                               DateTimeStyles.None, _
                               dateValue) Then
            Console.WriteLine("Converted '{0}' to {1}.", dateString, dateValue)
         Else
            Console.WriteLine("Unable to convert '{0}' to a date.", dateString)
         End If                                               
      Next
   End Sub   
End Module
' The example displays the following output:
'       Converted '5/1/2009 6:32 PM' to 5/1/2009 6:32:00 PM.
'       Converted '05/01/2009 6:32:05 PM' to 5/1/2009 6:32:05 PM.
'       Converted '5/1/2009 6:32:00' to 5/1/2009 6:32:00 AM.
'       Converted '05/01/2009 06:32' to 5/1/2009 6:32:00 AM.
'       Converted '05/01/2009 06:32:00 PM' to 5/1/2009 6:32:00 PM.
'       Converted '05/01/2009 06:32:00' to 5/1/2009 6:32:00 AM.

Comentarios

El método DateTime.TryParseExact(String, String[], IFormatProvider, DateTimeStyles, DateTime) analiza la representación de cadena de una fecha que coincide con cualquiera de los patrones asignados al parámetro formats. Es como el método DateTime.ParseExact(String, String[], IFormatProvider, DateTimeStyles), excepto que el método TryParseExact no produce una excepción si se produce un error en la conversión.

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

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

El parámetro formats 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 parámetro formats constan de uno o varios especificadores de formato personalizado de la cadenas de formato de fecha y hora personalizados tabla, o un único especificador de formato estándar, que identifica un patrón predefinido, de la cadena de formato de fecha y hora estándar tabla.

Si no usa separadores de fecha u hora en un patrón de formato personalizado, use la referencia cultural invariable para el parámetro provider 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 amplio, "HH", en lugar del formato 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 parámetro provider, tal como es el formato preciso de s si format es una cadena de especificador de formato estándar. El parámetro provider puede ser cualquiera de los siguientes:

• Objeto CultureInfo que representa la referencia cultural utilizada para interpretar s. El objeto DateTimeFormatInfo devuelto por su propiedad DateTimeFormat 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 de IFormatProvider personalizada cuyo método GetFormat devuelve el objeto CultureInfo o el objeto DateTimeFormatInfo que proporciona información de formato.

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

El parámetro styles incluye uno o varios miembros de la enumeración DateTimeStyles que determinan si y dónde pueden aparecer espacios en blanco no definidos por format en s 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 enumeración DateTimeStyles afecta al funcionamiento del método TryParseExact(String, String[], IFormatProvider, DateTimeStyles, DateTime).

Miembro DateTimeStyles	Descripción
AdjustToUniversal	Analiza s 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 marca DateTimeStyles.AssumeLocal, el método analiza la cadena, llama a ToUniversalTime para convertir el valor de DateTime devuelto a UTC y establece la propiedad Kind en DateTimeKind.Utc. Si s indica que representa UTC, o si s no contiene información de zona horaria, pero styles incluye la marca DateTimeStyles.AssumeUniversal, el método analiza la cadena, no realiza ninguna conversión de zona horaria en el valor de DateTime devuelto y establece la propiedad Kind en DateTimeKind.Utc. 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 o 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 pueden 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 marca de DateTimeStyles.AdjustToUniversal esté presente, la propiedad Kind del valor de DateTime devuelto se establece en DateTimeKind.Local.
AssumeUniversal	Especifica que si s carece de información de zona horaria, se supone que representa utc. A menos que la marca DateTimeStyles.AdjustToUniversal esté presente, el método convierte el valor de DateTime devuelto de UTC a hora local y establece su propiedad Kind en DateTimeKind.Local.
NoCurrentDateDefault	Si s contiene la hora sin información de fecha, la fecha del valor devuelto se establece en DateTime.MinValue.Date.
None	El parámetro s se analiza mediante valores predeterminados. No se permite ningún espacio en blanco distinto del 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 propiedad Kind del objeto de DateTime devuelto se establece en DateTimeKind.Unspecified. Si la información de zona horaria está presente en s, la hora se convierte en hora local y la propiedad Kind del objeto de DateTime devuelto se establece en DateTimeKind.Local.
RoundtripKind	En el caso de las cadenas que contienen información de zona horaria, intenta evitar la conversión a un valor de DateTime con su propiedad Kind establecida en DateTimeKind.Local. Esta marca evita principalmente la conversión de las horas UTC a las horas locales.

Notas a los autores de las llamadas

En .NET Framework 4, el método TryParseExact devuelve false 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

• ParseExact
• CultureInfo
• DateTimeFormatInfo
• analizar cadenas de fecha y hora en el de .NET Framework
• cadenas de formato de fecha y hora estándar
• cadenas de formato de fecha y hora personalizados