DateTimeOffset.ParseExact Método

Referencia

Definición

Espacio de nombres:: System

Ensamblado:: System.Runtime.dll

Ensamblado:: mscorlib.dll

Ensamblado:: netstandard.dll

Importante

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

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

Sobrecargas

ParseExact(String, String[], IFormatProvider, DateTimeStyles)	Convierte la representación de cadena especificada de una fecha y hora en su equivalente de DateTimeOffset, usando los 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 uno de los formatos especificados.
ParseExact(String, String, IFormatProvider, DateTimeStyles)	Convierte la representación de cadena especificada de una fecha y hora en el objeto DateTimeOffset 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.
ParseExact(String, String, IFormatProvider)	Convierte la representación de cadena especificada de una fecha y hora en el objeto DateTimeOffset equivalente, usando la información de formato específica de la referencia cultural y el formato que se hayan especificado. El formato de la representación de cadena debe coincidir exactamente con el formato especificado.
ParseExact(ReadOnlySpan<Char>, ReadOnlySpan<Char>, IFormatProvider, DateTimeStyles)	Convierte un intervalo de caracteres que representa una fecha y hora en su objeto DateTimeOffset equivalente mediante el formato, la información de formato específica de la cultura y el estilo especificados. El formato de la representación de fecha y hora debe coincidir exactamente con el formato especificado.
ParseExact(ReadOnlySpan<Char>, String[], IFormatProvider, DateTimeStyles)	Convierte un intervalo de caracteres que contiene la representación de cadena de una fecha y hora en su objeto DateTimeOffset equivalente mediante los formatos, la información de formato específica de la cultura y el estilo especificados. El formato de la representación de fecha y hora debe coincidir exactamente con uno de los formatos especificados.

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

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

public:
 static DateTimeOffset ParseExact(System::String ^ input, cli::array <System::String ^> ^ formats, IFormatProvider ^ formatProvider, System::Globalization::DateTimeStyles styles);

public static DateTimeOffset ParseExact (string input, string[] formats, IFormatProvider formatProvider, System.Globalization.DateTimeStyles styles);

public static DateTimeOffset ParseExact (string input, string[] formats, IFormatProvider? formatProvider, System.Globalization.DateTimeStyles styles);

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

Public Shared Function ParseExact (input As String, formats As String(), formatProvider As IFormatProvider, styles As DateTimeStyles) As DateTimeOffset

Parámetros

input: String

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

formats: String[]

Matriz de especificadores de formato que definen los formatos esperados de input.

formatProvider: IFormatProvider

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

styles: DateTimeStyles

Combinación bit a bit de valores de enumeración que indica el formato permitido de input.

Devoluciones

DateTimeOffset

Objeto equivalente a la fecha y hora contenidas en el parámetro input, tal como especifican los parámetros formats, formatProvider y styles.

Excepciones

ArgumentException

El desplazamiento es mayor que 14 horas o menor que -14 horas.

o bien

styles incluye un valor no admitido.

o bien

El parámetro styles contiene valores DateTimeStyles que no pueden usarse juntos.

ArgumentNullException

input es null.

FormatException

input es una cadena vacía ("").

o bien

input no contiene una representación de cadena válida de una fecha y una hora.

o bien

Ningún elemento de formats contiene un especificador de formato válido.

o bien

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

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 DateTimeOffset.ParseExact(String, String[], IFormatProvider, DateTimeStyles) usuario al método .

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 = new 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();
   try
   {
      result = DateTimeOffset.ParseExact(input, formats, provider,
                                         DateTimeStyles.AllowWhiteSpaces);
      break;
   }
   catch (FormatException)
   {
      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 input = String.Empty
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

let mutable result = None
let mutable tries = 0
while tries < 3 && result.IsNone do
    printfn "Enter a date, time, and offset (MM/DD/YYYY HH:MM +/-HH:MM),"
    printf "Then press Enter: "
    let input = stdin.ReadLine()
    printfn ""
    try
        result <- 
            DateTimeOffset.ParseExact(input, formats, provider, DateTimeStyles.AllowWhiteSpaces) 
            |> Some
    with :? FormatException ->
        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() 
    Try
       result = DateTimeOffset.ParseExact(input, formats, provider, _
                                          DateTimeStyles.AllowWhiteSpaces)
       Exit Do
    Catch e As FormatException
       Console.WriteLine("Unable to parse {0}.", input)      
       tries += 1
    End Try
 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 DateTimeOffset.ParseExact(String, String[], IFormatProvider, DateTimeStyles) método analiza la representación de cadena de una fecha que coincide con cualquiera de los patrones asignados al formats parámetro . Si la input cadena no coincide con ninguno de estos patrones con ninguna de las variaciones definidas por el styles parámetro , el método produce una FormatExceptionexcepción . Además de comparar input con varios patrones de formato, esta sobrecarga se comporta de forma idéntica al DateTimeOffset.ParseExact(String, String, IFormatProvider, DateTimeStyles) método .

El formats parámetro es una matriz de cadenas cuyos elementos contienen un único especificador de formato estándar o uno o varios especificadores de formato personalizado que definen el patrón posible del input parámetro. Cuando se llama al método , input debe coincidir con uno de estos patrones. 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 los zespecificadores de formato personalizado , zzo zzz 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, el método produce una FormatExceptionexcepción .

Importante

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

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

Objeto CultureInfo que representa la referencia cultural basada en la que input se interpreta. El DateTimeFormatInfo objeto devuelto por la CultureInfo.DateTimeFormat propiedad define los símbolos y el formato en input.
Objeto DateTimeFormatInfo que define el formato de los datos de fecha y hora.

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

El styles parámetro 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 DateTimeStyles enumeración, excepto NoCurrentDateDefault. En la tabla siguiente se muestra el efecto de cada miembro admitido.

Miembro`DateTimeStyles`	Comportamiento
AdjustToUniversal	`input` Analiza y, si es necesario, lo convierte en UTC. Equivale a analizar una cadena y, a continuación, llamar al DateTimeOffset.ToUniversalTime método del objeto devuelto DateTimeOffset .
AssumeLocal	Si el elemento coincidente de `formats` no requiere que `input` contenga un valor de desplazamiento, el objeto devuelto DateTimeOffset 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 `input` incluir espacios en blanco internos no especificados por `format`. 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 `input` incluir espacios iniciales no especificados por `formats`. Se omiten al analizar la cadena.
AllowTrailingWhite	Permite `input` incluir espacios finales no especificados por `formats`. Se omiten al analizar la cadena.
AllowWhiteSpaces	Permite `input` incluir espacios iniciales, finales y internos no especificados por `formats`. Todos los caracteres de espacio en blanco adicionales no especificados en el elemento coincidente en `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 de `formats` para que se produzca una coincidencia. Este es el comportamiento predeterminado.
RoundtripKind	No tiene ningún efecto porque la DateTimeOffset estructura no incluye una `Kind` propiedad .

Notas a los autores de las llamadas

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

Consulte también

Se aplica a

ParseExact(String, String, IFormatProvider, DateTimeStyles)

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

public:
 static DateTimeOffset ParseExact(System::String ^ input, System::String ^ format, IFormatProvider ^ formatProvider, System::Globalization::DateTimeStyles styles);

public static DateTimeOffset ParseExact (string input, string format, IFormatProvider formatProvider, System.Globalization.DateTimeStyles styles);

public static DateTimeOffset ParseExact (string input, string format, IFormatProvider? formatProvider, System.Globalization.DateTimeStyles styles);

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

Public Shared Function ParseExact (input As String, format As String, formatProvider As IFormatProvider, styles As DateTimeStyles) As DateTimeOffset

Parámetros

input: String

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

format: String

Especificador de formato que define el formato esperado de input.

formatProvider: IFormatProvider

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

styles: DateTimeStyles

Combinación bit a bit de valores de enumeración que indica el formato permitido de input.

Devoluciones

DateTimeOffset

Objeto equivalente a la fecha y hora contenidas en el parámetro input, tal como especifican los parámetros format, formatProvider y styles.

Excepciones

ArgumentException

El desplazamiento es mayor que 14 horas o menor que -14 horas.

o bien

El parámetro styles incluye un valor no admitido.

o bien

El parámetro styles contiene valores DateTimeStyles que no pueden usarse juntos.

ArgumentNullException

input es null.

O bien

format es null.

FormatException

input es una cadena vacía ("").

o bien

input no contiene una representación de cadena válida de una fecha y una hora.

o bien

format es una cadena vacía.

O bien

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

Ejemplos

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

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

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

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

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

// Parse date and time and convert to UTC.
dateString = "  06/15/2008 15:15:30 -05:00";
format = "MM/dd/yyyy H:mm:ss zzz";
try
{
   result = DateTimeOffset.ParseExact(dateString, format, provider,
                                      DateTimeStyles.AllowWhiteSpaces |
                                      DateTimeStyles.AdjustToUniversal);
   Console.WriteLine("'{0}' converts to {1}.", dateString, result.ToString());
}
catch (FormatException)
{
   Console.WriteLine("'{0}' is not in the correct format.", dateString);
}
// The example displays the following output:
//    '06/15/2008' converts to 6/15/2008 12:00:00 AM +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"
try
    let result = DateTimeOffset.ParseExact(dateString, format, provider, DateTimeStyles.AssumeUniversal)
    printfn $"'{dateString}' converts to {result}."
with :? FormatException ->
    printfn $"'{dateString}' is not in the correct format."

// Parse date-only value with leading white space.
// Should throw a FormatException because only trailing white space is
// specified in method call.
let dateString = " 06/15/2008"
try
    let result = DateTimeOffset.ParseExact(dateString, format, provider, DateTimeStyles.AllowTrailingWhite)
    printfn $"'{dateString}' converts to {result}."
with :? FormatException ->
    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"
try
    let result = DateTimeOffset.ParseExact(dateString, format, provider, DateTimeStyles.AllowWhiteSpaces)
    printfn $"'{dateString}' converts to {result}."
with :? FormatException ->
    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"
try
    let result = 
        DateTimeOffset.ParseExact(dateString, format, provider,
                                  DateTimeStyles.AllowWhiteSpaces |||
                                  DateTimeStyles.AdjustToUniversal)
    printfn $"'{dateString}' converts to {result}."
with :? FormatException ->
    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"
Try
   result = DateTimeOffset.ParseExact(dateString, format, provider, _
                                      DateTimeStyles.AssumeUniversal)
   Console.WriteLine("'{0}' converts to {1}.", dateString, result.ToString())
Catch e As FormatException
   Console.WriteLine("'{0}' is not in the correct format.", dateString)
End Try 

' Parse date-only value with leading white space.
' Should throw a FormatException because only trailing white space is  
' specified in method call.
dateString = " 06/15/2008"
Try
   result = DateTimeOffset.ParseExact(dateString, format, provider, _
                                      DateTimeStyles.AllowTrailingWhite)
   Console.WriteLine("'{0}' converts to {1}.", dateString, result.ToString())
Catch e As FormatException
   Console.WriteLine("'{0}' is not in the correct format.", dateString)
End Try 

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

' Parse date and time and convert to UTC.
dateString = "  06/15/2008 15:15:30 -05:00"   
format = "MM/dd/yyyy H:mm:ss zzz"       
Try
   result = DateTimeOffset.ParseExact(dateString, format, provider, _
                                      DateTimeStyles.AllowWhiteSpaces Or _
                                      DateTimeStyles.AdjustToUniversal)
   Console.WriteLine("'{0}' converts to {1}.", dateString, result.ToString())
Catch e As FormatException
   Console.WriteLine("'{0}' is not in the correct format.", dateString)
End Try 
' 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 DateTimeStyles valores 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 se pueden analizar si:

contienen espacios en blanco y una marca adecuada DateTimeStyles (por DateTimeStyles.AllowWhiteSpaces ejemplo, no se ha proporcionado en la llamada al método.
contienen elementos de fecha y hora que están fuera del intervalo.

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

module parseexact_iso8601_2

open System
open System.Globalization

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" |] 

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

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
//         FormatException: Unable to convert '2018/08/18T12:45:16.0000000Z'
//         FormatException: Unable to convert '2018-18-08T12:45:16.0000000Z'
//         2018-08-18T12:45:16.0000000         --> 2018-08-18 12:45:16 -07:00
//         FormatException: 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
//         FormatException: Unable to convert '2018/08/18T12:45:16.0000000Z'
//         FormatException: 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
//         FormatException: Unable to convert '2018/08/18T12:45:16.0000000Z'
//         FormatException: Unable to convert '2018-18-08T12:45:16.0000000Z'
//         2018-08-18T12:45:16.0000000         --> 2018-08-18 19:45:16 +00:00
//         FormatException: 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
//         FormatException: Unable to convert '2018/08/18T12:45:16.0000000Z'
//         FormatException: Unable to convert '2018-18-08T12:45:16.0000000Z'
//         2018-08-18T12:45:16.0000000         --> 2018-08-18 12:45:16 -07:00
//         FormatException: 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
//         FormatException: Unable to convert '2018/08/18T12:45:16.0000000Z'
//         FormatException: Unable to convert '2018-18-08T12:45:16.0000000Z'
//         2018-08-18T12:45:16.0000000         --> 2018-08-18 12:45:16 +00:00
//         FormatException: 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}:");
      foreach (var dateString in dateStrings)
      {
         try {
            var date = DateTimeOffset.ParseExact(dateString, "O", null, styles);
            Console.WriteLine($"   {dateString,-35} --> {date:yyyy-MM-dd HH:mm:ss.FF zzz}");
         }
         catch (FormatException)
         {
            Console.WriteLine($"   FormatException: 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
//         FormatException: Unable to convert '2018/08/18T12:45:16.0000000Z'
//         FormatException: Unable to convert '2018-18-08T12:45:16.0000000Z'
//         2018-08-18T12:45:16.0000000         --> 2018-08-18 12:45:16 -07:00
//         FormatException: 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
//         FormatException: Unable to convert '2018/08/18T12:45:16.0000000Z'
//         FormatException: 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
//         FormatException: Unable to convert '2018/08/18T12:45:16.0000000Z'
//         FormatException: Unable to convert '2018-18-08T12:45:16.0000000Z'
//         2018-08-18T12:45:16.0000000         --> 2018-08-18 19:45:16 +00:00
//         FormatException: 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
//         FormatException: Unable to convert '2018/08/18T12:45:16.0000000Z'
//         FormatException: Unable to convert '2018-18-08T12:45:16.0000000Z'
//         2018-08-18T12:45:16.0000000         --> 2018-08-18 12:45:16 -07:00
//         FormatException: 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
//         FormatException: Unable to convert '2018/08/18T12:45:16.0000000Z'
//         FormatException: Unable to convert '2018-18-08T12:45:16.0000000Z'
//         2018-08-18T12:45:16.0000000         --> 2018-08-18 12:45:16 +00:00
//         FormatException: 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}:")
      For Each dateStr In dateStrings
         Try 
            Dim dat = DateTimeOffset.ParseExact(dateString, "O", Nothing, styles)
            Console.WriteLine($"   {dateString,-35} --> {dat:yyyy-MM-dd HH:mm:ss.FF zzz}")
         catch e As FormatException
            Console.WriteLine($"   FormatException: Unable to convert '{dateString}'")
         End Try   
      Next 
   End Sub
End Module
' The example displays the following output:
'      Parsing with None:
'         FormatException: Unable to convert '07-30-2018'
'         FormatException: Unable to convert '07-30-2018'
'         FormatException: Unable to convert '07-30-2018'
'         FormatException: Unable to convert '07-30-2018'
'         FormatException: Unable to convert '07-30-2018'
'         FormatException: Unable to convert '07-30-2018'
'         FormatException: Unable to convert '07-30-2018'
'
'      -----
'
'      Parsing with AllowWhiteSpaces:
'         FormatException: Unable to convert '07-30-2018'
'         FormatException: Unable to convert '07-30-2018'
'         FormatException: Unable to convert '07-30-2018'
'         FormatException: Unable to convert '07-30-2018'
'         FormatException: Unable to convert '07-30-2018'
'         FormatException: Unable to convert '07-30-2018'
'         FormatException: Unable to convert '07-30-2018'
'
'      -----
'
'      Parsing with AdjustToUniversal:
'         FormatException: Unable to convert '07-30-2018'
'         FormatException: Unable to convert '07-30-2018'
'         FormatException: Unable to convert '07-30-2018'
'         FormatException: Unable to convert '07-30-2018'
'         FormatException: Unable to convert '07-30-2018'
'         FormatException: Unable to convert '07-30-2018'
'         FormatException: Unable to convert '07-30-2018'
'
'      -----
'
'      Parsing with AssumeLocal:
'         FormatException: Unable to convert '07-30-2018'
'         FormatException: Unable to convert '07-30-2018'
'         FormatException: Unable to convert '07-30-2018'
'         FormatException: Unable to convert '07-30-2018'
'         FormatException: Unable to convert '07-30-2018'
'         FormatException: Unable to convert '07-30-2018'
'         FormatException: Unable to convert '07-30-2018'
'
'      -----
'
'      Parsing with AssumeUniversal:
'         FormatException: Unable to convert '07-30-2018'
'         FormatException: Unable to convert '07-30-2018'
'         FormatException: Unable to convert '07-30-2018'
'         FormatException: Unable to convert '07-30-2018'
'         FormatException: Unable to convert '07-30-2018'
'         FormatException: Unable to convert '07-30-2018'
'         FormatException: Unable to convert '07-30-2018'

Comentarios

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

El format parámetro 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 del input parámetro. 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 los zespecificadores de formato personalizado , zzo zzz 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, el método produce una FormatExceptionexcepción .

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

El parámetro define formatProvider los símbolos y cadenas de fecha y hora concretos utilizados en input . Lo mismo sucede con el formato preciso de , si format es una cadena de inputespecificador de formato estándar. El formatProvider parámetro puede ser cualquiera de los siguientes:

Objeto CultureInfo que representa la referencia cultural basada en la que input se interpreta. El DateTimeFormatInfo objeto devuelto por la CultureInfo.DateTimeFormat propiedad define los símbolos y el formato en input.
Objeto DateTimeFormatInfo que define el formato de los datos de fecha y hora.

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

Miembro`DateTimeStyles`	Comportamiento
AdjustToUniversal	Analiza y, si es `input` necesario, lo convierte en UTC. Equivale a analizar una cadena y, a continuación, llamar al DateTimeOffset.ToUniversalTime método del objeto devuelto DateTimeOffset .
AssumeLocal	Si `format` no requiere que `input` contenga un valor de desplazamiento, el objeto devuelto DateTimeOffset recibe el desplazamiento de la zona horaria local. Este es el valor predeterminado.
AssumeUniversal	Si `format` no requiere que `input` contenga un valor de desplazamiento, el objeto devuelto DateTimeOffset recibe el desplazamiento UTC (+00:00).
AllowInnerWhite	Permite `input` incluir espacios en blanco internos no especificados por `format`. El espacio en blanco adicional puede aparecer entre los componentes de fecha y hora y dentro de los componentes individuales, y se omite al analizar la cadena.
AllowLeadingWhite	Permite `input` incluir espacios iniciales no especificados por `format`. Se omiten al analizar la cadena.
AllowTrailingWhite	Permite `input` incluir espacios finales no especificados por `format`. Se omiten al analizar la cadena.
AllowWhiteSpaces	Permite `input` incluir espacios iniciales, finales y internos no especificados por `format`. Todos los caracteres de espacio en blanco adicionales que no se especifican 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 porque la DateTimeOffset estructura no incluye una `Kind` propiedad .

Notas a los autores de las llamadas

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

Consulte también

Se aplica a

ParseExact(String, String, IFormatProvider)

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

public:
 static DateTimeOffset ParseExact(System::String ^ input, System::String ^ format, IFormatProvider ^ formatProvider);

public static DateTimeOffset ParseExact (string input, string format, IFormatProvider formatProvider);

public static DateTimeOffset ParseExact (string input, string format, IFormatProvider? formatProvider);

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

Public Shared Function ParseExact (input As String, format As String, formatProvider As IFormatProvider) As DateTimeOffset

Parámetros

input: String

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

format: String

Especificador de formato que define el formato esperado de input.

formatProvider: IFormatProvider

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

Devoluciones

DateTimeOffset

Objeto equivalente a la fecha y hora que se indican en input, tal como especifican format y formatProvider.

Excepciones

ArgumentException

El desplazamiento es mayor que 14 horas o menor que -14 horas.

ArgumentNullException

input es null.

O bien

format es null.

FormatException

input es una cadena vacía ("").

o bien

input no contiene una representación de cadena válida de una fecha y una hora.

o bien

format es una cadena vacía.

O bien

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

Ejemplos

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

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

// Parse date-only value with invariant culture.
dateString = "06/15/2008";
format = "d";
try
{
   result = DateTimeOffset.ParseExact(dateString, format, provider);
   Console.WriteLine("{0} converts to {1}.", dateString, result.ToString());
}
catch (FormatException)
{
   Console.WriteLine("{0} is not in the correct format.", dateString);
}

// Parse date-only value without leading zero in month using "d" format.
// Should throw a FormatException because standard short date pattern of
// invariant culture requires two-digit month.
dateString = "6/15/2008";
try
{
   result = DateTimeOffset.ParseExact(dateString, format, provider);
   Console.WriteLine("{0} converts to {1}.", dateString, result.ToString());
}
catch (FormatException)
{
   Console.WriteLine("{0} is not in the correct format.", dateString);
}

// Parse date and time with custom specifier.
dateString = "Sun 15 Jun 2008 8:30 AM -06:00";
format = "ddd dd MMM yyyy h:mm tt zzz";
try
{
   result = DateTimeOffset.ParseExact(dateString, format, provider);
   Console.WriteLine("{0} converts to {1}.", dateString, result.ToString());
}
catch (FormatException)
{
   Console.WriteLine("{0} is not in the correct format.", dateString);
}

// Parse date and time with offset without offset//s minutes.
// Should throw a FormatException because "zzz" specifier requires leading
// zero in hours.
dateString = "Sun 15 Jun 2008 8:30 AM -06";
try
{
   result = DateTimeOffset.ParseExact(dateString, format, provider);
   Console.WriteLine("{0} converts to {1}.", dateString, result.ToString());
}
catch (FormatException)
{
   Console.WriteLine("{0} is not in the correct format.", dateString);
}
// The example displays the following output:
//    06/15/2008 converts to 6/15/2008 12:00:00 AM -07:00.
//    6/15/2008 is not in the correct format.
//    Sun 15 Jun 2008 8:30 AM -06:00 converts to 6/15/2008 8:30:00 AM -06:00.
//    Sun 15 Jun 2008 8:30 AM -06 is not in the correct format.

let provider = CultureInfo.InvariantCulture

// Parse date-only value with invariant culture.
let dateString = "06/15/2008"
let format = "d"
try
    let result = DateTimeOffset.ParseExact(dateString, format, provider)
    printfn $"{dateString} converts to {result}."
with :? FormatException ->
    printfn $"{dateString} is not in the correct format."

// Parse date-only value without leading zero in month using "d" format.
// Should throw a FormatException because standard short date pattern of
// invariant culture requires two-digit month.
let dateString = "6/15/2008"
try
    let result = DateTimeOffset.ParseExact(dateString, format, provider)
    printfn $"{dateString} converts to {result}."
with :? FormatException ->
    printfn $"{dateString} is not in the correct format."

// Parse date and time with custom specifier.
let dateString = "Sun 15 Jun 2008 8:30 AM -06:00"
let format = "ddd dd MMM yyyy h:mm tt zzz"
try
    let result = DateTimeOffset.ParseExact(dateString, format, provider)
    printfn $"{dateString} converts to {result}."
with :? FormatException ->
    printfn $"{dateString} is not in the correct format."

// Parse date and time with offset without offset//s minutes.
// Should throw a FormatException because "zzz" specifier requires leading
// zero in hours.
let dateString = "Sun 15 Jun 2008 8:30 AM -06"
try
    let result = DateTimeOffset.ParseExact(dateString, format, provider)
    printfn $"{dateString} converts to {result}."
with :? FormatException ->
    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 -07:00.
//    6/15/2008 is not in the correct format.
//    Sun 15 Jun 2008 8:30 AM -06:00 converts to 6/15/2008 8:30:00 AM -06:00.
//    Sun 15 Jun 2008 8:30 AM -06 is not in the correct format.

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

' Parse date-only value with invariant culture.
dateString = "06/15/2008"
format = "d"
Try
   result = DateTimeOffset.ParseExact(dateString, format, provider)
   Console.WriteLine("{0} converts to {1}.", dateString, result.ToString())
Catch e As FormatException
   Console.WriteLine("{0} is not in the correct format.", dateString)
End Try 

' Parse date-only value without leading zero in month using "d" format.
' Should throw a FormatException because standard short date pattern of 
' invariant culture requires two-digit month.
dateString = "6/15/2008"
Try
   result = DateTimeOffset.ParseExact(dateString, format, provider)
   Console.WriteLine("{0} converts to {1}.", dateString, result.ToString())
Catch e As FormatException
   Console.WriteLine("{0} is not in the correct format.", dateString)
End Try 

' Parse date and time with custom specifier.
dateString = "Sun 15 Jun 2008 8:30 AM -06:00"
format = "ddd dd MMM yyyy h:mm tt zzz"        
Try
   result = DateTimeOffset.ParseExact(dateString, format, provider)
   Console.WriteLine("{0} converts to {1}.", dateString, result.ToString())
Catch e As FormatException
   Console.WriteLine("{0} is not in the correct format.", dateString)
End Try 

' Parse date and time with offset without offset's minutes.
' Should throw a FormatException because "zzz" specifier requires leading  
' zero in hours.
dateString = "Sun 15 Jun 2008 8:30 AM -06"
Try
   result = DateTimeOffset.ParseExact(dateString, format, provider)
   Console.WriteLine("{0} converts to {1}.", dateString, result.ToString())
Catch e As FormatException
   Console.WriteLine("{0} is not in the correct format.", dateString)
End Try 
' The example displays the following output:
'    06/15/2008 converts to 6/15/2008 12:00:00 AM -07:00.
'    6/15/2008 is not in the correct format.
'    Sun 15 Jun 2008 8:30 AM -06:00 converts to 6/15/2008 8:30:00 AM -06:00.
'    Sun 15 Jun 2008 8:30 AM -06 is not in the correct format.

En el ejemplo siguiente se analiza una matriz de cadenas que se espera que se ajusten a ISO 8601. Como se muestra en la salida del ejemplo, las cadenas con espacios iniciales o finales no se analizan correctamente, al igual que las cadenas con elementos de fecha y hora que están fuera del intervalo.

module parseexact_iso8601

open System

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.0000000Z "
      "2018-08-18T12:45:16.0000000+02:00"
      "2018-08-18T12:45:16.0000000-07:00" ]

for dateString in dateStrings do
    try
        let date =
            DateTimeOffset.ParseExact(dateString, "O", null)

        printfn $"""{dateString, -35} --> {date.ToString "yyyy-MM-dd HH:mm:ss.FF zzz"}"""
    with :? FormatException -> printfn $"FormatException: Unable to convert '{dateString}'"


// The example displays the following output:
//      2018-08-18T12:45:16.0000000Z        --> 2018-08-18 12:45:16 +00:00
//      FormatException: Unable to convert '2018/08/18T12:45:16.0000000Z'
//      FormatException: Unable to convert '2018-18-08T12:45:16.0000000Z'
//      FormatException: 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;

public class Example2
{
   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.0000000Z ",
                               "2018-08-18T12:45:16.0000000+02:00",
                               "2018-08-18T12:45:16.0000000-07:00" }; 
      
      foreach (var dateString in dateStrings)
      {
         try {
            var date = DateTimeOffset.ParseExact(dateString, "O", null);
            Console.WriteLine($"{dateString,-35} --> {date:yyyy-MM-dd HH:mm:ss.FF zzz}");
         }
         catch (FormatException)
         {
            Console.WriteLine($"FormatException: Unable to convert '{dateString}'");
         }   
      } 
   }
}
// The example displays the following output:
//      2018-08-18T12:45:16.0000000Z        --> 2018-08-18 12:45:16 +00:00
//      FormatException: Unable to convert '2018/08/18T12:45:16.0000000Z'
//      FormatException: Unable to convert '2018-18-08T12:45:16.0000000Z'
//      FormatException: 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

Public Module Example
   Public Sub Main()
      Dim dateStrings() As String = { "2018-08-18T12:45:16.0000000Z",
                                      "2018/08/18T12:45:16.0000000Z",
                                      "2018-18-08T12:45:16.0000000Z",
                                      " 2018-08-18T12:45:16.0000000Z ",
                                      "2018-08-18T12:45:16.0000000+02:00",
                                      "2018-08-18T12:45:16.0000000-07:00" } 
      
      For Each dateStr In dateStrings
         Try 
            Dim dat = DateTimeOffset.ParseExact(dateStr, "O", Nothing)
            Console.WriteLine($"{dateStr,-35} --> {dat:yyyy-MM-dd HH:mm:ss.FF zzz}")
         Catch  e As FormatException
            Console.WriteLine($"FormatException: Unable to convert '{dateStr}'")
         End Try   
      Next 
   End Sub
End Module
' The example displays the following output:
'      2018-08-18T12:45:16.0000000Z        --> 2018-08-18 12:45:16 +00:00
'      FormatException: Unable to convert '2018/08/18T12:45:16.0000000Z'
'      FormatException: Unable to convert '2018-18-08T12:45:16.0000000Z'
'      FormatException: 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

El ParseExact(String, String, IFormatProvider) método analiza la representación de cadena de una fecha, que debe estar en el formato definido por el format parámetro . También requiere que los <Date>elementos , <Time>y <Offset> de la representación de cadena de una fecha y hora aparezcan en el orden especificado por format. Si la input cadena no coincide con este format parámetro, el método produce una FormatExceptionexcepción . En cambio, el DateTimeOffset.Parse(String, IFormatProvider) método analiza la representación de cadena de una fecha en cualquiera de los formatos reconocidos por el objeto del proveedor de DateTimeFormatInfo formato. Parse también permite que los <Date>elementos , <Time>y <Offset> de la representación de cadena de una fecha y hora aparezcan en cualquier orden.

El format parámetro es una cadena que contiene un único especificador de formato estándar o uno o varios especificadores de formato personalizado que definen el formato necesario del input parámetro. 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 los zespecificadores de formato personalizado , zzo zzz 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, el método produce una FormatExceptionexcepción .

El parámetro define formatProvider los símbolos y cadenas de fecha y hora concretos input en , tal como es el formato preciso de input si format es una cadena de especificador de formato estándar. El formatProvider parámetro puede ser cualquiera de los siguientes:

Objeto CultureInfo que representa la referencia cultural basada en la que input se interpreta. El DateTimeFormatInfo objeto devuelto por su DateTimeFormat propiedad define los símbolos y el formato en input.
Objeto DateTimeFormatInfo que define el formato de los datos de fecha y hora.

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

Notas a los autores de las llamadas

Consulte también

Se aplica a

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

Convierte un intervalo de caracteres que representa una fecha y hora en su objeto DateTimeOffset equivalente mediante el formato, la información de formato específica de la cultura y el estilo especificados. El formato de la representación de fecha y hora debe coincidir exactamente con el formato especificado.

public static DateTimeOffset ParseExact (ReadOnlySpan<char> input, ReadOnlySpan<char> format, IFormatProvider? formatProvider, System.Globalization.DateTimeStyles styles = System.Globalization.DateTimeStyles.None);

public static DateTimeOffset ParseExact (ReadOnlySpan<char> input, ReadOnlySpan<char> format, IFormatProvider formatProvider, System.Globalization.DateTimeStyles styles = System.Globalization.DateTimeStyles.None);

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

Public Shared Function ParseExact (input As ReadOnlySpan(Of Char), format As ReadOnlySpan(Of Char), formatProvider As IFormatProvider, Optional styles As DateTimeStyles = System.Globalization.DateTimeStyles.None) As DateTimeOffset

Parámetros

input: ReadOnlySpan<Char>

Un intervalo de caracteres que representa una fecha y hora.

format: ReadOnlySpan<Char>

Un intervalo de caracteres que contiene un especificador de formato que define el formato esperado de input.

formatProvider: IFormatProvider

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

Devoluciones

DateTimeOffset

Objeto equivalente a la fecha y hora contenidas en el parámetro input, tal como especifican los parámetros format, formatProvider y styles.

Excepciones

ArgumentException

El desplazamiento es mayor que 14 horas o menor que -14 horas. -o bien- El styles parámetro incluye un valor no admitido. -o bien- El styles parámetro contiene DateTimeStyles valores que no se pueden usar juntos.

FormatException

input es un intervalo de caracteres vacío. input no contiene una representación de cadena válida de una fecha y una hora. format es un intervalo de caracteres vacío. -o bien- El componente de hora y el designador am/PM en input no están de acuerdo.

Comentarios

Este método analiza un intervalo de caracteres que representa una fecha, que debe estar en el formato definido por el format parámetro . También requiere que los <Date>elementos , <Time>y <Offset> de la representación de cadena de una fecha y hora aparezcan en el orden especificado por format. Si input no coincide con el format patrón, el método produce una FormatExceptionexcepción . En cambio, el DateTimeOffset.Parse(ReadOnlySpan<Char>, IFormatProvider, DateTimeStyles) método analiza la representación de cadena de una fecha en cualquiera de los formatos reconocidos por el objeto del proveedor de DateTimeFormatInfo formato. Parse también permite que los <Date>elementos , <Time>y <Offset> de la representación de cadena de una fecha y hora aparezcan en cualquier orden.

El format parámetro es un intervalo de caracteres que contiene un especificador de formato estándar de un solo carácter o uno o varios especificadores de formato personalizado que definen el formato necesario del input parámetro. 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 los zespecificadores de formato personalizado , zzo zzz 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, el método produce una FormatExceptionexcepción .

El parámetro define formatProvider los símbolos y cadenas de fecha y hora concretos input en , tal y como es el formato preciso de si format es un especificador de input formato estándar. El formatProvider parámetro puede ser cualquiera de los siguientes:

Objeto CultureInfo que representa la referencia cultural basada en la que input se interpreta. El DateTimeFormatInfo objeto devuelto por su DateTimeFormat propiedad define los símbolos y el formato en input.
Objeto DateTimeFormatInfo que define el formato de los datos de fecha y hora.

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

Se aplica a

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

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

public static DateTimeOffset ParseExact (ReadOnlySpan<char> input, string[] formats, IFormatProvider? formatProvider, System.Globalization.DateTimeStyles styles = System.Globalization.DateTimeStyles.None);

public static DateTimeOffset ParseExact (ReadOnlySpan<char> input, string[] formats, IFormatProvider formatProvider, System.Globalization.DateTimeStyles styles = System.Globalization.DateTimeStyles.None);

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

Public Shared Function ParseExact (input As ReadOnlySpan(Of Char), formats As String(), formatProvider As IFormatProvider, Optional styles As DateTimeStyles = System.Globalization.DateTimeStyles.None) As DateTimeOffset

Parámetros

input: ReadOnlySpan<Char>

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

formats: String[]

Matriz de especificadores de formato que definen los formatos esperados de input.

formatProvider: IFormatProvider

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

styles: DateTimeStyles

Combinación bit a bit de valores de enumeración que indica el formato permitido de input.

Devoluciones

DateTimeOffset

Objeto equivalente a la fecha y hora contenidas en el parámetro input, tal como especifican los parámetros formats, formatProvider y styles.

Excepciones

ArgumentException

El desplazamiento es mayor que 14 horas o menor que -14 horas. styles incluye un valor no admitido. -o bien- El styles parámetro contiene DateTimeStyles valores que no se pueden usar juntos.

FormatException

input es un intervalo de caracteres vacío. input no contiene una representación de cadena válida de una fecha y una hora. -o bien- Ningún elemento de formats contiene un especificador de formato válido. -o bien- El componente de hora y el designador am/PM en input no están de acuerdo.

Comentarios

Este método analiza un intervalo de caracteres que representa una fecha que coincide con cualquiera de los patrones asignados al formats parámetro . Si input no coincide con ninguno de estos patrones con ninguna de las variaciones definidas por el styles parámetro , el método produce una FormatExceptionexcepción . Además de comparar input con varios patrones de formato, esta sobrecarga se comporta de forma idéntica al DateTimeOffset.ParseExact(ReadOnlySpan<Char>, ReadOnlySpan<Char>, IFormatProvider, DateTimeStyles) método .

Importante

Objeto CultureInfo que representa la referencia cultural basada en la que input se interpreta. El DateTimeFormatInfo objeto devuelto por la CultureInfo.DateTimeFormat propiedad define los símbolos y el formato en input.
Objeto DateTimeFormatInfo que define el formato de los datos de fecha y hora.

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

Miembro`DateTimeStyles`	Comportamiento
AdjustToUniversal	Analiza y, si es `input` necesario, lo convierte en UTC. Equivale a analizar una cadena y, a continuación, llamar al DateTimeOffset.ToUniversalTime método del objeto devuelto DateTimeOffset .
AssumeLocal	Si el elemento coincidente de `formats` no requiere que `input` contenga un valor de desplazamiento, el objeto devuelto DateTimeOffset 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 `input` incluir espacios en blanco internos no especificados por `format`. El espacio en blanco adicional puede aparecer entre los componentes de fecha y hora y dentro de componentes individuales (excepto el desplazamiento) y se omite al analizar la cadena.
AllowLeadingWhite	Permite `input` incluir espacios iniciales no especificados por `formats`. Se omiten al analizar la cadena.
AllowTrailingWhite	Permite `input` incluir espacios finales no especificados por `formats`. Se omiten al analizar la cadena.
AllowWhiteSpaces	Permite `input` incluir espacios iniciales, finales y internos no especificados por `formats`. Todos los caracteres de espacio en blanco adicionales que no se especifican en el elemento coincidente en `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 de `formats` para que se produzca una coincidencia. Este es el comportamiento predeterminado.
RoundtripKind	No tiene ningún efecto porque la DateTimeOffset estructura no incluye una `Kind` propiedad .

Se aplica a

DateTimeOffset.ParseExact Método

Definición

Sobrecargas

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

Parámetros

Devoluciones

Excepciones

Ejemplos

Comentarios

Notas a los autores de las llamadas

Consulte también

Se aplica a

ParseExact(String, String, IFormatProvider, DateTimeStyles)

Parámetros

Devoluciones

Excepciones

Ejemplos

Comentarios

Notas a los autores de las llamadas

Consulte también

Se aplica a

ParseExact(String, String, IFormatProvider)

Parámetros

Devoluciones

Excepciones

Ejemplos

Comentarios

Notas a los autores de las llamadas

Consulte también

Se aplica a

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

Parámetros

Devoluciones

Excepciones

Comentarios

Se aplica a

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

Parámetros

Devoluciones

Excepciones

Comentarios

Se aplica a

Recursos adicionales