DateTimeOffset.ParseExact DateTimeOffset.ParseExact DateTimeOffset.ParseExact DateTimeOffset.ParseExact Method

Definición

Convierte la representación de cadena especificada de una fecha y hora en el objeto DateTimeOffset equivalente.Converts the specified string representation of a date and time to its DateTimeOffset equivalent. El formato de la representación de cadena debe coincidir exactamente con un formato ya especificado.The format of the string representation must match a specified format exactly.

Sobrecargas

ParseExact(String, String[], IFormatProvider, DateTimeStyles) ParseExact(String, String[], IFormatProvider, DateTimeStyles) ParseExact(String, String[], IFormatProvider, DateTimeStyles) 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.Converts the specified string representation of a date and time to its DateTimeOffset equivalent using the specified formats, culture-specific format information, and style. El formato de la representación de cadena debe coincidir exactamente con uno de los formatos especificados.The format of the string representation must match one of the specified formats exactly.

ParseExact(String, String, IFormatProvider, DateTimeStyles) ParseExact(String, String, IFormatProvider, DateTimeStyles) ParseExact(String, String, IFormatProvider, DateTimeStyles) 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.Converts the specified string representation of a date and time to its DateTimeOffset equivalent using the specified format, culture-specific format information, and style. El formato de la representación de cadena debe coincidir exactamente con el formato especificado.The format of the string representation must match the specified format exactly.

ParseExact(ReadOnlySpan<Char>, ReadOnlySpan<Char>, IFormatProvider, DateTimeStyles) ParseExact(ReadOnlySpan<Char>, ReadOnlySpan<Char>, IFormatProvider, DateTimeStyles) 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.Converts a character span that represents a date and time to its DateTimeOffset equivalent using the specified format, culture-specific format information, and style. El formato de la representación de fecha y hora debe coincidir exactamente con el formato especificado.The format of the date and time representation must match the specified format exactly.

ParseExact(String, String, IFormatProvider) ParseExact(String, String, IFormatProvider) ParseExact(String, String, IFormatProvider) 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.Converts the specified string representation of a date and time to its DateTimeOffset equivalent using the specified format and culture-specific format information. El formato de la representación de cadena debe coincidir exactamente con el formato especificado.The format of the string representation must match the specified format exactly.

ParseExact(ReadOnlySpan<Char>, String[], IFormatProvider, DateTimeStyles) ParseExact(ReadOnlySpan<Char>, String[], IFormatProvider, DateTimeStyles) 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.Converts a character span that contains the string representation of a date and time to its DateTimeOffset equivalent using the specified formats, culture-specific format information, and style. El formato de la representación de fecha y hora debe coincidir exactamente con uno de los formatos especificados.The format of the date and time representation must match one of the specified formats exactly.

ParseExact(String, String[], IFormatProvider, DateTimeStyles) ParseExact(String, String[], IFormatProvider, DateTimeStyles) ParseExact(String, String[], IFormatProvider, DateTimeStyles) 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.Converts the specified string representation of a date and time to its DateTimeOffset equivalent using the specified formats, culture-specific format information, and style. El formato de la representación de cadena debe coincidir exactamente con uno de los formatos especificados.The format of the string representation must match one of the specified formats exactly.

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

Cadena que contiene una fecha y hora que se van a convertir.A string that contains a date and time to convert.

formats
String[]

Matriz de especificadores de formato que definen los formatos esperados de input.An array of format specifiers that define the expected formats of input.

formatProvider
IFormatProvider IFormatProvider IFormatProvider IFormatProvider

Objeto que proporciona información de formato específica de la referencia cultural acerca de input.An object that supplies culture-specific formatting information about input.

styles
DateTimeStyles DateTimeStyles DateTimeStyles DateTimeStyles

Combinación bit a bit de valores de enumeración que indica el formato permitido de input.A bitwise combination of enumeration values that indicates the permitted format of input.

Devoluciones

Objeto equivalente a la fecha y hora contenidas en el parámetro input, tal como especifican los parámetros formats, formatProvider y styles.An object that is equivalent to the date and time that is contained in the input parameter, as specified by the formats, formatProvider, and styles parameters.

Excepciones

El desplazamiento es mayor que 14 horas o menor que -14 horas.The offset is greater than 14 hours or less than -14 hours.

-o bien--or- styles incluye un valor no admitido.styles includes an unsupported value.

-o bien--or- El parámetro styles contiene valores DateTimeStyles que no pueden usarse juntos.The styles parameter contains DateTimeStyles values that cannot be used together.

input es una cadena vacía ("").input is an empty string ("").

-o bien--or- input no contiene una representación de cadena válida de una fecha y una hora.input does not contain a valid string representation of a date and time.

-o bien--or- Ningún elemento de formats contiene un especificador de formato válido.No element of formats contains a valid format specifier.

-o bien--or- El componente de hora y el designador AM/PM en input no coinciden.The hour component and the AM/PM designator in input do not agree.

Ejemplos

El siguiente ejemplo define varios formatos de entrada para la representación de cadena de una fecha y la hora y el valor de desplazamiento y, a continuación, pasa la cadena especificada por el usuario para el DateTimeOffset.ParseExact(String, String[], IFormatProvider, DateTimeStyles) método.The following example defines multiple input formats for the string representation of a date and time and offset value, and then passes the string that is entered by the user to the DateTimeOffset.ParseExact(String, String[], IFormatProvider, DateTimeStyles) method.

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 
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 que se asigna a la formats parámetro.The DateTimeOffset.ParseExact(String, String[], IFormatProvider, DateTimeStyles) method parses the string representation of a date that matches any one of the patterns assigned to the formats parameter. Si el input cadena no coincide con cualquiera de estos patrones con cualquiera de las variaciones definidas por el styles parámetro, el método produce una FormatException.If the input string does not match any one of these patterns with any of the variations defined by the styles parameter, the method throws a FormatException. Además de comparar input para varios modelos de formato, esta sobrecarga se comporta igual que el DateTimeOffset.ParseExact(String, String, IFormatProvider, DateTimeStyles) método.Aside from comparing input to multiple formatting patterns, this overload behaves identically to the DateTimeOffset.ParseExact(String, String, IFormatProvider, DateTimeStyles) method.

El formats parámetro es una matriz de cadena cuyos elementos contienen un especificador de formato estándar único o uno o varios especificadores de formato personalizado que definen el modelo posibles de la input parámetro.The formats parameter is a string array whose elements contain either a single standard format specifier or one or more custom format specifiers that define the possible pattern of the input parameter. Cuando se llama al método, input debe coincidir con uno de estos patrones.When the method is called, input must match one of these patterns. Para obtener más información sobre los códigos de formato válidos, vea Standard Date and Time Format Strings y Custom Date and Time Format Strings.For details about valid formatting codes, see Standard Date and Time Format Strings and Custom Date and Time Format Strings. Si el elemento coincidente en formats incluye la z, zz, o zzz especificadores de formato personalizado para indicar que un desplazamiento debe estar presente en input, ese desplazamiento debe incluir un signo negativo o un signo positivo.If the matched element in formats includes the z, zz, or zzz custom format specifiers to indicate that an offset must be present in input, that offset must include either a negative sign or a positive sign. Si falta el signo, el método produce una FormatException.If the sign is missing, the method throws a FormatException.

Importante

Mediante el formats parámetro de esta sobrecarga para especificar varios formatos puede ayudar a reducir la frustración que muchos usuarios experimentan cuando introducen fechas y horas.Using the formats parameter of this overload to specify multiple formats can help reduce the frustration many users experience when they enter dates and times. En concreto, la capacidad de definir varios modelos de entrada permite que una aplicación controlar las representaciones de fecha y hora en que pueden incluir o no los ceros iniciales en meses, días, horas, minutos y segundos.In particular, the ability to define multiple input patterns enables an application to handle date and time representations that can either include or lack leading zeros in months, days, hours, minutes, and seconds. El ejemplo proporciona una ilustración de este.The example provides an illustration of this.

Si el elemento coincidente en formats requiere que input contenga una fecha pero no una hora, resultante DateTimeOffset objeto se asigna a una hora de medianoche (0: 00:00).If the matched element in formats requires that input contain a date but not a time, the resulting DateTimeOffset object is assigned a time of midnight (0:00:00). Si el elemento coincidente en formats requiere que input contenga una hora pero no una fecha, resultante DateTimeOffset objeto se asigna a la fecha actual en el sistema local.If the matched element in formats requires that input contain a time but not a date, the resulting DateTimeOffset object is assigned the current date on the local system. Si el elemento coincidente en formats no requiere que input contienen un desplazamiento, el desplazamiento del resultante DateTimeOffset objeto depende del valor de la styles parámetro.If the matched element in formats does not require that input contain an offset, the offset of the resulting DateTimeOffset object depends on the value of the styles parameter. Si styles incluye AssumeLocal, el desplazamiento de la zona horaria local se asigna a la DateTimeOffset objeto.If styles includes AssumeLocal, the offset of the local time zone is assigned to the DateTimeOffset object. Si styles incluye AssumeUniversal, el desplazamiento de hora Universal coordinada (UTC), o + 00:00, se asigna a la DateTimeOffset objeto.If styles includes AssumeUniversal, the Coordinated Universal Time (UTC) offset, or +00:00, is assigned to the DateTimeOffset object. Si se especifica ninguno de estos valores, se usa el desplazamiento de la zona horaria local.If neither value is specified, the offset of the local time zone is used.

La fecha en particular y símbolos de tiempo y las cadenas usadas en input definidos por el formatProvider parámetro.The particular date and time symbols and strings used in input are defined by the formatProvider parameter. Lo mismo puede decirse con el formato preciso de input, si el elemento correspondiente de formats es una cadena de especificador de formato estándar.The same is true for the precise format of input, if the matching element of formats is a standard format specifier string. El formatProvider parámetro puede ser cualquiera de las siguientes:The formatProvider parameter can be either of the following:

Si formatprovider es null, el CultureInfo se usa el objeto que corresponde a la referencia cultural actual.If formatprovider is null, the CultureInfo object that corresponds to the current culture is used.

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 de UTC como parte de la operación de análisis.The styles parameter defines whether white space is permitted in the input string, indicates how strings without an explicit offset component are parsed, and supports UTC conversion as part of the parsing operation. Todos los miembros de la DateTimeStyles enumeración se admiten, excepto NoCurrentDateDefault.All members of the DateTimeStyles enumeration are supported except NoCurrentDateDefault. La tabla siguiente muestra el efecto de cada miembro compatible.The following table lists the effect of each supported member.

MiembroDateTimeStyles DateTimeStyles member ComportamientoBehavior
AdjustToUniversal Analiza input y, si es necesario, lo convierte a UTC.Parses input and, if necessary, converts it to UTC. Es equivalente a analizar una cadena y, a continuación, llamar a la DateTimeOffset.ToUniversalTime devuelto del método de DateTimeOffset objeto.It is equivalent to parsing a string, and then calling the DateTimeOffset.ToUniversalTime method of the returned DateTimeOffset object.
AssumeLocal Si el elemento coincidente en formats no requiere que input contienen un valor de desplazamiento, el valor devuelto DateTimeOffset objeto se asigna el desplazamiento de la zona horaria local.If the matched element in formats does not require that input contain an offset value, the returned DateTimeOffset object is given the offset of the local time zone. Este es el valor predeterminado.This is the default value.
AssumeUniversal Si el elemento coincidente en formats no requiere que input contienen un valor de desplazamiento, el valor devuelto DateTimeOffset objeto se asigna el desplazamiento de UTC (+ 00:00).If the matched element in formats does not require that input contain an offset value, the returned DateTimeOffset object is given the UTC offset (+00:00).
AllowInnerWhite Permite input para incluir espacio en blanco interno no especificado por format.Allows input to include inner white space not specified by format. Espacio en blanco pueden aparecer entre los componentes de fecha y hora y dentro de los componentes individuales (excepto el desplazamiento) y se omite al analizar la cadena.Extra white space can appear between date and time components and within individual components (except the offset), and is ignored when parsing the string.
AllowLeadingWhite Permite input para incluir los espacios iniciales no especificados por formats.Allows input to include leading spaces not specified by formats. Estas se omiten al analizar la cadena.These are ignored when parsing the string.
AllowTrailingWhite Permite input para incluir espacios finales no especificados por formats.Allows input to include trailing spaces not specified by formats. Estas se omiten al analizar la cadena.These are ignored when parsing the string.
AllowWhiteSpaces Permite input para incluir espacios iniciales, finales e internos no especificados por formats.Allows input to include leading, trailing, and inner spaces not specified by formats. Todos los caracteres de espacio en blanco adicionales no se especifica en el elemento coincidente en formats se omiten al analizar la cadena.All extra white-space characters not specified in the matched element in formats are ignored when parsing the string.
None Indica que ese espacio en blanco adicionales no se permite en input.Indicates that additional white space is not permitted in input. Espacio en blanco debe aparecer exactamente como se especifica en un elemento determinado de formats para que se produzca una coincidencia.White space must appear exactly as specified in a particular element of formats for a match to occur. Éste es el comportamiento predeterminado.This is the default behavior.
RoundtripKind No tiene ningún efecto porque el DateTimeOffset estructura no incluye un Kind propiedad.Has no effect because the DateTimeOffset structure does not include a Kind property.

Notas a los autores de las llamadas

En el .NET Framework 4.NET Framework 4, el ParseExact método produce una FormatException si la cadena que se puede analizar contiene un componente de hora y un designador AM/PM que no están en el contrato.In the .NET Framework 4.NET Framework 4, the ParseExact method throws a FormatException if the string to be parsed contains an hour component and an AM/PM designator that are not in agreement. En el .NET Framework 3,5.NET Framework 3.5 y versiones anteriores, el designador AM/PM se omite.In the .NET Framework 3,5.NET Framework 3.5 and earlier versions, the AM/PM designator is ignored.

Consulte también:

ParseExact(String, String, IFormatProvider, DateTimeStyles) ParseExact(String, String, IFormatProvider, DateTimeStyles) ParseExact(String, String, IFormatProvider, DateTimeStyles) 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.Converts the specified string representation of a date and time to its DateTimeOffset equivalent using the specified format, culture-specific format information, and style. El formato de la representación de cadena debe coincidir exactamente con el formato especificado.The format of the string representation must match the specified format exactly.

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

Cadena que contiene una fecha y hora que se van a convertir.A string that contains a date and time to convert.

format
String String String String

Especificador de formato que define el formato esperado de input.A format specifier that defines the expected format of input.

formatProvider
IFormatProvider IFormatProvider IFormatProvider IFormatProvider

Objeto que proporciona información de formato específica de la referencia cultural acerca de input.An object that supplies culture-specific formatting information about input.

styles
DateTimeStyles DateTimeStyles DateTimeStyles DateTimeStyles

Combinación bit a bit de valores de enumeración que indica el formato permitido de input.A bitwise combination of enumeration values that indicates the permitted format of input.

Devoluciones

Objeto equivalente a la fecha y hora contenidas en el parámetro input, tal como especifican los parámetros format, formatProvider y styles.An object that is equivalent to the date and time that is contained in the input parameter, as specified by the format, formatProvider, and styles parameters.

Excepciones

El desplazamiento es mayor que 14 horas o menor que -14 horas.The offset is greater than 14 hours or less than -14 hours.

-o bien--or- El parámetro styles incluye un valor no admitido.The styles parameter includes an unsupported value.

-o bien--or- El parámetro styles contiene valores DateTimeStyles que no pueden usarse juntos.The styles parameter contains DateTimeStyles values that cannot be used together.

El valor de input es null.input is null.

-o bien--or- El valor de format es null.format is null.

input es una cadena vacía ("").input is an empty string ("").

-o bien--or- input no contiene una representación de cadena válida de una fecha y una hora.input does not contain a valid string representation of a date and time.

-o bien--or- format es una cadena vacía.format is an empty string.

-o bien--or- El componente de hora y el designador AM/PM en input no coinciden.The hour component and the AM/PM designator in input do not agree.

Ejemplos

En el ejemplo siguiente se usa el DateTimeOffset.ParseExact(String, String, IFormatProvider, DateTimeStyles) método con especificadores de formato estándar y personalizadas, la referencia cultural invariable y varios DateTimeStyles valores para analizar varias cadenas de fecha y hora.The following example uses the DateTimeOffset.ParseExact(String, String, IFormatProvider, DateTimeStyles) method with standard and custom format specifiers, the invariant culture, and various DateTimeStyles values to parse several date and time strings.

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.
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 ajustan a ISO 8601.The following example uses a variety of DateTimeStyles values to parse an array of strings that are expected to conform to ISO 8601. Como se muestra el resultado del ejemplo, las cadenas que se encuentran en el formato correcto no se pueden analizar si:As the output from the example shows, strings that are in the proper format fail to parse if:

Las cadenas que no se especifican un desplazamiento de UTC se supone que tiene el desplazamiento de la zona horaria local (en este caso, -07:00) a menos que el DateTimeStyles.AssumeUniversal marca no se proporciona en la llamada al método.Strings that do not specify a UTC offset are assumed to have the offset of the local time zone (in this case, -07:00) unless the DateTimeStyles.AssumeUniversal flag is supplied in the method call. En ese caso, se supone que el horario Universal coordinado.In that case, they are assumed to be Universal Coordinated Time.

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.The DateTimeOffset.ParseExact(String, String, IFormatProvider, DateTimeStyles) method parses the string representation of a date, which must be in the format defined by the format parameter. También requiere que el <fecha >, <tiempo >, y <desplazamiento > elementos de la representación de cadena de una fecha y hora aparecen en el orden especificado por format.It also requires that the <Date>, <Time>, and <Offset> elements of the string representation of a date and time appear in the order specified by format. Si el input cadena no coincide con el patrón de la format parámetro, con las variaciones definido por el styles parámetro, el método produce una FormatException.If the input string does not match the pattern of the format parameter, with any variations defined by the styles parameter, the method throws a 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 proveedor de formato DateTimeFormatInfo objeto.In contrast, the DateTimeOffset.Parse(String, IFormatProvider, DateTimeStyles) method parses the string representation of a date in any one of the formats recognized by the format provider's DateTimeFormatInfo object. Parse También permite la <fecha >, <tiempo >, y <desplazamiento > elementos de la representación de cadena de una fecha y hora en aparecer en cualquier orden.Parse also allows the <Date>, <Time>, and <Offset> elements of the string representation of a date and time to appear in any order.

El format parámetro es una cadena que contiene un especificador de formato estándar único o uno o varios especificadores de formato personalizado que definen el patrón requerido de la input parámetro.The format parameter is a string that contains either a single standard format specifier or one or more custom format specifiers that define the required pattern of the input parameter. Para obtener más información sobre los códigos de formato válidos, vea Standard Date and Time Format Strings y Custom Date and Time Format Strings.For details about valid formatting codes, see Standard Date and Time Format Strings and Custom Date and Time Format Strings. Si format incluye la z, zz, o zzz especificadores de formato personalizado para indicar que un desplazamiento debe estar presente en input, ese desplazamiento debe incluir un signo negativo o un signo positivo.If format includes the z, zz, or zzz custom format specifiers to indicate that an offset must be present in input, that offset must include either a negative sign or a positive sign. Si falta el signo, el método produce una FormatException.If the sign is missing, the method throws a FormatException.

Si format requiere que input contenga una fecha pero no una hora, resultante DateTimeOffset objeto se asigna a una hora de medianoche (0: 00:00).If format requires that input contain a date but not a time, the resulting DateTimeOffset object is assigned a time of midnight (0:00:00). Si format requiere que input contenga una hora pero no una fecha, resultante DateTimeOffset objeto se asigna a la fecha actual en el sistema local.If format requires that input contain a time but not a date, the resulting DateTimeOffset object is assigned the current date on the local system. Si format no requiere que input contienen un desplazamiento, el desplazamiento del resultante DateTimeOffset objeto depende del valor de la styles parámetro.If format does not require that input contain an offset, the offset of the resulting DateTimeOffset object depends on the value of the styles parameter. Si styles incluye AssumeLocal, el desplazamiento de la zona horaria local se asigna a la DateTimeOffset objeto.If styles includes AssumeLocal, the offset of the local time zone is assigned to the DateTimeOffset object. Si styles incluye AssumeUniversal, el desplazamiento de hora Universal coordinada (UTC), o + 00:00, se asigna a la DateTimeOffset objeto.If styles includes AssumeUniversal, the Coordinated Universal Time (UTC) offset, or +00:00, is assigned to the DateTimeOffset object. Si se especifica ninguno de estos valores, se usa el desplazamiento de la zona horaria local.If neither value is specified, the offset of the local time zone is used.

La fecha en particular y símbolos de tiempo y las cadenas usadas en input definidos por el formatProvider parámetro.The particular date and time symbols and strings used in input are defined by the formatProvider parameter. Lo mismo puede decirse con el formato preciso de inputsi format es una cadena de especificador de formato estándar.The same is true for the precise format of input, if format is a standard format specifier string. El formatProvider parámetro puede ser cualquiera de las siguientes:The formatProvider parameter can be either of the following:

Si formatprovider es null, el CultureInfo se usa el objeto que corresponde a la referencia cultural actual.If formatprovider is null, the CultureInfo object that corresponds to the current culture is used.

El styles parámetro define si se permiten espacios 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 de UTC como parte de la operación de análisis.The styles parameter defines whether white space is allowed in the input string, indicates how strings without an explicit offset component are parsed, and supports UTC conversion as part of the parsing operation. Todos los miembros de la DateTimeStyles enumeración se admiten, excepto NoCurrentDateDefault.All members of the DateTimeStyles enumeration are supported except NoCurrentDateDefault. La tabla siguiente muestra el efecto de cada miembro compatible.The following table lists the effect of each supported member.

MiembroDateTimeStyles DateTimeStyles member ComportamientoBehavior
AdjustToUniversal Analiza input y, si es necesario, lo convierte a UTC.Parses input and, if necessary, converts it to UTC. Es equivalente a analizar una cadena y, a continuación, llamar a la DateTimeOffset.ToUniversalTime devuelto del método de DateTimeOffset objeto.It is equivalent to parsing a string, and then calling the DateTimeOffset.ToUniversalTime method of the returned DateTimeOffset object.
AssumeLocal Si format no requiere que input contienen un valor de desplazamiento, el valor devuelto DateTimeOffset objeto se asigna el desplazamiento de la zona horaria local.If format does not require that input contain an offset value, the returned DateTimeOffset object is given the offset of the local time zone. Este es el valor predeterminado.This is the default value.
AssumeUniversal Si format no requiere que input contienen un valor de desplazamiento, el valor devuelto DateTimeOffset objeto se asigna el desplazamiento de UTC (+ 00:00).If format does not require that input contain an offset value, the returned DateTimeOffset object is given the UTC offset (+00:00).
AllowInnerWhite Permite input para incluir espacio en blanco interno no especificado por format.Allows input to include inner white space not specified by format. Espacio en blanco pueden aparecer entre los componentes de fecha y hora y dentro de los componentes individuales y se omite al analizar la cadena.Extra white space can appear between date and time components and within individual components, and is ignored when parsing the string.
AllowLeadingWhite Permite input para incluir los espacios iniciales no especificados por format.Allows input to include leading spaces not specified by format. Estas se omiten al analizar la cadena.These are ignored when parsing the string.
AllowTrailingWhite Permite input para incluir espacios finales no especificados por format.Allows input to include trailing spaces not specified by format. Estas se omiten al analizar la cadena.These are ignored when parsing the string.
AllowWhiteSpaces Permite input para incluir espacios iniciales, finales e internos no especificados por format.Allows input to include leading, trailing, and inner spaces not specified by format. Todos los caracteres de espacio en blanco adicionales no se especifica en format se omiten al analizar la cadena.All extra white-space characters not specified in format are ignored when parsing the string.
None Indica que ese espacio en blanco adicionales no se permite en input.Indicates that additional white space is not permitted in input. Espacio en blanco debe aparecer exactamente como se especifica en format.White space must appear exactly as specified in format. Éste es el comportamiento predeterminado.This is the default behavior.
RoundtripKind No tiene ningún efecto porque el DateTimeOffset estructura no incluye un Kind propiedad.Has no effect because the DateTimeOffset structure does not include a Kind property.

Notas a los autores de las llamadas

En el .NET Framework 4.NET Framework 4, el ParseExact método produce una FormatException si la cadena que se puede analizar contiene un componente de hora y un designador AM/PM que no están en el contrato.In the .NET Framework 4.NET Framework 4, the ParseExact method throws a FormatException if the string to be parsed contains an hour component and an AM/PM designator that are not in agreement. En el .NET Framework 3,5.NET Framework 3.5 y versiones anteriores, el designador AM/PM se omite.In the .NET Framework 3,5.NET Framework 3.5 and earlier versions, the AM/PM designator is ignored.

Consulte también:

ParseExact(ReadOnlySpan<Char>, ReadOnlySpan<Char>, IFormatProvider, DateTimeStyles) ParseExact(ReadOnlySpan<Char>, ReadOnlySpan<Char>, IFormatProvider, DateTimeStyles) 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.Converts a character span that represents a date and time to its DateTimeOffset equivalent using the specified format, culture-specific format information, and style. El formato de la representación de fecha y hora debe coincidir exactamente con el formato especificado.The format of the date and time representation must match the specified format exactly.

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.A character span that represents a date and time.

format
ReadOnlySpan<Char>

Un intervalo de caracteres que contiene un especificador de formato que define el formato esperado de input.A character span that contains a format specifier that defines the expected format of input.

formatProvider
IFormatProvider IFormatProvider IFormatProvider IFormatProvider

Un objeto que proporciona información de formato específica de la referencia cultural sobre input.An object that provides culture-specific formatting information about input.

styles
DateTimeStyles DateTimeStyles DateTimeStyles DateTimeStyles

Combinación bit a bit de valores de enumeración que indica el formato permitido de input.A bitwise combination of enumeration values that indicates the permitted format of input.

Devoluciones

Objeto equivalente a la fecha y hora contenidas en el parámetro input, tal como especifican los parámetros format, formatProvider y styles.An object that is equivalent to the date and time that is contained in the input parameter, as specified by the format, formatProvider, and styles parameters.

Excepciones

El desplazamiento es mayor que 14 horas o menor que -14 horas.The offset is greater than 14 hours or less than -14 hours.
-o bien--or-
El parámetro styles incluye un valor no admitido.The styles parameter includes an unsupported value.
-o bien--or-
El parámetro styles contiene valores DateTimeStyles que no pueden usarse juntos.The styles parameter contains DateTimeStyles values that cannot be used together.

input es un intervalo de caracteres vacío.input is an empty character span.
input no contiene una representación de cadena válida de una fecha y una hora.-or- input does not contain a valid string representation of a date and time.
format es un intervalo de caracteres vacío.-or- format is an empty character span.
-o bien--or-
El componente de hora y el designador AM/PM en input no coinciden.The hour component and the AM/PM designator in input do not agree.

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.This method parses a character span that represents a date, which must be in the format defined by the format parameter. También requiere que el <fecha >, <tiempo >, y <desplazamiento > elementos de la representación de cadena de una fecha y hora aparecen en el orden especificado por format.It also requires that the <Date>, <Time>, and <Offset> elements of the string representation of a date and time appear in the order specified by format. Si input no coincide con el format patrón, el método produce una FormatException.If input does not match the format pattern, the method throws a FormatException. 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 proveedor de formato DateTimeFormatInfo objeto.In contrast, the DateTimeOffset.Parse(ReadOnlySpan<Char>, IFormatProvider, DateTimeStyles) method parses the string representation of a date in any one of the formats recognized by the format provider's DateTimeFormatInfo object. Parse También permite la <fecha >, <tiempo >, y <desplazamiento > elementos de la representación de cadena de una fecha y hora en aparecer en cualquier orden.Parse also allows the <Date>, <Time>, and <Offset> elements of the string representation of a date and time to appear in any order.

El format parámetro es un intervalo de caracteres que contiene un especificador de formato estándar de carácter único o uno o varios especificadores de formato personalizado que definen el formato requerido de la input parámetro.The format parameter is a character span that contains either a single-character standard format specifier or one or more custom format specifiers that define the required format of the input parameter. Para obtener más información sobre los códigos de formato válidos, vea Standard Date and Time Format Strings y Custom Date and Time Format Strings.For details about valid formatting codes, see Standard Date and Time Format Strings and Custom Date and Time Format Strings. Si format incluye la z, zz, o zzz especificadores de formato personalizado para indicar que un desplazamiento debe estar presente en input, ese desplazamiento debe incluir un signo negativo o un signo positivo.If format includes the z, zz, or zzz custom format specifiers to indicate that an offset must be present in input, that offset must include either a negative sign or a positive sign. Si falta el signo, el método produce una FormatException.If the sign is missing, the method throws a FormatException.

Si format requiere que input contenga una fecha pero no una hora, resultante DateTimeOffset objeto se asigna a una hora de medianoche (0: 00:00).If format requires that input contain a date but not a time, the resulting DateTimeOffset object is assigned a time of midnight (0:00:00). Si format requiere que input contenga una hora pero no una fecha, resultante DateTimeOffset objeto se asigna a la fecha actual en el sistema local.If format requires that input contain a time but not a date, the resulting DateTimeOffset object is assigned the current date on the local system. Si format no requiere que input contienen un desplazamiento, resultante DateTimeOffset objeto se asigna el desplazamiento de zona horaria del sistema local.If format does not require that input contain an offset, the resulting DateTimeOffset object is assigned the time zone offset of the local system.

La fecha en particular y símbolos de tiempo y las cadenas usadas en input definidos por el formatProvider parámetro, como el formato preciso de input si format es un especificador de formato estándar.The particular date and time symbols and strings used in input are defined by the formatProvider parameter, as is the precise format of input if format is a standard format specifier. El formatProvider parámetro puede ser cualquiera de las siguientes:The formatProvider parameter can be either of the following:

Si formatprovider es null, el CultureInfo se usa el objeto que corresponde a la referencia cultural actual.If formatprovider is null, the CultureInfo object that corresponds to the current culture is used.

ParseExact(String, String, IFormatProvider) ParseExact(String, String, IFormatProvider) ParseExact(String, String, IFormatProvider) 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.Converts the specified string representation of a date and time to its DateTimeOffset equivalent using the specified format and culture-specific format information. El formato de la representación de cadena debe coincidir exactamente con el formato especificado.The format of the string representation must match the specified format exactly.

public:
 static DateTimeOffset ParseExact(System::String ^ input, System::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 String String String

Cadena que contiene una fecha y hora que se van a convertir.A string that contains a date and time to convert.

format
String String String String

Especificador de formato que define el formato esperado de input.A format specifier that defines the expected format of input.

formatProvider
IFormatProvider IFormatProvider IFormatProvider IFormatProvider

Objeto que proporciona información de formato específica de la referencia cultural acerca de input.An object that supplies culture-specific formatting information about input.

Devoluciones

Objeto equivalente a la fecha y hora que se indican en input, tal como especifican format y formatProvider.An object that is equivalent to the date and time that is contained in input as specified by format and formatProvider.

Excepciones

El desplazamiento es mayor que 14 horas o menor que -14 horas.The offset is greater than 14 hours or less than -14 hours.

El valor de input es null.input is null.

-o bien--or- El valor de format es null.format is null.

input es una cadena vacía ("").input is an empty string ("").

-o bien--or- input no contiene una representación de cadena válida de una fecha y una hora.input does not contain a valid string representation of a date and time.

-o bien--or- format es una cadena vacía.format is an empty string.

-o bien--or- El componente de hora y el designador AM/PM en input no coinciden.The hour component and the AM/PM designator in input do not agree.

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.The following example uses the DateTimeOffset.ParseExact(String, String, IFormatProvider) method with standard and custom format specifiers and the invariant culture to parse several date and time strings.

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.                     
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 ajustan a ISO 8601.The following example parses an array of strings that are expected to conform to ISO 8601. Como la salida se muestra en el ejemplo, las cadenas con espacios iniciales o finales no se pudo analizar correctamente, igual que las cadenas de fecha y hora de los elementos que están fuera del intervalo.As the output from the example shows, strings with leading or trailing spaces fail to parse successfully, as do strings with date and time elements that are out of range.

using System;

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.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.The ParseExact(String, String, IFormatProvider) method parses the string representation of a date, which must be in the format defined by the format parameter. También requiere que el <fecha >, <tiempo >, y <desplazamiento > elementos de la representación de cadena de una fecha y hora aparecen en el orden especificado por format.It also requires that the <Date>, <Time>, and <Offset> elements of the string representation of a date and time appear in the order specified by format. Si el input cadena no coincide con esto format parámetro, el método produce una FormatException.If the input string does not match this format parameter, the method throws a FormatException. 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 proveedor de formato DateTimeFormatInfo objeto.In contrast, the DateTimeOffset.Parse(String, IFormatProvider) method parses the string representation of a date in any one of the formats recognized by the format provider's DateTimeFormatInfo object. Parse También permite la <fecha >, <tiempo >, y <desplazamiento > elementos de la representación de cadena de una fecha y hora en aparecer en cualquier orden.Parse also allows the <Date>, <Time>, and <Offset> elements of the string representation of a date and time to appear in any order.

El format parámetro es una cadena que contiene un especificador de formato estándar único o uno o varios especificadores de formato personalizado que definen el formato requerido de la input parámetro.The format parameter is a string that contains either a single standard format specifier or one or more custom format specifiers that define the required format of the input parameter. Para obtener más información sobre los códigos de formato válidos, vea Standard Date and Time Format Strings y Custom Date and Time Format Strings.For details about valid formatting codes, see Standard Date and Time Format Strings and Custom Date and Time Format Strings. Si format incluye la z, zz, o zzz especificadores de formato personalizado para indicar que un desplazamiento debe estar presente en input, ese desplazamiento debe incluir un signo negativo o un signo positivo.If format includes the z, zz, or zzz custom format specifiers to indicate that an offset must be present in input, that offset must include either a negative sign or a positive sign. Si falta el signo, el método produce una FormatException.If the sign is missing, the method throws a FormatException.

Si format requiere que input contenga una fecha pero no una hora, resultante DateTimeOffset objeto se asigna a una hora de medianoche (0: 00:00).If format requires that input contain a date but not a time, the resulting DateTimeOffset object is assigned a time of midnight (0:00:00). Si format requiere que input contenga una hora pero no una fecha, resultante DateTimeOffset objeto se asigna a la fecha actual en el sistema local.If format requires that input contain a time but not a date, the resulting DateTimeOffset object is assigned the current date on the local system. Si format no requiere que input contienen un desplazamiento, resultante DateTimeOffset objeto se asigna el desplazamiento de zona horaria del sistema local.If format does not require that input contain an offset, the resulting DateTimeOffset object is assigned the time zone offset of the local system.

La fecha en particular y símbolos de tiempo y las cadenas usadas en input definidos por el formatProvider parámetro, como el formato preciso de input si format es una cadena de especificador de formato estándar.The particular date and time symbols and strings used in input are defined by the formatProvider parameter, as is the precise format of input if format is a standard format specifier string. El formatProvider parámetro puede ser cualquiera de las siguientes:The formatProvider parameter can be either of the following:

Si formatprovider es null, el CultureInfo se usa el objeto que corresponde a la referencia cultural actual.If formatprovider is null, the CultureInfo object that corresponds to the current culture is used.

Notas a los autores de las llamadas

En el .NET Framework 4.NET Framework 4, el ParseExact método produce una FormatException si la cadena que se puede analizar contiene un componente de hora y un designador AM/PM que no están en el contrato.In the .NET Framework 4.NET Framework 4, the ParseExact method throws a FormatException if the string to be parsed contains an hour component and an AM/PM designator that are not in agreement. En el .NET Framework 3,5.NET Framework 3.5 y versiones anteriores, el designador AM/PM se omite.In the .NET Framework 3,5.NET Framework 3.5 and earlier versions, the AM/PM designator is ignored.

Consulte también:

ParseExact(ReadOnlySpan<Char>, String[], IFormatProvider, DateTimeStyles) ParseExact(ReadOnlySpan<Char>, String[], IFormatProvider, DateTimeStyles) 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.Converts a character span that contains the string representation of a date and time to its DateTimeOffset equivalent using the specified formats, culture-specific format information, and style. El formato de la representación de fecha y hora debe coincidir exactamente con uno de los formatos especificados.The format of the date and time representation must match one of the specified formats exactly.

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.A character span that contains a date and time to convert.

formats
String[]

Matriz de especificadores de formato que definen los formatos esperados de input.An array of format specifiers that define the expected formats of input.

formatProvider
IFormatProvider IFormatProvider IFormatProvider IFormatProvider

Objeto que proporciona información de formato específica de la referencia cultural acerca de input.An object that supplies culture-specific formatting information about input.

styles
DateTimeStyles DateTimeStyles DateTimeStyles DateTimeStyles

Combinación bit a bit de valores de enumeración que indica el formato permitido de input.A bitwise combination of enumeration values that indicates the permitted format of input.

Devoluciones

Objeto equivalente a la fecha y hora contenidas en el parámetro input, tal como especifican los parámetros formats, formatProvider y styles.An object that is equivalent to the date and time that is contained in the input parameter, as specified by the formats, formatProvider, and styles parameters.

Excepciones

El desplazamiento es mayor que 14 horas o menor que -14 horas.The offset is greater than 14 hours or less than -14 hours.
styles incluye un valor no admitido.-or- styles includes an unsupported value.
-o bien--or-
El parámetro styles contiene valores DateTimeStyles que no pueden usarse juntos.The styles parameter contains DateTimeStyles values that cannot be used together.

input es un intervalo de caracteres vacío.input is an empty character span.
input no contiene una representación de cadena válida de una fecha y una hora.-or- input does not contain a valid string representation of a date and time.
-o bien--or-
Ningún elemento de formats contiene un especificador de formato válido.No element of formats contains a valid format specifier.
-o bien--or-
El componente de hora y el designador AM/PM en input no coinciden.The hour component and the AM/PM designator in input do not agree.

Comentarios

Este método analiza un intervalo de caracteres que representa una fecha que coincide con cualquiera de los patrones que se asigna a la formats parámetro.This method parses a character span representing a date that matches any one of the patterns assigned to the formats parameter. Si input no coincide con cualquiera de estos patrones con cualquiera de las variaciones definidas por el styles parámetro, el método produce una FormatException.If input does not match any one of these patterns with any of the variations defined by the styles parameter, the method throws a FormatException. Además de comparar input para varios modelos de formato, esta sobrecarga se comporta igual que el DateTimeOffset.ParseExact(ReadOnlySpan<Char>, ReadOnlySpan<Char>, IFormatProvider, DateTimeStyles) método.Aside from comparing input to multiple formatting patterns, this overload behaves identically to the DateTimeOffset.ParseExact(ReadOnlySpan<Char>, ReadOnlySpan<Char>, IFormatProvider, DateTimeStyles) method.

El formats parámetro es una matriz de cadena cuyos elementos contienen un especificador de formato estándar único o uno o varios especificadores de formato personalizado que definen el modelo posibles de la input parámetro.The formats parameter is a string array whose elements contain either a single standard format specifier or one or more custom format specifiers that define the possible pattern of the input parameter. Cuando se llama al método, input debe coincidir con uno de estos patrones.When the method is called, input must match one of these patterns. Para obtener más información sobre los códigos de formato válidos, vea Standard Date and Time Format Strings y Custom Date and Time Format Strings.For details about valid formatting codes, see Standard Date and Time Format Strings and Custom Date and Time Format Strings. Si el elemento coincidente en formats incluye la z, zz, o zzz especificadores de formato personalizado para indicar que un desplazamiento debe estar presente en input, ese desplazamiento debe incluir un signo negativo o un signo positivo.If the matched element in formats includes the z, zz, or zzz custom format specifiers to indicate that an offset must be present in input, that offset must include either a negative sign or a positive sign. Si falta el signo, el método produce una FormatException.If the sign is missing, the method throws a FormatException.

Importante

Mediante el formats parámetro de esta sobrecarga para especificar varios formatos puede ayudar a reducir la frustración que muchos usuarios experimentan cuando introducen fechas y horas.Using the formats parameter of this overload to specify multiple formats can help reduce the frustration many users experience when they enter dates and times. En concreto, la capacidad de definir varios modelos de entrada permite que una aplicación controlar las representaciones de fecha y hora en que pueden incluir o no los ceros iniciales en meses, días, horas, minutos y segundos.In particular, the ability to define multiple input patterns enables an application to handle date and time representations that can either include or lack leading zeros in months, days, hours, minutes, and seconds.

Si el elemento coincidente en formats requiere que input contenga una fecha pero no una hora, resultante DateTimeOffset objeto se asigna a una hora de medianoche (0: 00:00).If the matched element in formats requires that input contain a date but not a time, the resulting DateTimeOffset object is assigned a time of midnight (0:00:00). Si el elemento coincidente en formats requiere que input contenga una hora pero no una fecha, resultante DateTimeOffset objeto se asigna a la fecha actual en el sistema local.If the matched element in formats requires that input contain a time but not a date, the resulting DateTimeOffset object is assigned the current date on the local system. Si el elemento coincidente en formats no requiere que input contienen un desplazamiento, el desplazamiento del resultante DateTimeOffset objeto depende del valor de la styles parámetro.If the matched element in formats does not require that input contain an offset, the offset of the resulting DateTimeOffset object depends on the value of the styles parameter. Si styles incluye AssumeLocal, el desplazamiento de la zona horaria local se asigna a la DateTimeOffset objeto.If styles includes AssumeLocal, the offset of the local time zone is assigned to the DateTimeOffset object. Si styles incluye AssumeUniversal, el desplazamiento de hora Universal coordinada (UTC), o + 00:00, se asigna a la DateTimeOffset objeto.If styles includes AssumeUniversal, the Coordinated Universal Time (UTC) offset, or +00:00, is assigned to the DateTimeOffset object. Si se especifica ninguno de estos valores, se usa el desplazamiento de la zona horaria local.If neither value is specified, the offset of the local time zone is used.

La fecha en particular y símbolos de tiempo y las cadenas usadas en input definidos por el formatProvider parámetro.The particular date and time symbols and strings used in input are defined by the formatProvider parameter. Lo mismo puede decirse con el formato preciso de input, si el elemento correspondiente de formats es una cadena de especificador de formato estándar.The same is true for the precise format of input, if the matching element of formats is a standard format specifier string. El formatProvider parámetro puede ser cualquiera de las siguientes:The formatProvider parameter can be either of the following:

Si formatprovider es null, el CultureInfo se usa el objeto que corresponde a la referencia cultural actual.If formatprovider is null, the CultureInfo object that corresponds to the current culture is used.

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 de UTC como parte de la operación de análisis.The styles parameter defines whether white space is permitted in the input string, indicates how strings without an explicit offset component are parsed, and supports UTC conversion as part of the parsing operation. Todos los miembros de la DateTimeStyles enumeración se admiten, excepto NoCurrentDateDefault.All members of the DateTimeStyles enumeration are supported except NoCurrentDateDefault. La tabla siguiente muestra el efecto de cada miembro compatible.The following table lists the effect of each supported member.

MiembroDateTimeStyles DateTimeStyles member ComportamientoBehavior
AdjustToUniversal Analiza input y, si es necesario, lo convierte a UTC.Parses input and, if necessary, converts it to UTC. Es equivalente a analizar una cadena y, a continuación, llamar a la DateTimeOffset.ToUniversalTime devuelto del método de DateTimeOffset objeto.It is equivalent to parsing a string, and then calling the DateTimeOffset.ToUniversalTime method of the returned DateTimeOffset object.
AssumeLocal Si el elemento coincidente en formats no requiere que input contienen un valor de desplazamiento, el valor devuelto DateTimeOffset objeto se asigna el desplazamiento de la zona horaria local.If the matched element in formats does not require that input contain an offset value, the returned DateTimeOffset object is given the offset of the local time zone. Este es el valor predeterminado.This is the default value.
AssumeUniversal Si el elemento coincidente en formats no requiere que input contienen un valor de desplazamiento, el valor devuelto DateTimeOffset objeto se asigna el desplazamiento de UTC (+ 00:00).If the matched element in formats does not require that input contain an offset value, the returned DateTimeOffset object is given the UTC offset (+00:00).
AllowInnerWhite Permite input para incluir espacio en blanco interno no especificado por format.Allows input to include inner white space not specified by format. Espacio en blanco pueden aparecer entre los componentes de fecha y hora y dentro de los componentes individuales (excepto el desplazamiento) y se omite al analizar la cadena.Extra white space can appear between date and time components and within individual components (except the offset), and is ignored when parsing the string.
AllowLeadingWhite Permite input para incluir los espacios iniciales no especificados por formats.Allows input to include leading spaces not specified by formats. Estas se omiten al analizar la cadena.These are ignored when parsing the string.
AllowTrailingWhite Permite input para incluir espacios finales no especificados por formats.Allows input to include trailing spaces not specified by formats. Estas se omiten al analizar la cadena.These are ignored when parsing the string.
AllowWhiteSpaces Permite input para incluir espacios iniciales, finales e internos no especificados por formats.Allows input to include leading, trailing, and inner spaces not specified by formats. Todos los caracteres de espacio en blanco adicionales no se especifica en el elemento coincidente en formats se omiten al analizar la cadena.All extra white-space characters not specified in the matched element in formats are ignored when parsing the string.
None Indica que ese espacio en blanco adicionales no se permite en input.Indicates that additional white space is not permitted in input. Espacio en blanco debe aparecer exactamente como se especifica en un elemento determinado de formats para que se produzca una coincidencia.White space must appear exactly as specified in a particular element of formats for a match to occur. Éste es el comportamiento predeterminado.This is the default behavior.
RoundtripKind No tiene ningún efecto porque el DateTimeOffset estructura no incluye un Kind propiedad.Has no effect because the DateTimeOffset structure does not include a Kind property.

Se aplica a