Compartir a través de

DateTimeOffset.ParseExact 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 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:

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.

MiembroDateTimeStyles 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:

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.

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

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, al objeto resultante DateTimeOffset se le asigna el desplazamiento de zona horaria del sistema local.

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:

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

Notas a los autores de las llamadas

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

Consulte también

Se aplica a

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 .

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, al objeto resultante DateTimeOffset se le asigna el desplazamiento de zona horaria del sistema local.

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:

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 .

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.

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:

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.

MiembroDateTimeStyles 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