DateTime.TryParseExact Método

Referencia

Definición

Espacio de nombres:: System

Ensamblado:: System.Runtime.dll

Ensamblado:: netstandard.dll

Ensamblado:: mscorlib.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 un formato ya 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 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. 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 valor DateTime equivalente y devuelve un valor que indica si la conversión se ha realizado correctamente.
TryParseExact(String, String, IFormatProvider, DateTimeStyles, DateTime)	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. 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 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. 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 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, 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 Preparación de la aplicación para el cambio en la era japonesa. Para conocer 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.

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

Source:: DateTime.cs

Source:: DateTime.cs

Source:: DateTime.cs

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

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>

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

format: ReadOnlySpan<Char>

Formato requerido 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 uno o varios valores de enumeración que indica el formato permitido de s.

result: DateTime

Cuando este método devuelve , contiene el DateTime valor 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 producirá un error en la conversión cuando el parámetro s o format sea null, una cadena vacía o no contenga una fecha y una hora que correspondan al modelo especificado en format. Este parámetro se pasa sin inicializar.

Devoluciones

Boolean

true si s se convirtió correctamente; en caso contrario, false.

Se aplica a

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

Source:: DateTime.cs

Source:: DateTime.cs

Source:: DateTime.cs

Convierte el intervalo de caracteres especificado de una fecha y hora en su valor DateTime equivalente y devuelve un valor que indica si la conversión se ha realizado 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);

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>

El intervalo que contiene los bytes que se van 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 acerca de s.

style: DateTimeStyles

Combinación bit a bit de valores de enumeración que define cómo se va a interpretar la fecha analizada respecto a la zona horaria actual o la fecha actual. Un valor que se especifica de forma habitual es None.

result: DateTime

Cuando este método devuelve , contiene el DateTime valor 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, Empty o no contiene ninguna 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 convierte correctamente; en caso contrario, false.

Se aplica a

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

Source:: DateTime.cs

Source:: DateTime.cs

Source:: DateTime.cs

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

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 van a convertir.

format: String

Formato requerido 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 uno o varios valores de enumeración que indica el formato permitido de s.

result: DateTime

Devoluciones

Boolean

true si s se convirtió correctamente; en caso contrario, false.

Excepciones

ArgumentException

styles no es un valor DateTimeStyles válido.

o bien

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

Ejemplos

En el siguiente ejemplo se muestra el DateTime.TryParseExact(String, String, IFormatProvider, DateTimeStyles, DateTime) 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";
      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 DateTime.TryParseExact(String, String, IFormatProvider, DateTimeStyles, DateTime) método analiza la representación de cadena de una fecha, que debe estar en el formato definido por el format parámetro . Es similar al DateTime.ParseExact(String, String, IFormatProvider, DateTimeStyles) método , salvo que el TryParseExact(String, String, IFormatProvider, DateTimeStyles, DateTime) método no produce una excepción si se produce un error en la conversión.

El s parámetro contiene la fecha y hora de análisis y debe estar en un formato definido por el format parámetro . 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 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 de forma predeterminada una fecha de DateTime.Now.Dateo tiene una fecha de DateTime.MinValue.Date si styles incluye la DateTimeStyles.NoCurrentDateDefault marca . El style parámetro 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 establecer la Kind propiedad DateTimeKind.Utcen .

El format parámetro contiene un patrón que corresponde al formato esperado del s parámetro . El patrón del format parámetro consta 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 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.TryParseExact(String, String[], IFormatProvider, DateTimeStyles, DateTime) método 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 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.

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 sformat 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 TryParseExact(String, String, IFormatProvider, DateTimeStyles, DateTime) 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 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 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 un DateTime valor con su Kind propiedad 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 TryParseExact método 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

Se aplica a

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

Source:: DateTime.cs

Source:: DateTime.cs

Source:: DateTime.cs

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

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

result: DateTime

Cuando este método devuelve , contiene el DateTime valor 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 producirá un error en la conversión cuando s o formats sea null, cuando s o un elemento de formats sea una cadena vacía, o cuando el formato de s no coincida exactamente con al menos uno de los modelos de formato de formats. Este parámetro se pasa sin inicializar.

Devoluciones

Boolean

true si el parámetro s se convierte correctamente; en caso contrario, false.

Excepciones

ArgumentException

styles no es un valor DateTimeStyles válido.

o bien

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

Ejemplos

En el ejemplo siguiente se usa el DateTime.TryParseExact(String, String, IFormatProvider, DateTimeStyles, DateTime) 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"};
      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 DateTime.TryParseExact(String, String[], IFormatProvider, DateTimeStyles, DateTime) método analiza la representación de cadena de una fecha que coincide con cualquiera de los patrones asignados al formats parámetro . Es como el DateTime.ParseExact(String, String[], IFormatProvider, DateTimeStyles) método , excepto que el TryParseExact método no produce una excepción si se produce un error en la conversión.

El s parámetro contiene la fecha y hora de análisis. 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 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, una de las 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 .

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.

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 sformat 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 TryParseExact(String, String[], IFormatProvider, DateTimeStyles, DateTime) 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 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 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 un DateTime valor con su Kind propiedad 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

Consulte también

Se aplica a

DateTime.TryParseExact Método

Definición

Sobrecargas

Comentarios

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

Parámetros

Devoluciones

Se aplica a

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

Parámetros

Devoluciones

Se aplica a

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

Parámetros

Devoluciones

Excepciones

Ejemplos

Comentarios

Notas a los autores de las llamadas

Consulte también

Se aplica a

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

Parámetros

Devoluciones

Excepciones

Ejemplos

Comentarios

Notas a los autores de las llamadas

Consulte también

Se aplica a

Comentarios

Recursos adicionales