Compartir vía

DateTimeOffset.TryParseExact Método

  • Referencia

Definición

Espacio de nombres:
System
Ensamblado:
System.Runtime.dll
Ensamblado:
mscorlib.dll
Ensamblado:
netstandard.dll

Convierte la representación de cadena especificada de una fecha y hora en su DateTimeOffset equivalente. El formato de la representación de cadena debe coincidir exactamente con un formato especificado.

Sobrecargas

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

Convierte la representación de cadena especificada de una fecha y hora en su DateTimeOffset 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 uno de los formatos especificados.
TryParseExact(ReadOnlySpan<Char>, ReadOnlySpan<Char>, IFormatProvider, DateTimeStyles, DateTimeOffset)

Convierte la representación de una fecha y hora en un intervalo de caracteres en su DateTimeOffset 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 fecha y hora debe coincidir exactamente con el formato especificado.
TryParseExact(ReadOnlySpan<Char>, String[], IFormatProvider, DateTimeStyles, DateTimeOffset)

Convierte la representación de una fecha y hora en un intervalo de caracteres en su DateTimeOffset equivalente mediante los formatos especificados, la información de formato específica de la referencia cultural y el estilo. El formato de la representación de fecha y hora debe coincidir exactamente con uno de los formatos especificados.
TryParseExact(String, String, IFormatProvider, DateTimeStyles, DateTimeOffset)

Convierte la representación de cadena especificada de una fecha y hora en su DateTimeOffset 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.

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

Source:
DateTimeOffset.cs
Source:
DateTimeOffset.cs
Source:
DateTimeOffset.cs

Convierte la representación de cadena especificada de una fecha y hora en su DateTimeOffset 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 uno de los formatos especificados.

public:
 static bool TryParseExact(System::String ^ input, cli::array <System::String ^> ^ formats, IFormatProvider ^ formatProvider, System::Globalization::DateTimeStyles styles, [Runtime::InteropServices::Out] DateTimeOffset % result);
public static bool TryParseExact (string input, string[] formats, IFormatProvider formatProvider, System.Globalization.DateTimeStyles styles, out DateTimeOffset result);
public static bool TryParseExact (string? input, string?[]? formats, IFormatProvider? formatProvider, System.Globalization.DateTimeStyles styles, out DateTimeOffset result);
static member TryParseExact : string * string[] * IFormatProvider * System.Globalization.DateTimeStyles * DateTimeOffset -> bool
Public Shared Function TryParseExact (input As String, formats As String(), formatProvider As IFormatProvider, styles As DateTimeStyles, ByRef result As DateTimeOffset) As Boolean

Parámetros

input
String

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

formats
String[]

Matriz que define los formatos esperados de input.

formatProvider
IFormatProvider

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

styles
DateTimeStyles

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

result
DateTimeOffset

Cuando el método devuelve , contiene el DateTimeOffset equivalente a la fecha y hora de input, si la conversión se realizó correctamente o DateTimeOffset.MinValue, si se produjo un error en la conversión. Se produce un error en la conversión si el input no contiene una representación de cadena válida de una fecha y hora, o no contiene la fecha y hora en el formato esperado definido por formatso si formats es null. Este parámetro se pasa sin inicializar.

Devoluciones

Boolean

true si el parámetro input se convierte correctamente; de lo contrario, false.

Excepciones

ArgumentException

styles incluye un valor de DateTimeStyles indefinido.

-o-

no se admite NoCurrentDateDefault.

-o-

styles incluye valores de DateTimeStyles mutuamente excluyentes.

Ejemplos

En el ejemplo siguiente se definen varios formatos de entrada para la representación de cadena de un valor de fecha y hora y desplazamiento y, a continuación, se pasa la cadena especificada por el usuario al método TryParseExact(String, String[], IFormatProvider, DateTimeStyles, DateTimeOffset).

TextReader conIn = Console.In;
TextWriter conOut = Console.Out;
int tries = 0;
string input = String.Empty;

string[] formats = new string[] {"M/dd/yyyy HH:m zzz", "MM/dd/yyyy HH:m zzz",
                                 "M/d/yyyy HH:m zzz", "MM/d/yyyy HH:m zzz",
                                 "M/dd/yy HH:m zzz", "MM/dd/yy HH:m zzz",
                                 "M/d/yy HH:m zzz", "MM/d/yy HH:m zzz",
                                 "M/dd/yyyy H:m zzz", "MM/dd/yyyy H:m zzz",
                                 "M/d/yyyy H:m zzz", "MM/d/yyyy H:m zzz",
                                 "M/dd/yy H:m zzz", "MM/dd/yy H:m zzz",
                                 "M/d/yy H:m zzz", "MM/d/yy H:m zzz",
                                 "M/dd/yyyy HH:mm zzz", "MM/dd/yyyy HH:mm zzz",
                                 "M/d/yyyy HH:mm zzz", "MM/d/yyyy HH:mm zzz",
                                 "M/dd/yy HH:mm zzz", "MM/dd/yy HH:mm zzz",
                                 "M/d/yy HH:mm zzz", "MM/d/yy HH:mm zzz",
                                 "M/dd/yyyy H:mm zzz", "MM/dd/yyyy H:mm zzz",
                                 "M/d/yyyy H:mm zzz", "MM/d/yyyy H:mm zzz",
                                 "M/dd/yy H:mm zzz", "MM/dd/yy H:mm zzz",
                                 "M/d/yy H:mm zzz", "MM/d/yy H:mm zzz"};
IFormatProvider provider = CultureInfo.InvariantCulture.DateTimeFormat;
DateTimeOffset result;

do {
   conOut.WriteLine("Enter a date, time, and offset (MM/DD/YYYY HH:MM +/-HH:MM),");
   conOut.Write("Then press Enter: ");
   input = conIn.ReadLine();
   conOut.WriteLine();
   if (DateTimeOffset.TryParseExact(input, formats, provider,
                                   DateTimeStyles.AllowWhiteSpaces,
                                   out result))
   {
      break;
   }
   else
   {
      Console.WriteLine("Unable to parse {0}.", input);
      tries++;
   }
} while (tries < 3);
if (tries >= 3)
   Console.WriteLine("Exiting application without parsing {0}", input);
else
   Console.WriteLine("{0} was converted to {1}", input, result.ToString());
// Some successful sample interactions with the user might appear as follows:
//    Enter a date, time, and offset (MM/DD/YYYY HH:MM +/-HH:MM),
//    Then press Enter: 12/08/2007 6:54 -6:00
//
//    12/08/2007 6:54 -6:00 was converted to 12/8/2007 6:54:00 AM -06:00
//
//    Enter a date, time, and offset (MM/DD/YYYY HH:MM +/-HH:MM),
//    Then press Enter: 12/8/2007 06:54 -06:00
//
//    12/8/2007 06:54 -06:00 was converted to 12/8/2007 6:54:00 AM -06:00
//
//    Enter a date, time, and offset (MM/DD/YYYY HH:MM +/-HH:MM),
//    Then press Enter: 12/5/07 6:54 -6:00
//
//    12/5/07 6:54 -6:00 was converted to 12/5/2007 6:54:00 AM -06:00

let mutable result = None    
let mutable tries = 0
let mutable input = ""

let formats = 
    [| "M/dd/yyyy HH:m zzz"; "MM/dd/yyyy HH:m zzz"
       "M/d/yyyy HH:m zzz"; "MM/d/yyyy HH:m zzz"
       "M/dd/yy HH:m zzz"; "MM/dd/yy HH:m zzz"
       "M/d/yy HH:m zzz"; "MM/d/yy HH:m zzz"
       "M/dd/yyyy H:m zzz"; "MM/dd/yyyy H:m zzz"
       "M/d/yyyy H:m zzz"; "MM/d/yyyy H:m zzz"
       "M/dd/yy H:m zzz"; "MM/dd/yy H:m zzz"
       "M/d/yy H:m zzz"; "MM/d/yy H:m zzz"
       "M/dd/yyyy HH:mm zzz"; "MM/dd/yyyy HH:mm zzz"
       "M/d/yyyy HH:mm zzz"; "MM/d/yyyy HH:mm zzz"
       "M/dd/yy HH:mm zzz"; "MM/dd/yy HH:mm zzz"
       "M/d/yy HH:mm zzz"; "MM/d/yy HH:mm zzz"
       "M/dd/yyyy H:mm zzz"; "MM/dd/yyyy H:mm zzz"
       "M/d/yyyy H:mm zzz"; "MM/d/yyyy H:mm zzz"
       "M/dd/yy H:mm zzz"; "MM/dd/yy H:mm zzz"
       "M/d/yy H:mm zzz"; "MM/d/yy H:mm zzz" |]
let provider = CultureInfo.InvariantCulture.DateTimeFormat

while tries < 3 && result.IsNone do
    printfn "Enter a date, time, and offset (MM/DD/YYYY HH:MM +/-HH:MM),"
    printf "Then press Enter: "
    input <- stdin.ReadLine()
    printfn ""
    match DateTimeOffset.TryParseExact(input, formats, provider, DateTimeStyles.AllowWhiteSpaces) with
    | true, dto ->
        result <- Some dto
    | _ ->
        printfn $"Unable to parse {input}."
    tries <- tries + 1

match result with
| Some result ->
    printfn $"{input} was converted to {result}"
| None ->
    printfn $"Exiting application without parsing {input}"

// Some successful sample interactions with the user might appear as follows:
//    Enter a date, time, and offset (MM/DD/YYYY HH:MM +/-HH:MM),
//    Then press Enter: 12/08/2007 6:54 -6:00
//
//    12/08/2007 6:54 -6:00 was converted to 12/8/2007 6:54:00 AM -06:00
//
//    Enter a date, time, and offset (MM/DD/YYYY HH:MM +/-HH:MM),
//    Then press Enter: 12/8/2007 06:54 -06:00
//
//    12/8/2007 06:54 -06:00 was converted to 12/8/2007 6:54:00 AM -06:00
//
//    Enter a date, time, and offset (MM/DD/YYYY HH:MM +/-HH:MM),
//    Then press Enter: 12/5/07 6:54 -6:00
//
//    12/5/07 6:54 -6:00 was converted to 12/5/2007 6:54:00 AM -06:00

 Dim conIn As TextReader = Console.In
 Dim conOut As TextWriter = Console.Out
 Dim tries As Integer = 0
 Dim input As String = String.Empty
 Dim formats() As String = {"M/dd/yyyy HH:m zzz", "MM/dd/yyyy HH:m zzz", _
                            "M/d/yyyy HH:m zzz", "MM/d/yyyy HH:m zzz", _
                            "M/dd/yy HH:m zzz", "MM/dd/yy HH:m zzz", _
                            "M/d/yy HH:m zzz", "MM/d/yy HH:m zzz", _                                 
                            "M/dd/yyyy H:m zzz", "MM/dd/yyyy H:m zzz", _
                            "M/d/yyyy H:m zzz", "MM/d/yyyy H:m zzz", _
                            "M/dd/yy H:m zzz", "MM/dd/yy H:m zzz", _
                            "M/d/yy H:m zzz", "MM/d/yy H:m zzz", _                               
                            "M/dd/yyyy HH:mm zzz", "MM/dd/yyyy HH:mm zzz", _
                            "M/d/yyyy HH:mm zzz", "MM/d/yyyy HH:mm zzz", _
                            "M/dd/yy HH:mm zzz", "MM/dd/yy HH:mm zzz", _
                            "M/d/yy HH:mm zzz", "MM/d/yy HH:mm zzz", _                                 
                            "M/dd/yyyy H:mm zzz", "MM/dd/yyyy H:mm zzz", _
                            "M/d/yyyy H:mm zzz", "MM/d/yyyy H:mm zzz", _
                            "M/dd/yy H:mm zzz", "MM/dd/yy H:mm zzz", _
                            "M/d/yy H:mm zzz", "MM/d/yy H:mm zzz"}   
 Dim provider As IFormatProvider = CultureInfo.InvariantCulture.DateTimeFormat
 Dim result As DateTimeOffset

 Do 
    conOut.WriteLine("Enter a date, time, and offset (MM/DD/YYYY HH:MM +/-HH:MM),")
    conOut.Write("Then press Enter: ")
    input = conIn.ReadLine()
    conOut.WriteLine() 
    If DateTimeOffset.TryParseExact(input, formats, provider, _
                                    DateTimeStyles.AllowWhiteSpaces, _
                                    result) Then
       Exit Do
    Else
       Console.WriteLine("Unable to parse {0}.", input)      
       tries += 1
    End If
 Loop While tries < 3
 If tries >= 3 Then
    Console.WriteLine("Exiting application without parsing {0}", input)
 Else
    Console.WriteLine("{0} was converted to {1}", input, result.ToString())                                                     
 End If 
 ' Some successful sample interactions with the user might appear as follows:
 '    Enter a date, time, and offset (MM/DD/YYYY HH:MM +/-HH:MM),
 '    Then press Enter: 12/08/2007 6:54 -6:00
 '    
 '    12/08/2007 6:54 -6:00 was converted to 12/8/2007 6:54:00 AM -06:00         
 '    
 '    Enter a date, time, and offset (MM/DD/YYYY HH:MM +/-HH:MM),
 '    Then press Enter: 12/8/2007 06:54 -06:00
 '    
 '    12/8/2007 06:54 -06:00 was converted to 12/8/2007 6:54:00 AM -06:00
 '    
 '    Enter a date, time, and offset (MM/DD/YYYY HH:MM +/-HH:MM),
 '    Then press Enter: 12/5/07 6:54 -6:00
 '    
 '    12/5/07 6:54 -6:00 was converted to 12/5/2007 6:54:00 AM -06:00

Comentarios

El método TryParseExact(String, String[], IFormatProvider, DateTimeStyles, DateTimeOffset) analiza la representación de cadena de una fecha que coincide con cualquiera de los patrones asignados a la matriz formats. Si la cadena de input no coincide con ninguno de estos patrones con ninguna variación definida por el parámetro styles, se produce un error en la operación de análisis y el método devuelve false. Además de comparar input con varias cadenas que contienen especificadores de formato, esta sobrecarga se comporta de forma idéntica al método DateTimeOffset.ParseExact(String, String[], IFormatProvider, DateTimeStyles).

El parámetro formats es una matriz de cadenas cuyos elementos contienen un único especificador de formato estándar o uno o varios especificadores de formato personalizados que definen el patrón posible de input. Para obtener más información sobre los códigos de formato válidos, vea cadenas de formato de fecha y hora estándar y cadenas de formato de fecha y hora personalizados. Si el elemento coincidente de formats incluye el z, zzo zzz especificadores de formato personalizado para indicar que un desplazamiento debe estar presente en input, ese desplazamiento debe incluir un signo negativo o un signo positivo. Si falta el signo, se produce un error en la operación de análisis y el método devuelve false.

Importante

El uso del parámetro formats de esta sobrecarga para especificar varios formatos puede ayudar a reducir la frustración que muchos usuarios experimentan al escribir fechas y horas. En concreto, la capacidad de definir varios patrones de entrada permite a una aplicación controlar las representaciones de fecha y hora que pueden incluir o carecer de ceros iniciales en meses, días, horas, minutos y segundos. En el ejemplo se proporciona una ilustración de esto.

Si el elemento coincidente de formats requiere que input contengan una fecha pero no una hora, al objeto de DateTimeOffset resultante se le asigna una hora de medianoche (0:00:00). Si el elemento coincidente de formats requiere que la entrada contenga una hora, pero no una fecha, al objeto DateTimeOffset resultante se le asigna la fecha actual en el sistema local. Si el elemento coincidente de formats no requiere que input contengan un desplazamiento, el desplazamiento del objeto DateTimeOffset resultante depende del valor del parámetro styles. Si styles incluye AssumeLocal, el desplazamiento de la zona horaria local se asigna al objeto DateTimeOffset. Si styles incluye AssumeUniversal, el desplazamiento hora universal coordinada (UTC) o +00:00, se asigna al objeto DateTimeOffset. Si no se especifica ningún valor, se usa el desplazamiento de la zona horaria local.

El parámetro formatProvider define los símbolos y cadenas de fecha y hora concretos que se usan en input. Lo mismo sucede con el patrón preciso de input si el elemento coincidente de formats es una cadena de especificador de formato estándar. El parámetro formatProvider puede ser cualquiera de los siguientes:

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

El parámetro styles define si se permite el espacio en blanco en la cadena de entrada, indica cómo se analizan las cadenas sin un componente de desplazamiento explícito y admite la conversión UTC como parte de la operación de análisis. Se admiten todos los miembros de la enumeración DateTimeStyles, excepto NoCurrentDateDefault. En la tabla siguiente se muestra el efecto de cada miembro admitido.

miembro de DateTimeStyles Comportamiento
AdjustToUniversal Analiza input y, si es necesario, lo convierte en UTC. Es equivalente a analizar una cadena y, a continuación, llamar al método DateTimeOffset.ToUniversalTime del objeto DateTimeOffset devuelto.
AssumeLocal Si el elemento coincidente de formats no requiere que input contengan un valor de desplazamiento, el objeto DateTimeOffset devuelto recibe el desplazamiento de la zona horaria local. Este es el valor predeterminado.
AssumeUniversal Si el elemento coincidente de formats no requiere que input contenga un valor de desplazamiento, el objeto devuelto DateTimeOffset recibe el desplazamiento UTC (+00:00).
AllowInnerWhite Permite que input incluyan espacios en blanco internos no especificados por los elementos de formats. El espacio en blanco adicional puede aparecer entre los componentes de fecha y hora y dentro de los componentes individuales (excepto el desplazamiento) y se omite al analizar la cadena.
AllowLeadingWhite Permite que input incluyan espacios iniciales no especificados por los elementos de formats. Estos se omiten al analizar la cadena.
AllowTrailingWhite Permite input incluir espacios finales no especificados por los elementos de formats. Estos se omiten al analizar la cadena.
AllowWhiteSpaces Permite que input incluyan espacios iniciales, finales e internos no especificados por los elementos de formats. Todos los caracteres de espacio en blanco adicionales no especificados en el elemento coincidente de formats se omiten al analizar la cadena.
None Indica que no se permite espacio en blanco adicional en input. El espacio en blanco debe aparecer exactamente como se especifica en un elemento determinado en formats para que se produzca una coincidencia correcta. Este es el comportamiento predeterminado.
RoundtripKind No tiene ningún efecto porque la estructura DateTimeOffset no incluye una propiedad Kind.

Notas a los autores de las llamadas

En .NET Framework 4, el 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.

Se aplica a

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

Source:
DateTimeOffset.cs
Source:
DateTimeOffset.cs
Source:
DateTimeOffset.cs

Convierte la representación de una fecha y hora en un intervalo de caracteres en su DateTimeOffset 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 fecha y hora debe coincidir exactamente con el formato especificado.

public:
 static bool TryParseExact(ReadOnlySpan<char> input, ReadOnlySpan<char> format, IFormatProvider ^ formatProvider, System::Globalization::DateTimeStyles styles, [Runtime::InteropServices::Out] DateTimeOffset % result);
public static bool TryParseExact (ReadOnlySpan<char> input, ReadOnlySpan<char> format, IFormatProvider? formatProvider, System.Globalization.DateTimeStyles styles, out DateTimeOffset result);
public static bool TryParseExact (ReadOnlySpan<char> input, ReadOnlySpan<char> format, IFormatProvider formatProvider, System.Globalization.DateTimeStyles styles, out DateTimeOffset result);
static member TryParseExact : ReadOnlySpan<char> * ReadOnlySpan<char> * IFormatProvider * System.Globalization.DateTimeStyles * DateTimeOffset -> bool
Public Shared Function TryParseExact (input As ReadOnlySpan(Of Char), format As ReadOnlySpan(Of Char), formatProvider As IFormatProvider, styles As DateTimeStyles, ByRef result As DateTimeOffset) As Boolean

Parámetros

input
ReadOnlySpan<Char>

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

format
ReadOnlySpan<Char>

Especificador de formato que define el formato necesario de input.

formatProvider
IFormatProvider

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

styles
DateTimeStyles

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

result
DateTimeOffset

Cuando el método devuelve , contiene el DateTimeOffset equivalente a la fecha y hora de input, si la conversión se realizó correctamente o dateTimeOffset.MinValue si se produjo un error en la conversión. Se produce un error en la conversión si se produce un error en la conversión

Devoluciones

Boolean

true si el parámetro input se convierte correctamente; de lo contrario, false.

Excepciones

ArgumentException

styles incluye un valor de DateTimeStyles indefinido. -o bien- no se admite NoCurrentDateDefault. -o bien- styles incluye valores de DateTimeStyles mutuamente excluyentes.

Comentarios

Esta sobrecarga es similar al método DateTimeOffset.ParseExact(ReadOnlySpan<Char>, ReadOnlySpan<Char>, IFormatProvider, DateTimeStyles), salvo que este método no produce una excepción si se produce un error en la conversión. Analiza la representación de una fecha y hora que debe coincidir exactamente con el patrón especificado por el parámetro format. Si input no coincide con este patrón, con algunas variaciones posibles en el espacio en blanco definido por el parámetro styles, se produce un error en la operación de análisis y el método devuelve false.

El parámetro format es un intervalo de caracteres que contiene un único especificador de formato estándar o uno o varios especificadores de formato personalizados que definen el patrón necesario de input. Para obtener más información sobre los códigos de formato válidos, vea cadenas de formato de fecha y hora estándar y cadenas de formato de fecha y hora personalizados. Si format incluye el z, zzo zzz especificadores de formato personalizado para indicar que un desplazamiento debe estar presente en input, ese desplazamiento debe incluir un signo negativo o un signo positivo. Si falta el signo, se produce un error en la operación de análisis y el método devuelve false.

Si format requiere que input contengan una fecha pero no una hora, al objeto de DateTimeOffset resultante se le asigna una hora de medianoche (0:00:00). Si format requiere que input contengan una hora pero no una fecha, al objeto DateTimeOffset resultante se le asigna la fecha actual en el sistema local. Si format no requiere que input contengan un desplazamiento, el desplazamiento del objeto DateTimeOffset resultante depende del valor del parámetro styles. Si styles incluye AssumeLocal, el desplazamiento de la zona horaria local se asigna al objeto DateTimeOffset. Si styles incluye AssumeUniversal, el desplazamiento hora universal coordinada (UTC) o +00:00, se asigna al objeto DateTimeOffset. Si no se especifica ningún valor, se usa el desplazamiento de la zona horaria local.

El parámetro formatProvider define los símbolos y cadenas de fecha y hora concretos que se usan en input. Lo mismo sucede con el patrón preciso de input si format es una cadena de especificador de formato estándar. El parámetro formatProvider puede ser cualquiera de los siguientes:

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

El parámetro styles define si se permite el espacio en blanco en la cadena de entrada, indica cómo se analizan las cadenas sin un componente de desplazamiento explícito y admite la conversión UTC como parte de la operación de análisis. Se admiten todos los miembros de la enumeración DateTimeStyles, excepto NoCurrentDateDefault. En la tabla siguiente se muestra el efecto de cada miembro admitido.

miembro de DateTimeStyles Comportamiento
AdjustToUniversal Analiza input y, si es necesario, lo convierte en UTC. Es equivalente a analizar una representación de fecha y hora y, a continuación, llamar al método DateTimeOffset.ToUniversalTime del objeto DateTimeOffset devuelto.
AssumeLocal Si format no requiere que input contengan un valor de desplazamiento, el objeto devuelto DateTimeOffset recibe el desplazamiento de la zona horaria local. Este es el comportamiento predeterminado.
AssumeUniversal Si format no requiere que input contengan un valor de desplazamiento, el objeto DateTimeOffset devuelto recibe el desplazamiento UTC (+00:00).
AllowInnerWhite Permite que input incluyan espacios en blanco internos no especificados por formato. El espacio en blanco adicional puede aparecer entre los componentes de fecha y hora y dentro de los componentes individuales, excepto el desplazamiento, y se omite al analizar la cadena.
AllowLeadingWhite Permite que input incluyan espacios iniciales no especificados por format. Estos se omiten al analizar la cadena.
AllowTrailingWhite Permite input incluir espacios finales no especificados por format. Estos se omiten al analizar la cadena.
AllowWhiteSpaces Permite que input incluyan espacios iniciales, finales e internos no especificados por format. Todos los caracteres de espacio en blanco adicionales no especificados en format se omiten al analizar la cadena.
None Indica que no se permite espacio en blanco adicional en input. El espacio en blanco debe aparecer exactamente como se especifica en format. Este es el comportamiento predeterminado.
RoundtripKind No tiene ningún efecto, ya que la estructura DateTimeOffset no incluye una propiedad Kind.

Se aplica a

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

Source:
DateTimeOffset.cs
Source:
DateTimeOffset.cs
Source:
DateTimeOffset.cs

Convierte la representación de una fecha y hora en un intervalo de caracteres en su DateTimeOffset equivalente mediante los formatos especificados, la información de formato específica de la referencia cultural y el estilo. El formato de la representación de fecha y hora debe coincidir exactamente con uno de los formatos especificados.

public:
 static bool TryParseExact(ReadOnlySpan<char> input, cli::array <System::String ^> ^ formats, IFormatProvider ^ formatProvider, System::Globalization::DateTimeStyles styles, [Runtime::InteropServices::Out] DateTimeOffset % result);
public static bool TryParseExact (ReadOnlySpan<char> input, string?[]? formats, IFormatProvider? formatProvider, System.Globalization.DateTimeStyles styles, out DateTimeOffset result);
public static bool TryParseExact (ReadOnlySpan<char> input, string[] formats, IFormatProvider formatProvider, System.Globalization.DateTimeStyles styles, out DateTimeOffset result);
static member TryParseExact : ReadOnlySpan<char> * string[] * IFormatProvider * System.Globalization.DateTimeStyles * DateTimeOffset -> bool
Public Shared Function TryParseExact (input As ReadOnlySpan(Of Char), formats As String(), formatProvider As IFormatProvider, styles As DateTimeStyles, ByRef result As DateTimeOffset) As Boolean

Parámetros

input
ReadOnlySpan<Char>

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

formats
String[]

Matriz de cadenas de formato estándar o personalizado que definen los formatos aceptables de input.

formatProvider
IFormatProvider

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

styles
DateTimeStyles

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

result
DateTimeOffset

Cuando el método devuelve , contiene el DateTimeOffset equivalente a la fecha y hora de input, si la conversión se realizó correctamente o dateTimeOffset.MinValue si se produjo un error en la conversión. Se produce un error en la conversión si se produce un error en la conversión

Devoluciones

Boolean

true si el parámetro input se convierte correctamente; de lo contrario, false.

Excepciones

ArgumentException

styles incluye un valor de DateTimeStyles indefinido. -o bien- no se admite NoCurrentDateDefault. -o bien- styles incluye valores de DateTimeStyles mutuamente excluyentes.

Comentarios

Este método analiza la representación de cadena de una fecha que coincide con cualquiera de los patrones asignados a la matriz formats. Si input no coincide con ninguno de estos patrones con ninguna variación definida por el parámetro styles, se produce un error en la operación de análisis y el método devuelve false. Además de comparar input con varias cadenas que contienen especificadores de formato, esta sobrecarga se comporta de forma idéntica al método DateTimeOffset.ParseExact(ReadOnlySpan<Char>, String[], IFormatProvider, DateTimeStyles).

El parámetro formats es una matriz de cadenas cuyos elementos contienen un único especificador de formato estándar o uno o varios especificadores de formato personalizados que definen el patrón posible de input. Para obtener más información sobre los códigos de formato válidos, vea cadenas de formato de fecha y hora estándar y cadenas de formato de fecha y hora personalizados. Si el elemento coincidente de formats incluye el z, zzo zzz especificadores de formato personalizado para indicar que un desplazamiento debe estar presente en input, ese desplazamiento debe incluir un signo negativo o un signo positivo. Si falta el signo, se produce un error en la operación de análisis y el método devuelve false.

Importante

El uso del parámetro formats de esta sobrecarga para especificar varios formatos puede ayudar a reducir la frustración que muchos usuarios experimentan al escribir fechas y horas. En concreto, la capacidad de definir varios patrones de entrada permite a una aplicación controlar las representaciones de fecha y hora que pueden incluir o carecer de ceros iniciales en meses, días, horas, minutos y segundos. En el ejemplo se proporciona una ilustración de esto.

Si el elemento coincidente de formats requiere que input contengan una fecha pero no una hora, al objeto de DateTimeOffset resultante se le asigna una hora de medianoche (0:00:00). Si el elemento coincidente de formats requiere que la entrada contenga una hora, pero no una fecha, al objeto DateTimeOffset resultante se le asigna la fecha actual en el sistema local. Si el elemento coincidente de formats no requiere que input contengan un desplazamiento, el desplazamiento del objeto DateTimeOffset resultante depende del valor del parámetro styles. Si styles incluye DateTimeStyles.AssumeLocal, el desplazamiento de la zona horaria local se asigna al objeto DateTimeOffset. Si styles incluye DateTimeStyles.AssumeUniversal, el desplazamiento hora universal coordinada (UTC) o +00:00, se asigna al objeto DateTimeOffset. Si no se especifica ningún valor, se usa el desplazamiento de la zona horaria local.

Los símbolos de fecha y hora concretos usados en input se definen mediante el parámetro formatProvider. Lo mismo sucede con el patrón preciso de input si el elemento coincidente de formats es una cadena de especificador de formato estándar. El parámetro formatProvider puede ser cualquiera de los siguientes:

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

El parámetro styles define si se permite el espacio en blanco en la cadena de entrada, indica cómo se analizan las cadenas sin un componente de desplazamiento explícito y admite la conversión UTC como parte de la operación de análisis. Se admiten todos los miembros de la enumeración DateTimeStyles, excepto NoCurrentDateDefault. En la tabla siguiente se muestra el efecto de cada miembro admitido.

miembro de DateTimeStyles Comportamiento
AdjustToUniversal Analiza input y, si es necesario, lo convierte en UTC. Es equivalente a analizar una cadena y, a continuación, llamar al método DateTimeOffset.ToUniversalTime del objeto DateTimeOffset devuelto.
AssumeLocal Si el elemento coincidente de formats no requiere que input contengan un valor de desplazamiento, el objeto DateTimeOffset devuelto recibe el desplazamiento de la zona horaria local. Este es el valor predeterminado.
AssumeUniversal Si el elemento coincidente de formats no requiere que input contenga un valor de desplazamiento, el objeto devuelto DateTimeOffset recibe el desplazamiento UTC (+00:00).
AllowInnerWhite Permite que input incluyan espacios en blanco internos no especificados por los elementos de formats. El espacio en blanco adicional puede aparecer entre los componentes de fecha y hora y dentro de los componentes individuales (excepto el desplazamiento) y se omite al analizar la cadena.
AllowLeadingWhite Permite que input incluyan espacios iniciales no especificados por los elementos de formats. Estos se omiten al analizar la cadena.
AllowTrailingWhite Permite input incluir espacios finales no especificados por los elementos de formats. Estos se omiten al analizar la cadena.
AllowWhiteSpaces Permite que input incluyan espacios iniciales, finales e internos no especificados por los elementos de formats. Todos los caracteres de espacio en blanco adicionales no especificados en el elemento coincidente de formats se omiten al analizar la cadena.
None Indica que no se permite espacio en blanco adicional en input. El espacio en blanco debe aparecer exactamente como se especifica en un elemento determinado en formats para que se produzca una coincidencia correcta. Este es el comportamiento predeterminado.
RoundtripKind No tiene ningún efecto porque la estructura DateTimeOffset no incluye una propiedad Kind.

Se aplica a

TryParseExact(String, String, IFormatProvider, DateTimeStyles, DateTimeOffset)

Source:
DateTimeOffset.cs
Source:
DateTimeOffset.cs
Source:
DateTimeOffset.cs

Convierte la representación de cadena especificada de una fecha y hora en su DateTimeOffset 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.

public:
 static bool TryParseExact(System::String ^ input, System::String ^ format, IFormatProvider ^ formatProvider, System::Globalization::DateTimeStyles styles, [Runtime::InteropServices::Out] DateTimeOffset % result);
public static bool TryParseExact (string input, string format, IFormatProvider formatProvider, System.Globalization.DateTimeStyles styles, out DateTimeOffset result);
public static bool TryParseExact (string? input, string? format, IFormatProvider? formatProvider, System.Globalization.DateTimeStyles styles, out DateTimeOffset result);
static member TryParseExact : string * string * IFormatProvider * System.Globalization.DateTimeStyles * DateTimeOffset -> bool
Public Shared Function TryParseExact (input As String, format As String, formatProvider As IFormatProvider, styles As DateTimeStyles, ByRef result As DateTimeOffset) As Boolean

Parámetros

input
String

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

format
String

Especificador de formato que define el formato necesario de input.

formatProvider
IFormatProvider

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

styles
DateTimeStyles

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

result
DateTimeOffset

Cuando el método devuelve , contiene el DateTimeOffset equivalente a la fecha y hora de input, si la conversión se realizó correctamente o DateTimeOffset.MinValue, si se produjo un error en la conversión. Se produce un error en la conversión si el parámetro input es nullo no contiene una representación de cadena válida de una fecha y hora en el formato esperado definido por format y provider. Este parámetro se pasa sin inicializar.

Devoluciones

Boolean

true si el parámetro input se convierte correctamente; de lo contrario, false.

Excepciones

ArgumentException

styles incluye un valor de DateTimeStyles indefinido.

-o-

no se admite NoCurrentDateDefault.

-o-

styles incluye valores de DateTimeStyles mutuamente excluyentes.

Ejemplos

En el ejemplo siguiente se usa el método TryParseExact(String, String, IFormatProvider, DateTimeStyles, DateTimeOffset) con especificadores de formato estándar y personalizado, la referencia cultural invariable y varios valores de DateTimeStyles para analizar varias cadenas de fecha y hora.

string dateString, format;
DateTimeOffset result;
IFormatProvider provider = CultureInfo.InvariantCulture;

// Parse date-only value with invariant culture and assume time is UTC.
dateString = "06/15/2008";
format = "d";
if (DateTimeOffset.TryParseExact(dateString, format, provider,
                                 DateTimeStyles.AssumeUniversal,
                                 out result))
   Console.WriteLine("'{0}' converts to {1}.", dateString, result.ToString());
else
   Console.WriteLine("'{0}' is not in the correct format.", dateString);

// Parse date-only value with leading white space.
// Should return False because only trailing white space is
// specified in method call.
dateString = " 06/15/2008";
if (DateTimeOffset.TryParseExact(dateString, format, provider,
                                 DateTimeStyles.AllowTrailingWhite,
                                 out result))
   Console.WriteLine("'{0}' converts to {1}.", dateString, result.ToString());
else
   Console.WriteLine("'{0}' is not in the correct format.", dateString);

// Parse date and time value, and allow all white space.
dateString = " 06/15/   2008  15:15    -05:00";
format = "MM/dd/yyyy H:mm zzz";
if (DateTimeOffset.TryParseExact(dateString, format, provider,
                                 DateTimeStyles.AllowWhiteSpaces,
                                 out result))
   Console.WriteLine("'{0}' converts to {1}.", dateString, result.ToString());
else
   Console.WriteLine("'{0}' is not in the correct format.", dateString);

// Parse date and time and convert to UTC.
dateString = "  06/15/2008 15:15:30 -05:00";
format = "MM/dd/yyyy H:mm:ss zzz";
if (DateTimeOffset.TryParseExact(dateString, format, provider,
                                DateTimeStyles.AllowWhiteSpaces |
                                DateTimeStyles.AdjustToUniversal,
                                out result))
   Console.WriteLine("'{0}' converts to {1}.", dateString, result.ToString());
else
   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 +00:00.
//    ' 06/15/2008' is not in the correct format.
//    ' 06/15/   2008  15:15    -05:00' converts to 6/15/2008 3:15:00 PM -05:00.
//    '  06/15/2008 15:15:30 -05:00' converts to 6/15/2008 8:15:30 PM +00:00.

let provider = CultureInfo.InvariantCulture

// Parse date-only value with invariant culture and assume time is UTC.
let dateString = "06/15/2008"
let format = "d"
match DateTimeOffset.TryParseExact(dateString, format, provider, DateTimeStyles.AssumeUniversal) with
| true, result ->
    printfn $"'{dateString}' converts to {result}."
| _ ->
    printfn $"'{dateString}' is not in the correct format."

// Parse date-only value with leading white space.
// Should return False because only trailing white space is
// specified in method call.
let dateString = " 06/15/2008"
match DateTimeOffset.TryParseExact(dateString, format, provider, DateTimeStyles.AllowTrailingWhite) with
| true, result ->
    printfn $"'{dateString}' converts to {result}."
| _ ->
    printfn $"'{dateString}' is not in the correct format."

// Parse date and time value, and allow all white space.
let dateString = " 06/15/   2008  15:15    -05:00"
let format = "MM/dd/yyyy H:mm zzz"
match DateTimeOffset.TryParseExact(dateString, format, provider, DateTimeStyles.AllowWhiteSpaces) with
| true, result ->
    printfn $"'{dateString}' converts to {result}."
| _ ->
    printfn $"'{dateString}' is not in the correct format."

// Parse date and time and convert to UTC.
let dateString = "  06/15/2008 15:15:30 -05:00"
let format = "MM/dd/yyyy H:mm:ss zzz"
match DateTimeOffset.TryParseExact(dateString, format, provider, DateTimeStyles.AllowWhiteSpaces ||| DateTimeStyles.AdjustToUniversal) with
| true, result ->
    printfn $"'{dateString}' converts to {result}."
| _ ->
    printfn $"'{dateString}' is not in the correct format."

// The example displays the following output:
//    '06/15/2008' converts to 6/15/2008 12:00:00 AM +00:00.
//    ' 06/15/2008' is not in the correct format.
//    ' 06/15/   2008  15:15    -05:00' converts to 6/15/2008 3:15:00 PM -05:00.
//    '  06/15/2008 15:15:30 -05:00' converts to 6/15/2008 8:15:30 PM +00:00.

Dim dateString, format As String  
Dim result As DateTimeOffset
Dim provider As CultureInfo = CultureInfo.InvariantCulture

' Parse date-only value with invariant culture and assume time is UTC.
dateString = "06/15/2008"
format = "d"
If DateTimeOffset.TryParseExact(dateString, format, provider, _
                                   DateTimeStyles.AssumeUniversal, _
                                   result) Then
   Console.WriteLine("'{0}' converts to {1}.", dateString, result.ToString())
Else
   Console.WriteLine("'{0}' is not in the correct format.", dateString)
End If 

' Parse date-only value with leading white space.
' Should return False because only trailing white space is  
' specified in method call.
dateString = " 06/15/2008"
If DateTimeOffset.TryParseExact(dateString, format, provider, _
                                DateTimeStyles.AllowTrailingWhite, _
                                result) Then
   Console.WriteLine("'{0}' converts to {1}.", dateString, result.ToString())
Else
   Console.WriteLine("'{0}' is not in the correct format.", dateString)
End If 

' Parse date and time value, and allow all white space.
dateString = " 06/15/   2008  15:15    -05:00"
format = "MM/dd/yyyy H:mm zzz"
If DateTimeOffset.TryParseExact(dateString, format, provider, _
                                DateTimeStyles.AllowWhiteSpaces, _
                                result) Then
   Console.WriteLine("'{0}' converts to {1}.", dateString, result.ToString())
Else
   Console.WriteLine("'{0}' is not in the correct format.", dateString)
End If 

' Parse date and time and convert to UTC.
dateString = "  06/15/2008 15:15:30 -05:00"   
format = "MM/dd/yyyy H:mm:ss zzz"       
If DateTimeOffset.TryParseExact(dateString, format, provider, _
                                DateTimeStyles.AllowWhiteSpaces Or _
                                DateTimeStyles.AdjustToUniversal, _
                                result) Then
   Console.WriteLine("'{0}' converts to {1}.", dateString, result.ToString())
Else
   Console.WriteLine("'{0}' is not in the correct format.", dateString)
End If 
' The example displays the following output:
'    '06/15/2008' converts to 6/15/2008 12:00:00 AM +00:00.
'    ' 06/15/2008' is not in the correct format.
'    ' 06/15/   2008  15:15    -05:00' converts to 6/15/2008 3:15:00 PM -05:00.
'    '  06/15/2008 15:15:30 -05:00' converts to 6/15/2008 8:15:30 PM +00:00.

En el ejemplo siguiente se usa una variedad de valores de DateTimeStyles para analizar una matriz de cadenas que se espera que se ajusten a ISO 8601. Como se muestra en la salida del ejemplo, las cadenas que tienen el formato adecuado no pueden analizarse si:

Se supone que las cadenas que no especifican un desplazamiento UTC tienen el desplazamiento de la zona horaria local (en este caso, -07:00, que refleja el desplazamiento de la zona horaria del Pacífico) a menos que se proporcione la marca DateTimeStyles.AssumeUniversal en la llamada al método. En ese caso, se supone que son hora coordinada universal.

open System
open System.Globalization

let parseWithISO8601 dateStrings styles =
    printfn $"Parsing with {styles}:"
    for dateString in dateStrings do
        match DateTimeOffset.TryParseExact(dateString, "O", null, styles) with
        | true, date ->
            printfn $"""   {dateString,-35} --> {date.ToString "yyyy-MM-dd HH:mm:ss.FF zzz"}"""
        | _ ->
            printfn $"   Unable to convert '{dateString}'"

let dateStrings = 
    [ "2018-08-18T12:45:16.0000000Z"
      "2018/08/18T12:45:16.0000000Z"
      "2018-18-08T12:45:16.0000000Z"
      "2018-08-18T12:45:16.0000000"
      " 2018-08-18T12:45:16.0000000Z "
      "2018-08-18T12:45:16.0000000+02:00"
      "2018-08-18T12:45:16.0000000-07:00" ]

parseWithISO8601 dateStrings DateTimeStyles.None
printfn "\n-----\n"
parseWithISO8601 dateStrings DateTimeStyles.AllowWhiteSpaces
printfn "\n-----\n"
parseWithISO8601 dateStrings DateTimeStyles.AdjustToUniversal
printfn "\n-----\n"
parseWithISO8601 dateStrings DateTimeStyles.AssumeLocal
printfn "\n-----\n"
parseWithISO8601 dateStrings DateTimeStyles.AssumeUniversal

// The example displays the following output:
//      Parsing with None:
//         2018-08-18T12:45:16.0000000Z        --> 2018-08-18 12:45:16 +00:00
//         Unable to convert '2018/08/18T12:45:16.0000000Z'
//         Unable to convert '2018-18-08T12:45:16.0000000Z'
//         2018-08-18T12:45:16.0000000         --> 2018-08-18 12:45:16 -07:00
//         Unable to convert ' 2018-08-18T12:45:16.0000000Z '
//         2018-08-18T12:45:16.0000000+02:00   --> 2018-08-18 12:45:16 +02:00
//         2018-08-18T12:45:16.0000000-07:00   --> 2018-08-18 12:45:16 -07:00
//
//      -----
//
//      Parsing with AllowWhiteSpaces:
//         2018-08-18T12:45:16.0000000Z        --> 2018-08-18 12:45:16 +00:00
//         Unable to convert '2018/08/18T12:45:16.0000000Z'
//         Unable to convert '2018-18-08T12:45:16.0000000Z'
//         2018-08-18T12:45:16.0000000         --> 2018-08-18 12:45:16 -07:00
//          2018-08-18T12:45:16.0000000Z       --> 2018-08-18 12:45:16 +00:00
//         2018-08-18T12:45:16.0000000+02:00   --> 2018-08-18 12:45:16 +02:00
//         2018-08-18T12:45:16.0000000-07:00   --> 2018-08-18 12:45:16 -07:00
//
//      -----
//
//      Parsing with AdjustToUniversal:
//         2018-08-18T12:45:16.0000000Z        --> 2018-08-18 12:45:16 +00:00
//         Unable to convert '2018/08/18T12:45:16.0000000Z'
//         Unable to convert '2018-18-08T12:45:16.0000000Z'
//         2018-08-18T12:45:16.0000000         --> 2018-08-18 19:45:16 +00:00
//         Unable to convert ' 2018-08-18T12:45:16.0000000Z '
//         2018-08-18T12:45:16.0000000+02:00   --> 2018-08-18 10:45:16 +00:00
//         2018-08-18T12:45:16.0000000-07:00   --> 2018-08-18 19:45:16 +00:00
//
//      -----
//
//      Parsing with AssumeLocal:
//         2018-08-18T12:45:16.0000000Z        --> 2018-08-18 12:45:16 +00:00
//         Unable to convert '2018/08/18T12:45:16.0000000Z'
//         Unable to convert '2018-18-08T12:45:16.0000000Z'
//         2018-08-18T12:45:16.0000000         --> 2018-08-18 12:45:16 -07:00
//         Unable to convert ' 2018-08-18T12:45:16.0000000Z '
//         2018-08-18T12:45:16.0000000+02:00   --> 2018-08-18 12:45:16 +02:00
//         2018-08-18T12:45:16.0000000-07:00   --> 2018-08-18 12:45:16 -07:00
//
//      -----
//
//      Parsing with AssumeUniversal:
//         2018-08-18T12:45:16.0000000Z        --> 2018-08-18 12:45:16 +00:00
//         Unable to convert '2018/08/18T12:45:16.0000000Z'
//         Unable to convert '2018-18-08T12:45:16.0000000Z'
//         2018-08-18T12:45:16.0000000         --> 2018-08-18 12:45:16 +00:00
//         Unable to convert ' 2018-08-18T12:45:16.0000000Z '
//         2018-08-18T12:45:16.0000000+02:00   --> 2018-08-18 12:45:16 +02:00
//         2018-08-18T12:45:16.0000000-07:00   --> 2018-08-18 12:45:16 -07:00

using System;
using System.Globalization;

public class Example
{
   public static void Main()
   {
      string[] dateStrings = { "2018-08-18T12:45:16.0000000Z",
                               "2018/08/18T12:45:16.0000000Z",
                               "2018-18-08T12:45:16.0000000Z",
                               "2018-08-18T12:45:16.0000000",                               
                               " 2018-08-18T12:45:16.0000000Z ",
                               "2018-08-18T12:45:16.0000000+02:00",
                               "2018-08-18T12:45:16.0000000-07:00" }; 
      
      ParseWithISO8601(dateStrings, DateTimeStyles.None);
      Console.WriteLine("\n-----\n");
      ParseWithISO8601(dateStrings, DateTimeStyles.AllowWhiteSpaces);
      Console.WriteLine("\n-----\n");
      ParseWithISO8601(dateStrings, DateTimeStyles.AdjustToUniversal);
      Console.WriteLine("\n-----\n");
      ParseWithISO8601(dateStrings, DateTimeStyles.AssumeLocal);
      Console.WriteLine("\n-----\n");
      ParseWithISO8601(dateStrings, DateTimeStyles.AssumeUniversal);   }

   private static void ParseWithISO8601(string[] dateStrings, DateTimeStyles styles)
   {   
      Console.WriteLine($"Parsing with {styles}:");
      DateTimeOffset date;
      foreach (var dateString in dateStrings)
      {
         if (DateTimeOffset.TryParseExact(dateString, "O", null, styles, out date))
         {
            Console.WriteLine($"   {dateString,-35} --> {date:yyyy-MM-dd HH:mm:ss.FF zzz}");
         }
         else
         {
            Console.WriteLine($"   Unable to convert '{dateString}'");
         }   
      } 
   }
}
// The example displays the following output:
//      Parsing with None:
//         2018-08-18T12:45:16.0000000Z        --> 2018-08-18 12:45:16 +00:00
//         Unable to convert '2018/08/18T12:45:16.0000000Z'
//         Unable to convert '2018-18-08T12:45:16.0000000Z'
//         2018-08-18T12:45:16.0000000         --> 2018-08-18 12:45:16 -07:00
//         Unable to convert ' 2018-08-18T12:45:16.0000000Z '
//         2018-08-18T12:45:16.0000000+02:00   --> 2018-08-18 12:45:16 +02:00
//         2018-08-18T12:45:16.0000000-07:00   --> 2018-08-18 12:45:16 -07:00
//
//      -----
//
//      Parsing with AllowWhiteSpaces:
//         2018-08-18T12:45:16.0000000Z        --> 2018-08-18 12:45:16 +00:00
//         Unable to convert '2018/08/18T12:45:16.0000000Z'
//         Unable to convert '2018-18-08T12:45:16.0000000Z'
//         2018-08-18T12:45:16.0000000         --> 2018-08-18 12:45:16 -07:00
//          2018-08-18T12:45:16.0000000Z       --> 2018-08-18 12:45:16 +00:00
//         2018-08-18T12:45:16.0000000+02:00   --> 2018-08-18 12:45:16 +02:00
//         2018-08-18T12:45:16.0000000-07:00   --> 2018-08-18 12:45:16 -07:00
//
//      -----
//
//      Parsing with AdjustToUniversal:
//         2018-08-18T12:45:16.0000000Z        --> 2018-08-18 12:45:16 +00:00
//         Unable to convert '2018/08/18T12:45:16.0000000Z'
//         Unable to convert '2018-18-08T12:45:16.0000000Z'
//         2018-08-18T12:45:16.0000000         --> 2018-08-18 19:45:16 +00:00
//         Unable to convert ' 2018-08-18T12:45:16.0000000Z '
//         2018-08-18T12:45:16.0000000+02:00   --> 2018-08-18 10:45:16 +00:00
//         2018-08-18T12:45:16.0000000-07:00   --> 2018-08-18 19:45:16 +00:00
//
//      -----
//
//      Parsing with AssumeLocal:
//         2018-08-18T12:45:16.0000000Z        --> 2018-08-18 12:45:16 +00:00
//         Unable to convert '2018/08/18T12:45:16.0000000Z'
//         Unable to convert '2018-18-08T12:45:16.0000000Z'
//         2018-08-18T12:45:16.0000000         --> 2018-08-18 12:45:16 -07:00
//         Unable to convert ' 2018-08-18T12:45:16.0000000Z '
//         2018-08-18T12:45:16.0000000+02:00   --> 2018-08-18 12:45:16 +02:00
//         2018-08-18T12:45:16.0000000-07:00   --> 2018-08-18 12:45:16 -07:00
//
//      -----
//
//      Parsing with AssumeUniversal:
//         2018-08-18T12:45:16.0000000Z        --> 2018-08-18 12:45:16 +00:00
//         Unable to convert '2018/08/18T12:45:16.0000000Z'
//         Unable to convert '2018-18-08T12:45:16.0000000Z'
//         2018-08-18T12:45:16.0000000         --> 2018-08-18 12:45:16 +00:00
//         Unable to convert ' 2018-08-18T12:45:16.0000000Z '
//         2018-08-18T12:45:16.0000000+02:00   --> 2018-08-18 12:45:16 +02:00
//         2018-08-18T12:45:16.0000000-07:00   --> 2018-08-18 12:45:16 -07:00

Imports System.Globalization

Public Module Example
   Public Sub Main()
      Dim dateStrings() = { "2018-08-18T12:45:16.0000000Z",
                            "2018/08/18T12:45:16.0000000Z",
                            "2018-18-08T12:45:16.0000000Z",
                            "2018-08-18T12:45:16.0000000",                               
                            " 2018-08-18T12:45:16.0000000Z ",
                            "2018-08-18T12:45:16.0000000+02:00",
                            "2018-08-18T12:45:16.0000000-07:00" } 
      
      ParseWithISO8601(dateStrings, DateTimeStyles.None)
      Console.WriteLine($"{vbCrLf}-----{vbCrLf}")
      ParseWithISO8601(dateStrings, DateTimeStyles.AllowWhiteSpaces)
      Console.WriteLine($"{vbCrLf}-----{vbCrLf}")
      ParseWithISO8601(dateStrings, DateTimeStyles.AdjustToUniversal)
      Console.WriteLine($"{vbCrLf}-----{vbCrLf}")
      ParseWithISO8601(dateStrings, DateTimeStyles.AssumeLocal)
      Console.WriteLine($"{vbCrLf}-----{vbCrLf}")
      ParseWithISO8601(dateStrings, DateTimeStyles.AssumeUniversal)   
   End Sub

   Private Sub ParseWithISO8601(dateStrings() As String, styles As DateTimeStyles)
      Console.WriteLine($"Parsing with {styles}:")
      Dim dat As DateTimeOffset
      For Each dateStr In dateStrings
         If DateTimeOffset.TryParseExact(dateStr, "O", Nothing, styles, dat) Then
            Console.WriteLine($"   {dateStr,-35} --> {dat:yyyy-MM-dd HH:mm:ss.FF zzz}")
         Else
            Console.WriteLine($"   Unable to convert '{dateStr}'")
         End If   
      Next 
   End Sub
End Module
' The example displays the following output:
'      Parsing with None:
'         2018-08-18T12:45:16.0000000Z        --> 2018-08-18 12:45:16 +00:00
'         Unable to convert '2018/08/18T12:45:16.0000000Z'
'         Unable to convert '2018-18-08T12:45:16.0000000Z'
'         2018-08-18T12:45:16.0000000         --> 2018-08-18 12:45:16 -07:00
'         Unable to convert ' 2018-08-18T12:45:16.0000000Z '
'         2018-08-18T12:45:16.0000000+02:00   --> 2018-08-18 12:45:16 +02:00
'         2018-08-18T12:45:16.0000000-07:00   --> 2018-08-18 12:45:16 -07:00
'
'      -----
'
'      Parsing with AllowWhiteSpaces:
'         2018-08-18T12:45:16.0000000Z        --> 2018-08-18 12:45:16 +00:00
'         Unable to convert '2018/08/18T12:45:16.0000000Z'
'         Unable to convert '2018-18-08T12:45:16.0000000Z'
'         2018-08-18T12:45:16.0000000         --> 2018-08-18 12:45:16 -07:00
'          2018-08-18T12:45:16.0000000Z       --> 2018-08-18 12:45:16 +00:00
'         2018-08-18T12:45:16.0000000+02:00   --> 2018-08-18 12:45:16 +02:00
'         2018-08-18T12:45:16.0000000-07:00   --> 2018-08-18 12:45:16 -07:00
'
'      -----
'
'      Parsing with AdjustToUniversal:
'         2018-08-18T12:45:16.0000000Z        --> 2018-08-18 12:45:16 +00:00
'         Unable to convert '2018/08/18T12:45:16.0000000Z'
'         Unable to convert '2018-18-08T12:45:16.0000000Z'
'         2018-08-18T12:45:16.0000000         --> 2018-08-18 19:45:16 +00:00
'         Unable to convert ' 2018-08-18T12:45:16.0000000Z '
'         2018-08-18T12:45:16.0000000+02:00   --> 2018-08-18 10:45:16 +00:00
'         2018-08-18T12:45:16.0000000-07:00   --> 2018-08-18 19:45:16 +00:00
'
'      -----
'
'      Parsing with AssumeLocal:
'         2018-08-18T12:45:16.0000000Z        --> 2018-08-18 12:45:16 +00:00
'         Unable to convert '2018/08/18T12:45:16.0000000Z'
'         Unable to convert '2018-18-08T12:45:16.0000000Z'
'         2018-08-18T12:45:16.0000000         --> 2018-08-18 12:45:16 -07:00
'         Unable to convert ' 2018-08-18T12:45:16.0000000Z '
'         2018-08-18T12:45:16.0000000+02:00   --> 2018-08-18 12:45:16 +02:00
'         2018-08-18T12:45:16.0000000-07:00   --> 2018-08-18 12:45:16 -07:00
'
'      -----
'
'      Parsing with AssumeUniversal:
'         2018-08-18T12:45:16.0000000Z        --> 2018-08-18 12:45:16 +00:00
'         Unable to convert '2018/08/18T12:45:16.0000000Z'
'         Unable to convert '2018-18-08T12:45:16.0000000Z'
'         2018-08-18T12:45:16.0000000         --> 2018-08-18 12:45:16 +00:00
'         Unable to convert ' 2018-08-18T12:45:16.0000000Z '
'         2018-08-18T12:45:16.0000000+02:00   --> 2018-08-18 12:45:16 +02:00
'         2018-08-18T12:45:16.0000000-07:00   --> 2018-08-18 12:45:16 -07:00

Comentarios

Esta sobrecarga del método TryParseExact(String, String, IFormatProvider, DateTimeStyles, DateTimeOffset) es similar al método DateTimeOffset.ParseExact(String, String, IFormatProvider, DateTimeStyles), salvo que este método no produce una excepción si se produce un error en la conversión. Analiza la representación de cadena de una fecha y hora que debe coincidir exactamente con el patrón especificado por el parámetro format. Si la cadena de input no coincide con este patrón, con algunas posibles variaciones en el espacio en blanco definido por el parámetro styles, se produce un error en la operación de análisis y el método devuelve false.

El parámetro format es una cadena que contiene un único especificador de formato estándar o uno o varios especificadores de formato personalizados que definen el patrón necesario de input. Para obtener más información sobre los códigos de formato válidos, vea cadenas de formato de fecha y hora estándar y cadenas de formato de fecha y hora personalizados. Si format incluye el z, zzo zzz especificadores de formato personalizado para indicar que un desplazamiento debe estar presente en input, ese desplazamiento debe incluir un signo negativo o un signo positivo. Si falta el signo, se produce un error en la operación de análisis y el método devuelve false.

Si format requiere que input contengan una fecha pero no una hora, al objeto de DateTimeOffset resultante se le asigna una hora de medianoche (0:00:00). Si format requiere que input contengan una hora pero no una fecha, al objeto DateTimeOffset resultante se le asigna la fecha actual en el sistema local. Si format no requiere que input contengan un desplazamiento, el desplazamiento del objeto DateTimeOffset resultante depende del valor del parámetro styles. Si styles incluye AssumeLocal, el desplazamiento de la zona horaria local se asigna al objeto DateTimeOffset. Si styles incluye AssumeUniversal, el desplazamiento hora universal coordinada (UTC) o +00:00, se asigna al objeto DateTimeOffset. Si no se especifica ningún valor, se usa el desplazamiento de la zona horaria local.

El parámetro formatProvider define los símbolos y cadenas de fecha y hora concretos que se usan en input. Lo mismo sucede con el patrón preciso de input si format es una cadena de especificador de formato estándar. El parámetro formatProvider puede ser cualquiera de los siguientes:

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

El parámetro styles define si se permite el espacio en blanco en la cadena de entrada, indica cómo se analizan las cadenas sin un componente de desplazamiento explícito y admite la conversión UTC como parte de la operación de análisis. Se admiten todos los miembros de la enumeración DateTimeStyles, excepto NoCurrentDateDefault. En la tabla siguiente se muestra el efecto de cada miembro admitido.

miembro de DateTimeStyles Comportamiento
AdjustToUniversal Analiza input y, si es necesario, lo convierte en UTC. Es equivalente a analizar una cadena y, a continuación, llamar al método DateTimeOffset.ToUniversalTime del objeto DateTimeOffset devuelto.
AssumeLocal Si format no requiere que input contengan un valor de desplazamiento, el objeto devuelto DateTimeOffset recibe el desplazamiento de la zona horaria local. Este es el comportamiento predeterminado.
AssumeUniversal Si format no requiere que input contengan un valor de desplazamiento, el objeto DateTimeOffset devuelto recibe el desplazamiento UTC (+00:00).
AllowInnerWhite Permite que input incluyan espacios en blanco internos no especificados por formato. El espacio en blanco adicional puede aparecer entre los componentes de fecha y hora y dentro de los componentes individuales, excepto el desplazamiento, y se omite al analizar la cadena.
AllowLeadingWhite Permite que input incluyan espacios iniciales no especificados por format. Estos se omiten al analizar la cadena.
AllowTrailingWhite Permite input incluir espacios finales no especificados por format. Estos se omiten al analizar la cadena.
AllowWhiteSpaces Permite que input incluyan espacios iniciales, finales e internos no especificados por format. Todos los caracteres de espacio en blanco adicionales no especificados en format se omiten al analizar la cadena.
None Indica que no se permite espacio en blanco adicional en input. El espacio en blanco debe aparecer exactamente como se especifica en format. Este es el comportamiento predeterminado.
RoundtripKind No tiene ningún efecto, ya que la estructura DateTimeOffset no incluye una propiedad Kind.

Notas a los autores de las llamadas

En .NET Framework 4, el 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

Se aplica a