Compartir vía

DateTime.Parse 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 de una fecha y hora en su DateTime equivalente.

Sobrecargas

Parse(String)

Convierte la representación de cadena de una fecha y hora en su DateTime equivalente mediante las convenciones de la referencia cultural actual.
Parse(ReadOnlySpan<Char>, IFormatProvider)

Analiza un intervalo de caracteres en un valor.
Parse(String, IFormatProvider)

Convierte la representación de cadena de una fecha y hora en su DateTime equivalente mediante la información de formato específica de la referencia cultural.
Parse(ReadOnlySpan<Char>, IFormatProvider, DateTimeStyles)

Convierte un intervalo de memoria que contiene una representación de cadena de una fecha y hora en su DateTime equivalente mediante información de formato específica de la referencia cultural y un estilo de formato.
Parse(String, IFormatProvider, DateTimeStyles)

Convierte la representación de cadena de una fecha y hora en su DateTime equivalente mediante información de formato específica de la referencia cultural y un estilo de formato.

Ejemplos

Se intercalan numerosos ejemplos que llaman al método DateTime.Parse a lo largo de la sección Comentarios de este artículo y en la documentación de las sobrecargas de DateTime.Parse individuales.

Nota

Algunos ejemplos de C# de este artículo se ejecutan en Try.NET ejecutor de código insertado y parque infantil. Seleccione Ejecutar para ejecutar un ejemplo en una ventana interactiva. Una vez ejecutado el código, puede modificarlo y ejecutar el código modificado seleccionando Ejecutar de nuevo. El código modificado se ejecuta en la ventana interactiva o, si se produce un error en la compilación, la ventana interactiva muestra todos los mensajes de error del compilador de C#.

La zona horaria local del ejecutor de código insertado Try.NET y el área de juegos es hora universal coordinada o UTC. Esto puede afectar al comportamiento y a la salida de ejemplos que ilustran los tipos de DateTime, DateTimeOffsety TimeZoneInfo y sus miembros.

También puede descargar un conjunto completo de ejemplos de DateTime.Parse, que se incluyen en un proyecto de .NET Core de para C#.

Comentarios

En esta sección:

¿A qué método se llama?

Para Llamar
Analice una cadena de fecha y hora mediante las convenciones de la referencia cultural actual. sobrecarga de Parse(String)
Analice una cadena de fecha y hora mediante las convenciones de una referencia cultural específica. sobrecarga de Parse(String, IFormatProvider) (consulte análisis y convenciones culturales)
Analice una cadena de fecha y hora con elementos de estilo especiales (como espacios en blanco o sin espacios en blanco). sobrecarga de Parse(String, IFormatProvider, DateTimeStyles)
Analice una cadena de fecha y hora que debe estar en un formato determinado. DateTime.ParseExact o DateTime.TryParseExact
Analice una cadena de fecha y hora y realice una conversión a hora UTC o local. sobrecarga de Parse(String, IFormatProvider, DateTimeStyles)
Analice una cadena de fecha y hora sin controlar excepciones. método DateTime.TryParse
Restaure (ida y vuelta) un valor de fecha y hora creado por una operación de formato. Pase la cadena de formato estándar "o" o "r" al método ToString(String) y llame a la sobrecarga de Parse(String, IFormatProvider, DateTimeStyles) con DateTimeStyles.RoundtripKind
Analice una cadena de fecha y hora en un formato fijo entre los límites de la máquina (y posiblemente culturales). método DateTime.ParseExact o DateTime.TryParseExact

Cadena que se va a analizar

El método Parse intenta convertir la representación de cadena de un valor de fecha y hora en su DateTime equivalente. Intenta analizar completamente la cadena de entrada sin iniciar una excepción de FormatException.

Importante

Si se produce un error en la operación de análisis debido a un formato de cadena no reconocido, el método Parse produce un FormatException, mientras que el método TryParse devuelve false. Dado que el control de excepciones puede ser costoso, debe usar Parse cuando se espera que la operación de análisis se realice correctamente porque el origen de entrada es de confianza. TryParse es preferible cuando es probable que se analicen errores, especialmente porque un origen de entrada no es de confianza, o si tiene valores predeterminados razonables para sustituir las cadenas que no se analizan correctamente.

La cadena que se va a analizar puede adoptar cualquiera de las formas siguientes:

  • Cadena con un componente de fecha y hora.

  • Cadena con un componente de fecha pero sin hora. Si el componente de hora no está presente, el método asume la medianoche de 12:00. Si el componente de fecha tiene un año de dos dígitos, se convierte en un año basado en la Calendar.TwoDigitYearMax del calendario actual de la referencia cultural actual o en el calendario actual de la referencia cultural especificada (si usa una sobrecarga con un argumento de provider no NULL).

  • Cadena con un componente de fecha que incluye solo el mes y el año, pero ningún componente de día. El método asume el primer día del mes.

  • Cadena con un componente de fecha que incluye solo el mes y el día, pero ningún componente de año. El método asume el año actual.

  • Cadena con una hora pero sin componente de fecha. El método asume la fecha actual a menos que llame a la sobrecarga de Parse(String, IFormatProvider, DateTimeStyles) e incluya DateTimeStyles.NoCurrentDateDefault en el argumento styles, en cuyo caso el método asume una fecha del 1 de enero de 0001.

  • Cadena con un componente de hora que incluye solo la hora y un designador am/PM, sin ningún componente de fecha. El método supone la fecha actual y una hora sin minutos ni segundos. Puede cambiar este comportamiento llamando a la sobrecarga Parse(String, IFormatProvider, DateTimeStyles) e incluir DateTimeStyles.NoCurrentDateDefault en el argumento styles, en cuyo caso el método supone una fecha del 1 de enero de 0001.

  • Cadena que incluye información de zona horaria y se ajusta a ISO 8601. En los ejemplos siguientes, la primera cadena designa la hora universal coordinada (UTC) y la segunda designa la hora en una zona horaria que es siete horas antes de utc:

    "2008-11-01T19:35:00.0000000Z" "2008-11-01T19:35:00.0000000-07:00"

  • Cadena que incluye el designador GMT y se ajusta al formato de hora RFC 1123; por ejemplo:

    "Sat, 01 nov 2008 19:35:00 GMT"

  • Cadena que incluye la fecha y hora junto con la información de desplazamiento de zona horaria; por ejemplo:

    "03/01/2009 05:42:00 -5:00"

En el ejemplo siguiente se analizan las cadenas en cada uno de estos formatos mediante las convenciones de formato de la referencia cultural actual, que en este caso es la referencia cultural en-US:

using System;

public class Example
{
   public static void Main()
   {
      (string dateAsString, string description)[]  dateInfo = { ("08/18/2018 07:22:16", "String with a date and time component"),
                                                                ("08/18/2018", "String with a date component only"),
                                                                ("8/2018", "String with a month and year component only"),
                                                                ("8/18", "String with a month and day component only"),
                                                                ("07:22:16", "String with a time component only"),
                                                                ("7 PM", "String with an hour and AM/PM designator only"),
                                                                ("2018-08-18T07:22:16.0000000Z", "UTC string that conforms to ISO 8601"),
                                                                ("2018-08-18T07:22:16.0000000-07:00", "Non-UTC string that conforms to ISO 8601"),
                                                                ("Sat, 18 Aug 2018 07:22:16 GMT", "String that conforms to RFC 1123"),
                                                                ("08/18/2018 07:22:16 -5:00", "String with date, time, and time zone information" ) };

      Console.WriteLine($"Today is {DateTime.Now:d}\n");

      foreach (var item in dateInfo) {
         Console.WriteLine($"{item.description + ":",-52} '{item.dateAsString}' --> {DateTime.Parse(item.dateAsString)}");
      }
   }
}
// The example displays output like the following:
//   Today is 2/22/2018
//
//   String with a date and time component:               '08/18/2018 07:22:16' --> 8/18/2018 7:22:16 AM
//   String with a date component only:                   '08/18/2018' --> 8/18/2018 12:00:00 AM
//   String with a month and year component only:         '8/2018' --> 8/1/2018 12:00:00 AM
//   String with a month and day component only:          '8/18' --> 8/18/2018 12:00:00 AM
//   String with a time component only:                   '07:22:16' --> 2/22/2018 7:22:16 AM
//   String with an hour and AM/PM designator only:       '7 PM' --> 2/22/2018 7:00:00 PM
//   UTC string that conforms to ISO 8601:                '2018-08-18T07:22:16.0000000Z' --> 8/18/2018 12:22:16 AM
//   Non-UTC string that conforms to ISO 8601:            '2018-08-18T07:22:16.0000000-07:00' --> 8/18/2018 7:22:16 AM
//   String that conforms to RFC 1123:                    'Sat, 18 Aug 2018 07:22:16 GMT' --> 8/18/2018 12:22:16 AM
//   String with date, time, and time zone information:   '08/18/2018 07:22:16 -5:00' --> 8/18/2018 5:22:16 AM

module Parse6

open System

let  dateInfo = 
    [ "08/18/2018 07:22:16", "String with a date and time component"
      "08/18/2018", "String with a date component only"
      "8/2018", "String with a month and year component only"
      "8/18", "String with a month and day component only"
      "07:22:16", "String with a time component only"
      "7 PM", "String with an hour and AM/PM designator only"
      "2018-08-18T07:22:16.0000000Z", "UTC string that conforms to ISO 8601"
      "2018-08-18T07:22:16.0000000-07:00", "Non-UTC string that conforms to ISO 8601"
      "Sat, 18 Aug 2018 07:22:16 GMT", "String that conforms to RFC 1123"
      "08/18/2018 07:22:16 -5:00", "String with date, time, and time zone information" ]

printfn $"Today is {DateTime.Now:d}\n"

for dateAsString, description in dateInfo do
    printfn $"""{description + ":",-52} '{dateAsString}' --> {DateTime.Parse(dateAsString)}"""


// The example displays output like the following:
//   Today is 2/22/2018
//
//   String with a date and time component:               '08/18/2018 07:22:16' --> 8/18/2018 7:22:16 AM
//   String with a date component only:                   '08/18/2018' --> 8/18/2018 12:00:00 AM
//   String with a month and year component only:         '8/2018' --> 8/1/2018 12:00:00 AM
//   String with a month and day component only:          '8/18' --> 8/18/2018 12:00:00 AM
//   String with a time component only:                   '07:22:16' --> 2/22/2018 7:22:16 AM
//   String with an hour and AM/PM designator only:       '7 PM' --> 2/22/2018 7:00:00 PM
//   UTC string that conforms to ISO 8601:                '2018-08-18T07:22:16.0000000Z' --> 8/18/2018 12:22:16 AM
//   Non-UTC string that conforms to ISO 8601:            '2018-08-18T07:22:16.0000000-07:00' --> 8/18/2018 7:22:16 AM
//   String that conforms to RFC 1123:                    'Sat, 18 Aug 2018 07:22:16 GMT' --> 8/18/2018 12:22:16 AM
//   String with date, time, and time zone information:   '08/18/2018 07:22:16 -5:00' --> 8/18/2018 5:22:16 AM


Public Module Strings
   Public Sub Main()
      Dim dateInfo() As (dateAsString As String, description As String) = 
                     { ("08/18/2018 07:22:16", "String with a date and time component"),
                       ("08/18/2018", "String with a date component only"),
                       ("8/2018", "String with a month and year component only"),
                       ("8/18", "String with a month and day component only"),
                       ("07:22:16", "String with a time component only"),
                       ("7 PM", "String with an hour and AM/PM designator only"),
                       ("2018-08-18T07:22:16.0000000Z", "UTC string that conforms to ISO 8601"),   
                       ("2018-08-18T07:22:16.0000000-07:00", "Non-UTC string that conforms to ISO 8601"),
                       ("Sat, 18 Aug 2018 07:22:16 GMT", "String that conforms to RFC 1123"),
                       ("08/18/2018 07:22:16 -5:00", "String with date, time, and time zone information" ) }
   
      Console.WriteLine($"Today is {Date.Now:d}{vbCrLf}")
      
      For Each item in dateInfo
         Console.WriteLine($"{item.description + ":",-52} '{item.dateAsString}' --> {DateTime.Parse(item.dateAsString)}")        
      Next
   End Sub
End Module
' The example displays output like the following:
'   Today is 2/22/2018
'   
'   String with a date and time component:               '08/18/2018 07:22:16' --> 8/18/2018 7:22:16 AM
'   String with a date component only:                   '08/18/2018' --> 8/18/2018 12:00:00 AM
'   String with a month and year component only:         '8/2018' --> 8/1/2018 12:00:00 AM
'   String with a month and day component only:          '8/18' --> 8/18/2018 12:00:00 AM
'   String with a time component only:                   '07:22:16' --> 2/22/2018 7:22:16 AM
'   String with an hour and AM/PM designator only:       '7 PM' --> 2/22/2018 7:00:00 PM
'   UTC string that conforms to ISO 8601:                '2018-08-18T07:22:16.0000000Z' --> 8/18/2018 12:22:16 AM
'   Non-UTC string that conforms to ISO 8601:            '2018-08-18T07:22:16.0000000-07:00' --> 8/18/2018 7:22:16 AM
'   String that conforms to RFC 1123:                    'Sat, 18 Aug 2018 07:22:16 GMT' --> 8/18/2018 12:22:16 AM
'   String with date, time, and time zone information:   '08/18/2018 07:22:16 -5:00' --> 8/18/2018 5:22:16 AM

Si la cadena de entrada representa un día bisiesto en un año bisiesto en el calendario usado por el método de análisis (vea Las convenciones culturales y de análisis), el método Parse analiza correctamente la cadena. Si la cadena de entrada representa un día bisiesto en un año no bisiesto, el método produce un FormatException.

Dado que el método Parse intenta analizar la representación de cadena de una fecha y hora mediante las reglas de formato de la referencia cultural actual o especificada, se puede producir un error al intentar analizar una cadena en distintas referencias culturales. Para analizar un formato de fecha y hora específico en diferentes configuraciones regionales, use una de las sobrecargas del método DateTime.ParseExact y proporcione un especificador de formato.

Análisis y convenciones culturales

Todas las sobrecargas del método Parse distinguen la referencia cultural a menos que se analice la cadena (representada por s en la tabla siguiente) se ajusta al patrón ISO 8601. La operación de análisis usa la información de formato en un objeto DateTimeFormatInfo que se deriva de la siguiente manera:

Importante

Las eras en los calendarios japoneses se basan en el reinado del emperador y, por tanto, se espera que cambien. Por ejemplo, el 1 de mayo de 2019 marcó el comienzo de la era Reiwa en el JapaneseCalendar y JapaneseLunisolarCalendar. Este cambio de era afecta a todas las aplicaciones que usan estos calendarios. Para obtener más información y determinar si las aplicaciones se ven afectadas, consulte Control de una nueva era en el calendario japonés en .NET. Para obtener información sobre cómo probar las aplicaciones en sistemas Windows para garantizar su preparación para el cambio de era, consulte Preparar la aplicación para el cambio de la era japonesa. Para ver las características de .NET que admiten calendarios con varias eras y para obtener procedimientos recomendados al trabajar con calendarios que admiten varias eras, consulte Working with eras.

Si llama a Y provider es La información de formato se deriva de
Parse(String) - Referencia cultural actual ( propiedadDateTimeFormatInfo.CurrentInfo)
Parse(String, IFormatProvider) o Parse(String, IFormatProvider, DateTimeStyles) un objeto DateTimeFormatInfo Objeto DateTimeFormatInfo especificado
Parse(String, IFormatProvider) o Parse(String, IFormatProvider, DateTimeStyles) null Referencia cultural actual ( propiedadDateTimeFormatInfo.CurrentInfo)
Parse(String, IFormatProvider) o Parse(String, IFormatProvider, DateTimeStyles) un objeto CultureInfo La propiedad CultureInfo.DateTimeFormat
Parse(String, IFormatProvider) o Parse(String, IFormatProvider, DateTimeStyles) Implementación de IFormatProvider personalizada Método IFormatProvider.GetFormat

Cuando la información de formato se deriva de un objeto DateTimeFormatInfo, la propiedad DateTimeFormatInfo.Calendar define el calendario usado en la operación de análisis.

Si analiza una cadena de fecha y hora mediante un objeto DateTimeFormatInfo con valores personalizados distintos de los de una referencia cultural estándar, use el método ParseExact en lugar del método Parse para mejorar las posibilidades de una conversión correcta. Una cadena de fecha y hora no estándar puede ser complicada y difícil de analizar. El método Parse intenta analizar una cadena con varios patrones de análisis implícitos, lo que podría producir un error. Por el contrario, el método ParseExact requiere que designe explícitamente uno o varios patrones de análisis exactos que probablemente se realicen correctamente. Para obtener más información, vea la sección "DateTimeFormatInfo y datos dinámicos" del tema DateTimeFormatInfo.

Importante

Tenga en cuenta que las convenciones de formato de una referencia cultural determinada son dinámicas y pueden estar sujetas a cambios. Esto significa que las operaciones de análisis que dependen de las convenciones de formato de la referencia cultural predeterminada (actual) o que especifican un objeto IFormatProvider que representa una referencia cultural distinta de la referencia cultural invariable pueden producir un error inesperado si se produce alguna de las siguientes acciones:

  • Los datos específicos de la referencia cultural han cambiado entre las versiones principales o secundarias de .NET Framework o como resultado de una actualización a la versión existente de .NET Framework.
  • Los datos específicos de la referencia cultural reflejan las preferencias del usuario, que pueden variar de máquina a máquina o sesión a sesión.
  • Los datos específicos de la referencia cultural representan una referencia cultural de reemplazo que invalida la configuración de una referencia cultural estándar o una referencia cultural personalizada.

Para evitar las dificultades de análisis de datos y cadenas de tiempo asociadas a cambios en los datos culturales, puede analizar cadenas de fecha y hora mediante la referencia cultural invariable, o bien puede llamar al método ParseExact o TryParseExact y especificar el formato exacto de la cadena que se va a analizar. Si va a serializar y deserializar datos de fecha y hora, puede usar las convenciones de formato de la referencia cultural invariable, o bien puede serializar y deserializar el valor de DateTime en un formato binario.

Para obtener más información, vea la sección "Datos de referencia cultural dinámica" del tema CultureInfo y la sección "Conservar valores dateTime" en el tema DateTime.

Análisis y elementos de estilo

Todas las sobrecargas de Parse omiten los caracteres de espacio en blanco iniciales, internos o finales de la cadena de entrada (que se representa mediante s en la tabla siguiente). La fecha y hora pueden estar entre corchetes con un par de caracteres DE SIGNO NÚMERO inicial y final ("#", U+0023) y se pueden registrar con uno o varios caracteres NULL (U+0000).

Además, la sobrecarga de Parse(String, IFormatProvider, DateTimeStyles) tiene un parámetro styles que consta de uno o varios miembros de la enumeración DateTimeStyles. Este parámetro define cómo se debe interpretar s y cómo la operación de análisis debe convertir s a una fecha y hora. En la tabla siguiente se describe el efecto de cada miembro DateTimeStyles en la operación de análisis.

Miembro DateTimeStyles Efecto en la conversión
AdjustToUniversal Analiza s y, si es necesario, lo convierte en UTC, como se indica a continuación:

- Si s incluye un desplazamiento de zona horaria o si s no contiene información de zona horaria, pero styles incluye la marca AssumeLocal, el método analiza la cadena, llama a ToUniversalTime para convertir el valor de DateTime devuelto a UTC y establece la propiedad Kind en DateTimeKind.Utc.
- Si s indica que representa UTC, o si s no contiene información de zona horaria, pero styles incluye la marca AssumeUniversal, el método analiza la cadena, no realiza ninguna conversión de zona horaria en el valor devuelto DateTime y establece la propiedad Kind en DateTimeKind.Utc.
- En todos los demás casos, la marca no tiene ningún efecto.
AllowInnerWhite Este valor se omite. El espacio en blanco interno siempre se permite en los elementos de fecha y hora de s.
AllowLeadingWhite Este valor se omite. El espacio en blanco inicial siempre se permite en los elementos de fecha y hora de s.
AllowTrailingWhite Este valor se omite. El espacio en blanco final siempre se permite en los elementos de fecha y hora de s.
AllowWhiteSpaces Especifica que s pueden contener espacios en blanco iniciales, internos y finales. Este es el comportamiento predeterminado. No se puede invalidar proporcionando un valor de enumeración DateTimeStyles más restrictivo, como None.
AssumeLocal Especifica que si s carece de información de zona horaria, se asume la hora local. A menos que la marca de AdjustToUniversal esté presente, la propiedad Kind del valor de DateTime devuelto se establece en DateTimeKind.Local.
AssumeUniversal Especifica que si s carece de información de zona horaria, se supone que utc. A menos que la marca AdjustToUniversal esté presente, el método convierte el valor de DateTime devuelto de UTC a hora local y establece su propiedad Kind en DateTimeKind.Local.
None Aunque es válido, este valor se omite.
RoundtripKind En el caso de las cadenas que contienen información de zona horaria, intenta evitar la conversión de una cadena de fecha y hora en un valor de DateTime que representa una hora local con su propiedad Kind establecida en DateTimeKind.Local. Normalmente, esta cadena se crea llamando al método DateTime.ToString(String) y mediante el especificador de formato estándar "o", "r" o "u".

Valor devuelto y DateTime.Kind

Las sobrecargas de DateTime.Parse devuelven un valor de DateTime cuya propiedad Kind incluye información de zona horaria. Puede indicar que la hora es:

Por lo general, el método Parse devuelve un objeto DateTime cuya propiedad Kind es DateTimeKind.Unspecified. Sin embargo, el método Parse también puede realizar la conversión de zona horaria y establecer el valor de la propiedad Kind de forma diferente, en función de los valores de los parámetros s y styles:

Si Conversión de zona horaria Kind (propiedad)
s contiene información de zona horaria. La fecha y hora se convierten a la hora en la zona horaria local. DateTimeKind.Local
s contiene información de zona horaria y styles incluye la marca AdjustToUniversal. La fecha y hora se convierten en hora universal coordinada (UTC). DateTimeKind.Utc
s contiene el designador de zona horaria Z o GMT y styles incluye la marca RoundtripKind. La fecha y hora se interpretan como UTC. DateTimeKind.Utc

En el ejemplo siguiente se convierten cadenas de fecha que contienen información de zona horaria a la hora de la zona horaria local:

using System;

public class Example
{
   public static void Main()
   {
      string[] dateStrings = {"2008-05-01T07:34:42-5:00",
                              "2008-05-01 7:34:42Z",
                              "Thu, 01 May 2008 07:34:42 GMT"};
      foreach (string dateString in dateStrings)
      {
         DateTime convertedDate = DateTime.Parse(dateString);
         Console.WriteLine($"Converted {dateString} to {convertedDate.Kind} time {convertedDate}");
      }
   }
}
// These calls to the DateTime.Parse method display the following output:
//  Converted 2008-05-01T07:34:42-5:00 to Local time 5/1/2008 5:34:42 AM
//  Converted 2008-05-01 7:34:42Z to Local time 5/1/2008 12:34:42 AM
//  Converted Thu, 01 May 2008 07:34:42 GMT to Local time 5/1/2008 12:34:42 AM

open System

let dateStrings = 
    [ "2008-05-01T07:34:42-5:00"
      "2008-05-01 7:34:42Z"
      "Thu, 01 May 2008 07:34:42 GMT" ]

for dateString in dateStrings do
    let convertedDate = DateTime.Parse dateString
    printfn $"Converted {dateString} to {convertedDate.Kind} time {convertedDate}"

// These calls to the DateTime.Parse method display the following output:
//  Converted 2008-05-01T07:34:42-5:00 to Local time 5/1/2008 5:34:42 AM
//  Converted 2008-05-01 7:34:42Z to Local time 5/1/2008 12:34:42 AM
//  Converted Thu, 01 May 2008 07:34:42 GMT to Local time 5/1/2008 12:34:42 AM

Module Example
   Public Sub Main()
      Dim dateStrings() As String = {"2008-05-01T07:34:42-5:00", 
                                     "2008-05-01 7:34:42Z", 
                                     "Thu, 01 May 2008 07:34:42 GMT"}
      
      For Each dateStr In dateStrings
         Dim convertedDate As Date = Date.Parse(dateStr)
         Console.WriteLine($"Converted {dateStr} to {convertedDate.Kind} time {convertedDate}")
      Next 
   End Sub
End Module
' These calls to the DateTime.Parse method display the following output:
'   Converted 2008-05-01T07:34:42-5:00 to Local time 5/1/2008 5:34:42 AM
'   Converted 2008-05-01 7:34:42Z to Local time 5/1/2008 12:34:42 AM
'   Converted Thu, 01 May 2008 07:34:42 GMT to Local time 5/1/2008 12:34:42 AM

También puede conservar el valor de una propiedad Kind de fecha y hora durante una operación de formato y análisis mediante la marca DateTimeStyles.RoundtripKind. En el ejemplo siguiente se muestra cómo afecta la marca de RoundtripKind a la operación de análisis en DateTime valores que se convierten en cadenas mediante el especificador de formato "o", "r" o "u".

   string[] formattedDates = { "2008-09-15T09:30:41.7752486-07:00",
                               "2008-09-15T09:30:41.7752486Z",
                               "2008-09-15T09:30:41.7752486",
                               "2008-09-15T09:30:41.7752486-04:00",
                               "Mon, 15 Sep 2008 09:30:41 GMT" };
   foreach (string formattedDate in formattedDates)
   {
      Console.WriteLine(formattedDate);
      DateTime roundtripDate = DateTime.Parse(formattedDate, null,
                                              DateTimeStyles.RoundtripKind);
      Console.WriteLine($"   With RoundtripKind flag: {roundtripDate} {roundtripDate.Kind} time.");

      DateTime noRoundtripDate = DateTime.Parse(formattedDate, null,
                                                DateTimeStyles.None);
      Console.WriteLine($"   Without RoundtripKind flag: {noRoundtripDate} {noRoundtripDate.Kind} time.");
   }
// The example displays the following output:
//       2008-09-15T09:30:41.7752486-07:00
//          With RoundtripKind flag: 9/15/2008 9:30:41 AM Local time.
//          Without RoundtripKind flag: 9/15/2008 9:30:41 AM Local time.
//       2008-09-15T09:30:41.7752486Z
//          With RoundtripKind flag: 9/15/2008 9:30:41 AM Utc time.
//          Without RoundtripKind flag: 9/15/2008 2:30:41 AM Local time.
//       2008-09-15T09:30:41.7752486
//          With RoundtripKind flag: 9/15/2008 9:30:41 AM Unspecified time.
//          Without RoundtripKind flag: 9/15/2008 9:30:41 AM Unspecified time.
//       2008-09-15T09:30:41.7752486-04:00
//          With RoundtripKind flag: 9/15/2008 6:30:41 AM Local time.
//          Without RoundtripKind flag: 9/15/2008 6:30:41 AM Local time.
//       Mon, 15 Sep 2008 09:30:41 GMT
//          With RoundtripKind flag: 9/15/2008 9:30:41 AM Utc time.
//          Without RoundtripKind flag: 9/15/2008 2:30:41 AM Local time.

let formattedDates = 
    [ "2008-09-15T09:30:41.7752486-07:00"
      "2008-09-15T09:30:41.7752486Z"
      "2008-09-15T09:30:41.7752486"
      "2008-09-15T09:30:41.7752486-04:00"
      "Mon, 15 Sep 2008 09:30:41 GMT" ]

for formattedDate in formattedDates do
    printfn $"{formattedDate}"
    let roundtripDate = DateTime.Parse(formattedDate, null, DateTimeStyles.RoundtripKind)
    printfn $"   With RoundtripKind flag: {roundtripDate} {roundtripDate.Kind} time."

    let noRoundtripDate = DateTime.Parse(formattedDate, null, DateTimeStyles.None)
    printfn $"   Without RoundtripKind flag: {noRoundtripDate} {noRoundtripDate.Kind} time."

// The example displays the following output:
//       2008-09-15T09:30:41.7752486-07:00
//          With RoundtripKind flag: 9/15/2008 9:30:41 AM Local time.
//          Without RoundtripKind flag: 9/15/2008 9:30:41 AM Local time.
//       2008-09-15T09:30:41.7752486Z
//          With RoundtripKind flag: 9/15/2008 9:30:41 AM Utc time.
//          Without RoundtripKind flag: 9/15/2008 2:30:41 AM Local time.
//       2008-09-15T09:30:41.7752486
//          With RoundtripKind flag: 9/15/2008 9:30:41 AM Unspecified time.
//          Without RoundtripKind flag: 9/15/2008 9:30:41 AM Unspecified time.
//       2008-09-15T09:30:41.7752486-04:00
//          With RoundtripKind flag: 9/15/2008 6:30:41 AM Local time.
//          Without RoundtripKind flag: 9/15/2008 6:30:41 AM Local time.
//       Mon, 15 Sep 2008 09:30:41 GMT
//          With RoundtripKind flag: 9/15/2008 9:30:41 AM Utc time.
//          Without RoundtripKind flag: 9/15/2008 2:30:41 AM Local time.

Dim formattedDates() = { "2008-09-15T09:30:41.7752486-07:00", 
                           "2008-09-15T09:30:41.7752486Z",  
                           "2008-09-15T09:30:41.7752486",  
                           "2008-09-15T09:30:41.7752486-04:00", 
                           "Mon, 15 Sep 2008 09:30:41 GMT" }
For Each formattedDate In formattedDates
   Console.WriteLine(formattedDate)
   Dim roundtripDate = DateTime.Parse(formattedDate, Nothing,  
                                      DateTimeStyles.RoundtripKind)                        
   Console.WriteLine($"   With RoundtripKind flag: {roundtripDate} {roundtripDate.Kind} time.")                                          
   Dim noRoundtripDate = DateTime.Parse(formattedDate, Nothing,                                                                                                  DateTimeStyles.None)
   Console.WriteLine($"   Without RoundtripKind flag: {noRoundtripDate} {noRoundtripDate.Kind} time.")
Next         
' The example displays the following output:
'       2008-09-15T09:30:41.7752486-07:00
'          With RoundtripKind flag: 9/15/2008 9:30:41 AM Local time.
'          Without RoundtripKind flag: 9/15/2008 9:30:41 AM Local time.
'       2008-09-15T09:30:41.7752486Z
'          With RoundtripKind flag: 9/15/2008 9:30:41 AM Utc time.
'          Without RoundtripKind flag: 9/15/2008 2:30:41 AM Local time.
'       2008-09-15T09:30:41.7752486
'          With RoundtripKind flag: 9/15/2008 9:30:41 AM Unspecified time.
'          Without RoundtripKind flag: 9/15/2008 9:30:41 AM Unspecified time.
'       2008-09-15T09:30:41.7752486-04:00
'          With RoundtripKind flag: 9/15/2008 6:30:41 AM Local time.
'          Without RoundtripKind flag: 9/15/2008 6:30:41 AM Local time.
'       Mon, 15 Sep 2008 09:30:41 GMT
'          With RoundtripKind flag: 9/15/2008 9:30:41 AM Utc time.
'          Without RoundtripKind flag: 9/15/2008 2:30:41 AM Local time.

Parse(String)

Source:
DateTime.cs
Source:
DateTime.cs
Source:
DateTime.cs

Convierte la representación de cadena de una fecha y hora en su DateTime equivalente mediante las convenciones de la referencia cultural actual.

public:
 static DateTime Parse(System::String ^ s);
public static DateTime Parse (string s);
static member Parse : string -> DateTime
Public Shared Function Parse (s As String) As DateTime

Parámetros

s
String

Cadena que contiene una fecha y hora que se va a convertir. Consulte Cadena para analizar para obtener más información.

Devoluciones

DateTime

Objeto que es equivalente a la fecha y hora contenida en s.

Excepciones

ArgumentNullException

s es null.

FormatException

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

Ejemplos

En el ejemplo siguiente se analiza la representación de cadena de varios valores de fecha y hora por:

  • Con el proveedor de formato predeterminado, que proporciona las convenciones de formato de la referencia cultural actual del equipo que se usa para generar la salida de ejemplo. La salida de este ejemplo refleja las convenciones de formato de la referencia cultural en-US.

  • Con el valor de estilo predeterminado, que es AllowWhiteSpaces.

Controla el FormatException excepción que se produce cuando el método intenta analizar la representación de cadena de una fecha y hora mediante algunas convenciones de formato de otra referencia cultural. También se muestra cómo analizar correctamente un valor de fecha y hora que no usa las convenciones de formato de la referencia cultural actual.

using System;
using System.Globalization;

public class DateTimeParser
{
   public static void Main()
   {
      // Assume the current culture is en-US.
      // The date is February 16, 2008, 12 hours, 15 minutes and 12 seconds.

      // Use standard en-US date and time value
      DateTime dateValue;
      string dateString = "2/16/2008 12:15:12 PM";
      try {
         dateValue = DateTime.Parse(dateString);
         Console.WriteLine("'{0}' converted to {1}.", dateString, dateValue);
      }
      catch (FormatException) {
         Console.WriteLine("Unable to convert '{0}'.", dateString);
      }

      // Reverse month and day to conform to the fr-FR culture.
      // The date is February 16, 2008, 12 hours, 15 minutes and 12 seconds.
      dateString = "16/02/2008 12:15:12";
      try {
         dateValue = DateTime.Parse(dateString);
         Console.WriteLine("'{0}' converted to {1}.", dateString, dateValue);
      }
      catch (FormatException) {
         Console.WriteLine("Unable to convert '{0}'.", dateString);
      }

      // Call another overload of Parse to successfully convert string
      // formatted according to conventions of fr-FR culture.
      try {
         dateValue = DateTime.Parse(dateString, new CultureInfo("fr-FR", false));
         Console.WriteLine("'{0}' converted to {1}.", dateString, dateValue);
      }
      catch (FormatException) {
         Console.WriteLine("Unable to convert '{0}'.", dateString);
      }

      // Parse string with date but no time component.
      dateString = "2/16/2008";
      try {
         dateValue = DateTime.Parse(dateString);
         Console.WriteLine("'{0}' converted to {1}.", dateString, dateValue);
      }
      catch (FormatException) {
         Console.WriteLine("Unable to convert '{0}'.", dateString);
      }
   }
}
// The example displays the following output to the console:
//       '2/16/2008 12:15:12 PM' converted to 2/16/2008 12:15:12 PM.
//       Unable to convert '16/02/2008 12:15:12'.
//       '16/02/2008 12:15:12' converted to 2/16/2008 12:15:12 PM.
//       '2/16/2008' converted to 2/16/2008 12:00:00 AM.

open System
open System.Globalization

[<EntryPoint>]
let main _ =
    // Assume the current culture is en-US.
    // The date is February 16, 2008, 12 hours, 15 minutes and 12 seconds.

    // Use standard en-US date and time value
    let dateString = "2/16/2008 12:15:12 PM"
    try
        let dateValue = DateTime.Parse dateString
        printfn $"'{dateString}' converted to {dateValue}."
    with :? FormatException ->
        printfn $"Unable to convert '{dateString}'."

    // Reverse month and day to conform to the fr-FR culture.
    // The date is February 16, 2008, 12 hours, 15 minutes and 12 seconds.
    let dateString = "16/02/2008 12:15:12"
    try
        let dateValue = DateTime.Parse dateString
        printfn $"'{dateString}' converted to {dateValue}."
    with :? FormatException ->
        Console.WriteLine("Unable to convert '{0}'.", dateString)

    // Call another overload of Parse to successfully convert string
    // formatted according to conventions of fr-FR culture.
    try
        let dateValue = DateTime.Parse(dateString, CultureInfo("fr-FR", false))
        printfn $"'{dateString}' converted to {dateValue}."
    with :? FormatException ->
        printfn $"Unable to convert '{dateString}'."

    // Parse string with date but no time component.
    let dateString = "2/16/2008"
    try
        let dateValue = DateTime.Parse dateString
        printfn $"'{dateString}' converted to {dateValue}."
    with :? FormatException ->
        printfn $"Unable to convert '{dateString}'."

    0

// The example displays the following output to the console:
//       '2/16/2008 12:15:12 PM' converted to 2/16/2008 12:15:12 PM.
//       Unable to convert '16/02/2008 12:15:12'.
//       '16/02/2008 12:15:12' converted to 2/16/2008 12:15:12 PM.
//       '2/16/2008' converted to 2/16/2008 12:00:00 AM.

Imports System.Globalization

Class DateTimeParser
   Public Shared Sub Main()
      ' Assume the current culture is en-US. 
      ' The date is February 16, 2008, 12 hours, 15 minutes and 12 seconds.

      ' Use standard en-US date and time value
      Dim dateValue As Date
      Dim dateString As String = "2/16/2008 12:15:12 PM"
      Try
         dateValue = Date.Parse(dateString)
         Console.WriteLine("'{0}' converted to {1}.", dateString, dateValue)
      Catch e As FormatException
         Console.WriteLine("Unable to convert '{0}'.", dateString)
      End Try
            
      ' Reverse month and day to conform to the fr-FR culture.
      ' The date is February 16, 2008, 12 hours, 15 minutes and 12 seconds.
      dateString = "16/02/2008 12:15:12"
      Try
         dateValue = Date.Parse(dateString)
         Console.WriteLine("'{0}' converted to {1}.", dateString, dateValue)
      Catch e As FormatException
         Console.WriteLine("Unable to convert '{0}'.", dateString)
      End Try

      ' Call another overload of Parse to successfully convert string
      ' formatted according to conventions of fr-FR culture.      
      Try
         dateValue = Date.Parse(dateString, New CultureInfo("fr-FR", False))
         Console.WriteLine("'{0}' converted to {1}.", dateString, dateValue)
      Catch e As FormatException
         Console.WriteLine("Unable to convert '{0}'.", dateString)
      End Try
      
      ' Parse string with date but no time component.
      dateString = "2/16/2008"
      Try
         dateValue = Date.Parse(dateString)
         Console.WriteLine("'{0}' converted to {1}.", dateString, dateValue)
      Catch e As FormatException
         Console.WriteLine("Unable to convert '{0}'.", dateString)
      End Try
   End Sub 
End Class 
' The example displays the following output to the console:
'       '2/16/2008 12:15:12 PM' converted to 2/16/2008 12:15:12 PM.
'       Unable to convert '16/02/2008 12:15:12'.
'       '16/02/2008 12:15:12' converted to 2/16/2008 12:15:12 PM.
'       '2/16/2008' converted to 2/16/2008 12:00:00 AM.

Comentarios

Si s contiene información de zona horaria, este método devuelve un valor de DateTime cuya propiedad Kind es DateTimeKind.Local y convierte la fecha y hora en s a la hora local. De lo contrario, no realiza ninguna conversión de zona horaria y devuelve un valor de DateTime cuya propiedad Kind es DateTimeKind.Unspecified.

Esta sobrecarga intenta analizar s mediante las convenciones de formato de la referencia cultural actual. La referencia cultural actual se indica mediante la propiedad CurrentCulture. Para analizar una cadena mediante las convenciones de formato de una referencia cultural específica, llame al Parse(String, IFormatProvider) o a las sobrecargas de Parse(String, IFormatProvider, DateTimeStyles).

Esta sobrecarga intenta analizar s mediante DateTimeStyles.AllowWhiteSpaces estilo.

Consulte también

Se aplica a

Parse(ReadOnlySpan<Char>, IFormatProvider)

Source:
DateTime.cs
Source:
DateTime.cs
Source:
DateTime.cs

Analiza un intervalo de caracteres en un valor.

public:
 static DateTime Parse(ReadOnlySpan<char> s, IFormatProvider ^ provider) = ISpanParsable<DateTime>::Parse;
public static DateTime Parse (ReadOnlySpan<char> s, IFormatProvider? provider);
static member Parse : ReadOnlySpan<char> * IFormatProvider -> DateTime
Public Shared Function Parse (s As ReadOnlySpan(Of Char), provider As IFormatProvider) As DateTime

Parámetros

s
ReadOnlySpan<Char>

Intervalo de caracteres que se va a analizar.

provider
IFormatProvider

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

Devoluciones

DateTime

Resultado del análisis s.

Implementaciones

Parse(ReadOnlySpan<Char>, IFormatProvider)

Se aplica a

Parse(String, IFormatProvider)

Source:
DateTime.cs
Source:
DateTime.cs
Source:
DateTime.cs

Convierte la representación de cadena de una fecha y hora en su DateTime equivalente mediante la información de formato específica de la referencia cultural.

public:
 static DateTime Parse(System::String ^ s, IFormatProvider ^ provider);
public:
 static DateTime Parse(System::String ^ s, IFormatProvider ^ provider) = IParsable<DateTime>::Parse;
public static DateTime Parse (string s, IFormatProvider provider);
public static DateTime Parse (string s, IFormatProvider? provider);
static member Parse : string * IFormatProvider -> DateTime
Public Shared Function Parse (s As String, provider As IFormatProvider) As DateTime

Parámetros

s
String

Cadena que contiene una fecha y hora que se va a convertir. Consulte Cadena para analizar para obtener más información.

provider
IFormatProvider

Objeto que proporciona información de formato específica de la referencia cultural sobre s. Consulte de convenciones culturales y análisis

Devoluciones

DateTime

Objeto que es equivalente a la fecha y hora contenida en s tal como se especifica en provider.

Implementaciones

Parse(String, IFormatProvider)

Excepciones

ArgumentNullException

s es null.

FormatException

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

Ejemplos

En el ejemplo siguiente se analiza una matriz de cadenas de fecha mediante las convenciones de las referencias culturales de en-US, fr-FRy de-DE culturales. Muestra que las representaciones de cadena de una sola fecha se pueden interpretar de forma diferente en distintas referencias culturales.

using System;
using System.Globalization;

public class ParseDate
{
   public static void Main()
   {
      // Define cultures to be used to parse dates.
      CultureInfo[] cultures = {CultureInfo.CreateSpecificCulture("en-US"),
                                CultureInfo.CreateSpecificCulture("fr-FR"),
                                CultureInfo.CreateSpecificCulture("de-DE")};
      // Define string representations of a date to be parsed.
      string[] dateStrings = {"01/10/2009 7:34 PM",
                              "10.01.2009 19:34",
                              "10-1-2009 19:34" };
      // Parse dates using each culture.
      foreach (CultureInfo culture in cultures)
      {
         DateTime dateValue;
         Console.WriteLine("Attempted conversions using {0} culture.",
                           culture.Name);
         foreach (string dateString in dateStrings)
         {
            try {
               dateValue = DateTime.Parse(dateString, culture);
               Console.WriteLine("   Converted '{0}' to {1}.",
                                 dateString, dateValue.ToString("f", culture));
            }
            catch (FormatException) {
               Console.WriteLine("   Unable to convert '{0}' for culture {1}.",
                                 dateString, culture.Name);
            }
         }
         Console.WriteLine();
      }
   }
}
// The example displays the following output to the console:
//       Attempted conversions using en-US culture.
//          Converted '01/10/2009 7:34 PM' to Saturday, January 10, 2009 7:34 PM.
//          Converted '10.01.2009 19:34' to Thursday, October 01, 2009 7:34 PM.
//          Converted '10-1-2009 19:34' to Thursday, October 01, 2009 7:34 PM.
//
//       Attempted conversions using fr-FR culture.
//          Converted '01/10/2009 7:34 PM' to jeudi 1 octobre 2009 19:34.
//          Converted '10.01.2009 19:34' to samedi 10 janvier 2009 19:34.
//          Converted '10-1-2009 19:34' to samedi 10 janvier 2009 19:34.
//
//       Attempted conversions using de-DE culture.
//          Converted '01/10/2009 7:34 PM' to Donnerstag, 1. Oktober 2009 19:34.
//          Converted '10.01.2009 19:34' to Samstag, 10. Januar 2009 19:34.
//          Converted '10-1-2009 19:34' to Samstag, 10. Januar 2009 19:34.

open System
open System.Globalization

// Define cultures to be used to parse dates.
let cultures = 
    [ CultureInfo.CreateSpecificCulture "en-US"
      CultureInfo.CreateSpecificCulture "fr-FR"
      CultureInfo.CreateSpecificCulture "de-DE" ]

// Define string representations of a date to be parsed.
let dateStrings = 
    [ "01/10/2009 7:34 PM"
      "10.01.2009 19:34"
      "10-1-2009 19:34" ]

// Parse dates using each culture.
for culture in cultures do
    printfn $"Attempted conversions using {culture.Name} culture."
    for dateString in dateStrings do
        try
            let dateValue = DateTime.Parse(dateString, culture)
            printfn $"""   Converted '{dateString}' to {dateValue.ToString("f", culture)}."""
        with :? FormatException ->
            printfn $"   Unable to convert '{dateString}' for culture {culture.Name}." 
    printfn ""


// The example displays the following output to the console:
//       Attempted conversions using en-US culture.
//          Converted '01/10/2009 7:34 PM' to Saturday, January 10, 2009 7:34 PM.
//          Converted '10.01.2009 19:34' to Thursday, October 01, 2009 7:34 PM.
//          Converted '10-1-2009 19:34' to Thursday, October 01, 2009 7:34 PM.
//
//       Attempted conversions using fr-FR culture.
//          Converted '01/10/2009 7:34 PM' to jeudi 1 octobre 2009 19:34.
//          Converted '10.01.2009 19:34' to samedi 10 janvier 2009 19:34.
//          Converted '10-1-2009 19:34' to samedi 10 janvier 2009 19:34.
//
//       Attempted conversions using de-DE culture.
//          Converted '01/10/2009 7:34 PM' to Donnerstag, 1. Oktober 2009 19:34.
//          Converted '10.01.2009 19:34' to Samstag, 10. Januar 2009 19:34.
//          Converted '10-1-2009 19:34' to Samstag, 10. Januar 2009 19:34.

Imports System.Globalization

Module ParseDate
   Public Sub Main()
      ' Define cultures to be used to parse dates.
      Dim cultures() As CultureInfo = {CultureInfo.CreateSpecificCulture("en-US"), _
                                       CultureInfo.CreateSpecificCulture("fr-FR"), _
                                       CultureInfo.CreateSpecificCulture("de-DE")}
      ' Define string representations of a date to be parsed.
      Dim dateStrings() As String = {"01/10/2009 7:34 PM", _
                                     "10.01.2009 19:34", _
                                     "10-1-2009 19:34" }
      ' Parse dates using each culture.
      For Each culture In cultures
         Dim dateValue As Date
         Console.WriteLine("Attempted conversions using {0} culture.", culture.Name)
         For Each dateString As String In dateStrings
            Try
               dateValue = Date.Parse(dateString, culture)
               Console.WriteLine("   Converted '{0}' to {1}.", _
                                 dateString, dateValue.ToString("f", culture))
            Catch e As FormatException
               Console.WriteLine("   Unable to convert '{0}' for culture {1}.", _
                                 dateString, culture.Name)
            End Try                                                
         Next
         Console.WriteLine()
      Next                                                                                     
   End Sub
End Module
' The example displays the following output to the console:
'       Attempted conversions using en-US culture.
'          Converted '01/10/2009 7:34 PM' to Saturday, January 10, 2009 7:34 PM.
'          Converted '10.01.2009 19:34' to Thursday, October 01, 2009 7:34 PM.
'          Converted '10-1-2009 19:34' to Thursday, October 01, 2009 7:34 PM.
'       
'       Attempted conversions using fr-FR culture.
'          Converted '01/10/2009 7:34 PM' to jeudi 1 octobre 2009 19:34.
'          Converted '10.01.2009 19:34' to samedi 10 janvier 2009 19:34.
'          Converted '10-1-2009 19:34' to samedi 10 janvier 2009 19:34.
'       
'       Attempted conversions using de-DE culture.
'          Converted '01/10/2009 7:34 PM' to Donnerstag, 1. Oktober 2009 19:34.
'          Converted '10.01.2009 19:34' to Samstag, 10. Januar 2009 19:34.
'          Converted '10-1-2009 19:34' to Samstag, 10. Januar 2009 19:34.

Comentarios

Si s contiene información de zona horaria, este método devuelve un valor de DateTime cuya propiedad Kind es DateTimeKind.Local y convierte la fecha y hora en s a la hora local. De lo contrario, no realiza ninguna conversión de zona horaria y devuelve un valor de DateTime cuya propiedad Kind es DateTimeKind.Unspecified.

Esta sobrecarga intenta analizar s mediante el estilo DateTimeStyles.AllowWhiteSpaces.

Consulte también

Se aplica a

Parse(ReadOnlySpan<Char>, IFormatProvider, DateTimeStyles)

Source:
DateTime.cs
Source:
DateTime.cs
Source:
DateTime.cs

Convierte un intervalo de memoria que contiene una representación de cadena de una fecha y hora en su DateTime equivalente mediante información de formato específica de la referencia cultural y un estilo de formato.

public static DateTime Parse (ReadOnlySpan<char> s, IFormatProvider? provider = default, System.Globalization.DateTimeStyles styles = System.Globalization.DateTimeStyles.None);
public static DateTime Parse (ReadOnlySpan<char> s, IFormatProvider provider = default, System.Globalization.DateTimeStyles styles = System.Globalization.DateTimeStyles.None);
static member Parse : ReadOnlySpan<char> * IFormatProvider * System.Globalization.DateTimeStyles -> DateTime
Public Shared Function Parse (s As ReadOnlySpan(Of Char), Optional provider As IFormatProvider = Nothing, Optional styles As DateTimeStyles = System.Globalization.DateTimeStyles.None) As DateTime

Parámetros

s
ReadOnlySpan<Char>

Intervalo de memoria que contiene la cadena que se va a analizar. Consulte Cadena para analizar para obtener más información.

provider
IFormatProvider

Objeto que proporciona información de formato específica de la referencia cultural sobre s. Consulte de convenciones culturales y análisis

styles
DateTimeStyles

Combinación bit a bit de los valores de enumeración que indica los elementos de estilo que pueden estar presentes en s para que la operación de análisis se realice correctamente y que defina cómo interpretar la fecha analizada en relación con la zona horaria actual o la fecha actual. Un valor típico que se debe especificar es None.

Devoluciones

DateTime

Objeto que es equivalente a la fecha y hora contenida en s, tal como se especifica en provider y styles.

Excepciones

FormatException

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

ArgumentException

styles contiene una combinación no válida de valores DateTimeStyles. Por ejemplo, tanto AssumeLocal como AssumeUniversal.

Se aplica a

Parse(String, IFormatProvider, DateTimeStyles)

Source:
DateTime.cs
Source:
DateTime.cs
Source:
DateTime.cs

Convierte la representación de cadena de una fecha y hora en su DateTime equivalente mediante información de formato específica de la referencia cultural y un estilo de formato.

public:
 static DateTime Parse(System::String ^ s, IFormatProvider ^ provider, System::Globalization::DateTimeStyles styles);
public static DateTime Parse (string s, IFormatProvider provider, System.Globalization.DateTimeStyles styles);
public static DateTime Parse (string s, IFormatProvider? provider, System.Globalization.DateTimeStyles styles);
static member Parse : string * IFormatProvider * System.Globalization.DateTimeStyles -> DateTime
Public Shared Function Parse (s As String, provider As IFormatProvider, styles As DateTimeStyles) As DateTime

Parámetros

s
String

Cadena que contiene una fecha y hora que se va a convertir. Consulte Cadena para analizar para obtener más información.

provider
IFormatProvider

Objeto que proporciona información de formato específica de la referencia cultural sobre s. Consulte de convenciones culturales y análisis

styles
DateTimeStyles

Combinación bit a bit de los valores de enumeración que indica los elementos de estilo que pueden estar presentes en s para que la operación de análisis se realice correctamente y que defina cómo interpretar la fecha analizada en relación con la zona horaria actual o la fecha actual. Un valor típico que se debe especificar es None.

Devoluciones

DateTime

Objeto que es equivalente a la fecha y hora contenida en s, tal como se especifica en provider y styles.

Excepciones

ArgumentNullException

s es null.

FormatException

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

ArgumentException

styles contiene una combinación no válida de valores DateTimeStyles. Por ejemplo, tanto AssumeLocal como AssumeUniversal.

Ejemplos

En el ejemplo siguiente se muestra el método Parse(String, IFormatProvider, DateTimeStyles) y se muestra el valor de la propiedad Kind de los valores de DateTime resultantes.

using System;
using System.Globalization;

public class ParseDateExample
{
   public static void Main()
   {
      string dateString;
      CultureInfo culture ;
      DateTimeStyles styles;
      DateTime result;

      // Parse a date and time with no styles.
      dateString = "03/01/2009 10:00 AM";
      culture = CultureInfo.CreateSpecificCulture("en-US");
      styles = DateTimeStyles.None;
      try {
         result = DateTime.Parse(dateString, culture, styles);
         Console.WriteLine("{0} converted to {1} {2}.",
                           dateString, result, result.Kind.ToString());
      }
      catch (FormatException) {
         Console.WriteLine("Unable to convert {0} to a date and time.",
                           dateString);
      }

      // Parse the same date and time with the AssumeLocal style.
      styles = DateTimeStyles.AssumeLocal;
      try {
         result = DateTime.Parse(dateString, culture, styles);
         Console.WriteLine("{0} converted to {1} {2}.",
                           dateString, result, result.Kind.ToString());
      }
      catch (FormatException) {
         Console.WriteLine("Unable to convert {0} to a date and time.", dateString);
      }

      // Parse a date and time that is assumed to be local.
      // This time is five hours behind UTC. The local system's time zone is
      // eight hours behind UTC.
      dateString = "2009/03/01T10:00:00-5:00";
      styles = DateTimeStyles.AssumeLocal;
      try {
         result = DateTime.Parse(dateString, culture, styles);
         Console.WriteLine("{0} converted to {1} {2}.",
                           dateString, result, result.Kind.ToString());
      }
      catch (FormatException) {
         Console.WriteLine("Unable to convert {0} to a date and time.", dateString);
      }

      // Attempt to convert a string in improper ISO 8601 format.
      dateString = "03/01/2009T10:00:00-5:00";
      try {
         result = DateTime.Parse(dateString, culture, styles);
         Console.WriteLine("{0} converted to {1} {2}.",
                           dateString, result, result.Kind.ToString());
      }
      catch (FormatException) {
         Console.WriteLine("Unable to convert {0} to a date and time.", dateString);
      }

      // Assume a date and time string formatted for the fr-FR culture is the local
      // time and convert it to UTC.
      dateString = "2008-03-01 10:00";
      culture = CultureInfo.CreateSpecificCulture("fr-FR");
      styles = DateTimeStyles.AdjustToUniversal | DateTimeStyles.AssumeLocal;
      try {
         result = DateTime.Parse(dateString, culture, styles);
         Console.WriteLine("{0} converted to {1} {2}.",
                           dateString, result, result.Kind.ToString());
      }
      catch (FormatException) {
         Console.WriteLine("Unable to convert {0} to a date and time.", dateString);
      }
   }
}
// The example displays the following output to the console:
//       03/01/2009 10:00 AM converted to 3/1/2009 10:00:00 AM Unspecified.
//       03/01/2009 10:00 AM converted to 3/1/2009 10:00:00 AM Local.
//       2009/03/01T10:00:00-5:00 converted to 3/1/2009 7:00:00 AM Local.
//       Unable to convert 03/01/2009T10:00:00-5:00 to a date and time.
//       2008-03-01 10:00 converted to 3/1/2008 6:00:00 PM Utc.

open System
open System.Globalization

[<EntryPoint>]
let main _ =
    // Parse a date and time with no styles.
    let dateString = "03/01/2009 10:00 AM"
    let culture = CultureInfo.CreateSpecificCulture "en-US"
    let styles = DateTimeStyles.None
    try
        let result = DateTime.Parse(dateString, culture, styles)
        printfn $"{dateString} converted to {result} {result.Kind}."
    with :? FormatException ->
        printfn $"Unable to convert {dateString} to a date and time."

    // Parse the same date and time with the AssumeLocal style.
    let styles = DateTimeStyles.AssumeLocal
    try
        let result = DateTime.Parse(dateString, culture, styles)
        printfn $"{dateString} converted to {result} {result.Kind}."
    with :? FormatException ->
        printfn $"Unable to convert {dateString} to a date and time."

    // Parse a date and time that is assumed to be local.
    // This time is five hours behind UTC. The local system's time zone is
    // eight hours behind UTC.
    let dateString = "2009/03/01T10:00:00-5:00"
    let styles = DateTimeStyles.AssumeLocal
    try
        let result = DateTime.Parse(dateString, culture, styles)
        printfn $"{dateString} converted to {result} {result.Kind}."
    with :? FormatException ->
        printfn $"Unable to convert {dateString} to a date and time."

    // Attempt to convert a string in improper ISO 8601 format.
    let dateString = "03/01/2009T10:00:00-5:00"
    try
        let result = DateTime.Parse(dateString, culture, styles)
        printfn $"{dateString} converted to {result} {result.Kind}."
    with :? FormatException ->
        printfn $"Unable to convert {dateString} to a date and time."

    // Assume a date and time string formatted for the fr-FR culture is the local
    // time and convert it to UTC.
    let dateString = "2008-03-01 10:00"
    let culture = CultureInfo.CreateSpecificCulture "fr-FR"
    let styles = DateTimeStyles.AdjustToUniversal ||| DateTimeStyles.AssumeLocal
    try
        let result = DateTime.Parse(dateString, culture, styles)
        printfn $"{dateString} converted to {result} {result.Kind}."
    with :? FormatException ->
        printfn $"Unable to convert {dateString} to a date and time."

    0

// The example displays the following output to the console:
//       03/01/2009 10:00 AM converted to 3/1/2009 10:00:00 AM Unspecified.
//       03/01/2009 10:00 AM converted to 3/1/2009 10:00:00 AM Local.
//       2009/03/01T10:00:00-5:00 converted to 3/1/2009 7:00:00 AM Local.
//       Unable to convert 03/01/2009T10:00:00-5:00 to a date and time.
//       2008-03-01 10:00 converted to 3/1/2008 6:00:00 PM Utc.

Imports System.Globalization

Module ParseDateExample
   Public Sub Main()
      Dim dateString As String  
      Dim culture As CultureInfo
      Dim styles As DateTimeStyles 
      Dim result As DateTime
      
      ' Parse a date and time with no styles.
      dateString = "03/01/2009 10:00 AM"
      culture = CultureInfo.CreateSpecificCulture("en-US")
      styles = DateTimeStyles.None
      Try
         result = DateTime.Parse(dateString, culture, styles)
         Console.WriteLine("{0} converted to {1} {2}.", _
                           dateString, result, result.Kind.ToString())
      Catch e As FormatException
         Console.WriteLine("Unable to convert {0} to a date and time.", dateString)
      End Try      
      
      ' Parse the same date and time with the AssumeLocal style.
      styles = DateTimeStyles.AssumeLocal
      Try
         result = DateTime.Parse(dateString, culture, styles)
         Console.WriteLine("{0} converted to {1} {2}.", _
                           dateString, result, result.Kind.ToString())
      Catch e As FormatException
         Console.WriteLine("Unable to convert {0} to a date and time.", dateString)
      End Try      
      
      ' Parse a date and time that is assumed to be local.
      ' This time is five hours behind UTC. The local system's time zone is 
      ' eight hours behind UTC.
      dateString = "2009/03/01T10:00:00-5:00"
      styles = DateTimeStyles.AssumeLocal
      Try
         result = DateTime.Parse(dateString, culture, styles)
         Console.WriteLine("{0} converted to {1} {2}.", _
                           dateString, result, result.Kind.ToString())
      Catch e As FormatException
         Console.WriteLine("Unable to convert {0} to a date and time.", dateString)
      End Try      
      
      ' Attempt to convert a string in improper ISO 8601 format.
      dateString = "03/01/2009T10:00:00-5:00"
      Try
         result = DateTime.Parse(dateString, culture, styles)
         Console.WriteLine("{0} converted to {1} {2}.", _
                           dateString, result, result.Kind.ToString())
      Catch e As FormatException
         Console.WriteLine("Unable to convert {0} to a date and time.", dateString)
      End Try      

      ' Assume a date and time string formatted for the fr-FR culture is the local 
      ' time and convert it to UTC.
      dateString = "2008-03-01 10:00"
      culture = CultureInfo.CreateSpecificCulture("fr-FR")
      styles = DateTimeStyles.AdjustToUniversal Or DateTimeStyles.AssumeLocal
      Try
         result = DateTime.Parse(dateString, culture, styles)
         Console.WriteLine("{0} converted to {1} {2}.", _
                           dateString, result, result.Kind.ToString())
      Catch e As FormatException
         Console.WriteLine("Unable to convert {0} to a date and time.", dateString)
      End Try      
   End Sub
End Module
'
' The example displays the following output to the console:
'       03/01/2009 10:00 AM converted to 3/1/2009 10:00:00 AM Unspecified.
'       03/01/2009 10:00 AM converted to 3/1/2009 10:00:00 AM Local.
'       2009/03/01T10:00:00-5:00 converted to 3/1/2009 7:00:00 AM Local.
'       Unable to convert 03/01/2009T10:00:00-5:00 to a date and time.
'       2008-03-01 10:00 converted to 3/1/2008 6:00:00 PM Utc.

Comentarios

Esta sobrecarga de método convierte la fecha y hora en s y establece la propiedad Kind del valor de DateTime devuelto de la siguiente manera:

Si Conversión de zona horaria Kind (propiedad)
s no contiene información de zona horaria. Ninguno. DateTimeKind.Unspecified
s contiene información de zona horaria. A la hora de la zona horaria local DateTimeKind.Local
s contiene información de zona horaria y styles incluye la marca DateTimeStyles.AdjustToUniversal. Para la hora universal coordinada (UTC) DateTimeKind.Utc
s contiene el designador de zona horaria Z o GMT y styles incluye el DateTimeStyles.RoundtripKind. Ninguno. DateTimeKind.Utc

Consulte también

Se aplica a