DateTime.Parse Método

Definición

Convierte la representación de cadena de una fecha y hora en el objeto DateTime equivalente.Converts the string representation of a date and time to its DateTime equivalent.

Sobrecargas

Parse(String)

Convierte la representación de cadena para una fecha y hora en su DateTime equivalente, usando las convenciones de la referencia cultural de subproceso especificada.Converts the string representation of a date and time to its DateTime equivalent by using the conventions of the current thread culture.

Parse(String, IFormatProvider)

Convierte la representación de cadena para una fecha y hora en su DateTime equivalente, usando la información de formato específica de la referencia cultural especificada.Converts the string representation of a date and time to its DateTime equivalent by using culture-specific format information.

Parse(ReadOnlySpan<Char>, IFormatProvider, DateTimeStyles)

Convierte un intervalo de memoria que contiene una representación de cadena de una fecha y hora en el objeto DateTime equivalente mediante la información de formato específica de la referencia cultural y un estilo de formato especificados.Converts a memory span that contains string representation of a date and time to its DateTime equivalent by using culture-specific format information and a formatting style.

Parse(String, IFormatProvider, DateTimeStyles)

Convierte la representación de cadena de una fecha y hora en el objeto DateTime equivalente, usando la información de formato específica de la referencia cultural y un estilo de formato especificados.Converts the string representation of a date and time to its DateTime equivalent by using culture-specific format information and a formatting style.

Ejemplos

Muchos ejemplos que llaman al método DateTime.Parse se intercalan en la sección comentarios de este artículo y en la documentación de las sobrecargas individuales de @no__t 2.Numerous examples that call the DateTime.Parse method are interspersed throughout the Remarks section of this article and in the documentation for the individual DateTime.Parse overloads.

Nota

Algunos ejemplos de C# de este artículo se ejecutan en el ejecutor de código en línea y área de juegos de Try.NET.Some C# examples in this article run in the Try.NET inline code runner and playground. Haga clic en el botón Ejecutar para ejecutar un ejemplo en una ventana interactiva.Select the Run button to run an example in an interactive window. Una vez que se ejecuta el código, puede modificar y ejecutar el código modificado si vuelve a hacer clic en Ejecutar.Once you execute the code, you can modify it and run the modified code by selecting Run again. El código modificado se ejecuta en la ventana interactiva o, si se produce un error en la compilación, en la ventana interactiva se muestran todos los mensajes de error del compilador de C#.The modified code either runs in the interactive window or, if compilation fails, the interactive window displays all C# compiler error messages.

La zona horaria local del ejecutor de código en línea de Try.NET y del área de juegos es la hora universal coordinada o UTC.The local time zone of the Try.NET inline code runner and playground is Coordinated Universal Time, or UTC. Esto puede afectar al comportamiento y la salida de ejemplos que ilustran los tipos DateTime, DateTimeOffset y TimeZoneInfo y sus miembros.This may affect the behavior and the output of examples that illustrate the DateTime, DateTimeOffset, and TimeZoneInfo types and their members.

También puede descargar un conjunto completo de ejemplos de DateTime.Parse, que se incluyen en un proyecto de .net Core 2,0 C# para y un proyecto de .net Core 2,0 para Visual Basic, desde el repositorio dotnet/samples de github.You can also download a complete set of DateTime.Parse examples, which are included in a .NET Core 2.0 project for C# and a .NET Core 2.0 project for Visual Basic, from the dotnet/samples GitHub repository.

Comentarios

En esta sección:In this section:

¿A qué método se llama?Which method do I call?

EnTo CallCall
Analizar una cadena de fecha y hora mediante las convenciones de la referencia cultural actual.Parse a date and time string by using the conventions of the current culture. Parse(String) overloadParse(String) overload
Analizar una cadena de fecha y hora mediante las convenciones de una referencia cultural concreta.Parse a date and time string by using the conventions of a specific culture. sobrecarga Parse(String, IFormatProvider) (consulte análisis y convenciones culturales)Parse(String, IFormatProvider) overload (see Parsing and Cultural Conventions)
Analiza una cadena de fecha y hora con elementos de estilo especiales (como un espacio en blanco o ningún espacio en blanco).Parse a date and time string with special style elements (such as white space or no white space). Parse(String, IFormatProvider, DateTimeStyles) overloadParse(String, IFormatProvider, DateTimeStyles) overload
Analiza una cadena de fecha y hora que debe estar en un formato determinado.Parse a date and time string that must be in a particular format. DateTime.ParseExact o DateTime.TryParseExactDateTime.ParseExact or DateTime.TryParseExact
Analiza una cadena de fecha y hora y realiza una conversión a UTC u hora local.Parse a date and time string and perform a conversion to UTC or local time. Parse(String, IFormatProvider, DateTimeStyles) overloadParse(String, IFormatProvider, DateTimeStyles) overload
Analizar una cadena de fecha y hora sin controlar excepciones.Parse a date and time string without handling exceptions. Método DateTime.TryParseDateTime.TryParse method
Restaurar (ida y vuelta) un valor de fecha y hora creado por una operación de formato.Restore (round-trip) a date and time value created by a formatting operation. Pase la cadena de formato estándar "o" o "r" al método ToString(String) y llame a la sobrecarga Parse(String, IFormatProvider, DateTimeStyles) con DateTimeStyles.RoundtripKindPass the "o" or "r" standard format string to the ToString(String) method, and call the Parse(String, IFormatProvider, DateTimeStyles) overload with DateTimeStyles.RoundtripKind
Analiza una cadena de fecha y hora en un formato fijo a través de los límites de la máquina (y posiblemente cultural).Parse a date and time string in a fixed format across machine (and possibly cultural) boundaries. DateTime.ParseExact o DateTime.TryParseExact (método)DateTime.ParseExact or DateTime.TryParseExact method

Cadena que se va a analizar.The string to parse

El método Parse intenta convertir la representación de cadena de un valor de fecha y hora en su equivalente DateTime.The Parse method tries to convert the string representation of a date and time value to its DateTime equivalent. Intenta analizar la cadena de entrada completamente sin producir una excepción FormatException.It tries to parse the input string completely without throwing a FormatException exception.

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 una FormatException, mientras que el método TryParse devuelve false.If the parsing operation fails because of an unrecognized string format, the Parse method throws a FormatException, whereas the TryParse method returns 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.Because exception handling can be expensive, you should use Parse when the parsing operation is expected to succeed because the input source is trusted. TryParse es preferible cuando es probable que se produzcan errores de análisis, especialmente porque un origen de entrada no es de confianza o tiene valores predeterminados razonables para sustituir cadenas que no se analizan correctamente.TryParse is preferable when parsing failures are likely, particularly because an input source is not trusted, or you have reasonable default values to substitute for strings that do not parse successfully.

La cadena que se va a analizar puede tener cualquiera de las siguientes formas:The string to be parsed can take any of the following forms:

  • Cadena con un componente de fecha y hora.A string with a date and a time component.

  • Cadena con una fecha pero sin componente de hora.A string with a date but no time component. Si el componente de hora está ausente, el método asume 12:00 medianoche.If the time component is absent, the method assumes 12:00 midnight. Si el componente de fecha tiene un año de dos dígitos, se convierte en un año basado en el Calendar.TwoDigitYearMax del calendario actual de la referencia cultural actual o el calendario actual de la referencia cultural especificada (si usa una sobrecarga con un argumento provider que no sea NULL).If the date component has a two-digit year, it is converted to a year based on the Calendar.TwoDigitYearMax of the current culture's current calendar or the specified culture's current calendar (if you use an overload with a non-null provider argument).

  • Una cadena con un componente de fecha que incluye solo los componentes month y Year pero no Day.A string with a date component that includes only the month and the year but no day component. El método asume el primer día del mes.The method assumes the first day of the month.

  • Cadena con un componente de fecha que incluye solo los componentes month y Day pero no year.A string with a date component that includes only the month and the day but no year component. El método asume el año actual.The method assumes the current year.

  • Cadena con un componente de hora pero sin fecha.A string with a time but no date component. El método asume la fecha actual a menos que llame a la sobrecarga 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.The method assumes the current date unless you call the Parse(String, IFormatProvider, DateTimeStyles) overload and include DateTimeStyles.NoCurrentDateDefault in the styles argument, in which case the method assumes a date of January 1, 0001.

  • Una cadena con un componente de hora que incluye solo la hora y un designador AM/PM, sin componente de fecha.A string with a time component that includes only the hour and an AM/PM designator, with no date component. El método asume la fecha actual y una hora sin minutos y sin segundos.The method assumes the current date and a time with no minutes and no seconds. Puede cambiar este comportamiento mediante una llamada a la sobrecarga Parse(String, IFormatProvider, DateTimeStyles) e incluir DateTimeStyles.NoCurrentDateDefault en el argumento styles, en cuyo caso el método asume una fecha del 1 de enero de 0001.You can change this behavior by calling the Parse(String, IFormatProvider, DateTimeStyles) overload and include DateTimeStyles.NoCurrentDateDefault in the styles argument, in which case the method assumes a date of January 1, 0001.

  • Una cadena que incluye información de zona horaria y se ajusta a ISO 8601.A string that includes time zone information and conforms to ISO 8601. En los ejemplos siguientes, la primera cadena designa la hora universal coordinada (UTC) y la segunda designa la hora de una zona horaria que es siete horas anterior a la hora UTC:In the following examples, the first string designates Coordinated Universal Time (UTC), and the second designates the time in a time zone that's seven hours earlier than UTC:

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

  • Una cadena que incluye el designador GMT y se ajusta al formato de hora RFC 1123. por ejemplo:A string that includes the GMT designator and conforms to the RFC 1123 time format; for example:

    "SAT, 01 Nov 2008 19:35:00 GMT""Sat, 01 Nov 2008 19:35:00 GMT"

  • Una cadena que incluye la fecha y la hora junto con la información de desplazamiento de zona horaria; por ejemplo:A string that includes the date and time along with time zone offset information; for example:

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

En el ejemplo siguiente se analizan las cadenas de 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:The following example parses strings in each of these formats by using the formatting conventions of the current culture, which in this case is the en-US culture:

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


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 de un año bisiesto en el calendario utilizado por el método de análisis (consulte análisis y convenciones culturales), el método Parse analiza la cadena correctamente.If the input string represents a leap day in a leap year in the calendar used by the parsing method (see Parsing and cultural conventions), the Parse method parses the string successfully. Si la cadena de entrada representa un día bisiesto en un año que no es bisiesto, el método produce una excepción FormatException.If the input string represents a leap day in a non-leap year, the method throws a FormatException.

Dado que el método Parse intenta analizar la representación de cadena de una fecha y hora usando 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.Because the Parse method tries to parse the string representation of a date and time by using the formatting rules of the current or a specified culture, trying to parse a string across different cultures can fail. Para analizar un formato de fecha y hora específico en distintas configuraciones regionales, use una de las sobrecargas del método DateTime.ParseExact y proporcione un especificador de formato.To parse a specific date and time format across different locales, use one of the overloads of the DateTime.ParseExact method and provide a format specifier.

Análisis y convenciones culturalesParsing and cultural conventions

Todas las sobrecargas del método Parse son dependientes de la referencia cultural, a menos que la cadena que se va a analizar (representada por s en la tabla siguiente) se ajuste al patrón ISO 8601.All overloads of the Parse method are culture-sensitive unless the string to be parsed (which is represented by s in the following table) conforms to the ISO 8601 pattern. La operación de análisis usa la información de formato en un objeto DateTimeFormatInfo que se deriva de la siguiente manera:The parsing operation uses the formatting information in a DateTimeFormatInfo object that is derived as follows:

Importante

Las eras en los calendarios japoneses se basan en el reino del emperador y, por tanto, se espera que cambien.Eras in the Japanese calendars are based on the emperor's reign and are therefore expected to change. Por ejemplo, el 1 de mayo de 2019 marcaba el comienzo de la era Reiwa en JapaneseCalendar y JapaneseLunisolarCalendar.For example, May 1, 2019 marked the beginning of the Reiwa era in the JapaneseCalendar and JapaneseLunisolarCalendar. Este cambio de era afecta a todas las aplicaciones que usan estos calendarios.Such a change of era affects all applications that use these calendars. Para obtener más información y determinar si sus aplicaciones están entre las afectadas, consulte Handling a new era in the Japanese calendar in .NET (Gestión de una nueva era del calendario japonés en .NET).See Handling a new era in the Japanese calendar in .NET for more information and to determine whether your applications are affected. Para obtener más información sobre cómo probar aplicaciones en sistemas Windows para garantizar que estén preparadas para el cambio de era, consulte Prepare your application for the Japanese era change (Preparación de la aplicación para el cambio de era japonesa).See Prepare your application for the Japanese era change for information on testing your applications on Windows systems to ensure their readiness for the era change. Consulte Trabajar con eras para ver las características de .NET que admiten calendarios con varias eras y procedimientos recomendados al trabajar con calendarios que admiten varias eras.See Working with eras for features in .NET that support calendars with multiple eras and for best practices when working with calendars that support multiple eras.

Si llama aIf you call Y provider esAnd provider is La información de formato se deriva deFormatting information is derived from
Parse(String) - Referencia cultural del subproceso actual (propiedad DateTimeFormatInfo.CurrentInfo)The current thread culture (DateTimeFormatInfo.CurrentInfo property)
Parse(String, IFormatProvider) o Parse(String, IFormatProvider, DateTimeStyles)Parse(String, IFormatProvider) or Parse(String, IFormatProvider, DateTimeStyles) un objeto DateTimeFormatInfoa DateTimeFormatInfo object Objeto DateTimeFormatInfo especificadoThe specified DateTimeFormatInfo object
Parse(String, IFormatProvider) o Parse(String, IFormatProvider, DateTimeStyles)Parse(String, IFormatProvider) or Parse(String, IFormatProvider, DateTimeStyles) null Referencia cultural del subproceso actual (propiedad DateTimeFormatInfo.CurrentInfo)The current thread culture (DateTimeFormatInfo.CurrentInfo property)
Parse(String, IFormatProvider) o Parse(String, IFormatProvider, DateTimeStyles)Parse(String, IFormatProvider) or Parse(String, IFormatProvider, DateTimeStyles) un objeto CultureInfoa CultureInfo object La propiedad CultureInfo.DateTimeFormatThe CultureInfo.DateTimeFormat property
Parse(String, IFormatProvider) o Parse(String, IFormatProvider, DateTimeStyles)Parse(String, IFormatProvider) or Parse(String, IFormatProvider, DateTimeStyles) Implementación personalizada de IFormatProviderCustom IFormatProvider implementation El método IFormatProvider.GetFormatThe IFormatProvider.GetFormat method

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.When formatting information is derived from a DateTimeFormatInfo object, the DateTimeFormatInfo.Calendar property defines the calendar used in the parsing operation.

Si analiza una cadena de fecha y hora mediante un objeto DateTimeFormatInfo con una configuración personalizada que difiere de la 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.If you parse a date and time string by using a DateTimeFormatInfo object with customized settings that are different from those of a standard culture, use the ParseExact method instead of the Parse method to improve the chances for a successful conversion. Una cadena de fecha y hora no estándar puede ser complicada y difícil de analizar.A non-standard date and time string can be complicated and difficult to parse. El método Parse intenta analizar una cadena con varios patrones de análisis implícitos; todos ellos podrían producir un error.The Parse method tries to parse a string with several implicit parse patterns, all of which might fail. Por el contrario, el método ParseExact requiere que designe explícitamente uno o más patrones de análisis exactos que probablemente sean correctos.In contrast, the ParseExact method requires you to explicitly designate one or more exact parse patterns that are likely to succeed. Para obtener más información, vea la sección "DateTimeFormatInfo and datos dinámicos" en el tema DateTimeFormatInfo.For more information, see the "DateTimeFormatInfo and Dynamic Data" section in the DateTimeFormatInfo topic.

Importante

Tenga en cuenta que las convenciones de formato de una referencia cultural determinada son dinámicas y pueden estar sujetas a cambios.Note that the formatting conventions for a particular culture are dynamic and can be subject to change. 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 de todos los idiomas pueden producir un error inesperado si se produce alguno de los siguientes casos:This means that parsing operations that depend on the formatting conventions of the default (current) culture or that specify an IFormatProvider object that represents a culture other than the invariant culture can unexpectedly fail if any of the following occurs:

  • Los datos específicos de la referencia cultural han cambiado entre las versiones principal o secundaria del .NET Framework o como resultado de una actualización de la versión existente de la .NET Framework.The culture-specific data has changed between major or minor versions of the .NET Framework or as the result of an update to the existing version of the .NET Framework.
  • Los datos específicos de la referencia cultural reflejan las preferencias del usuario, que pueden variar de un equipo a un equipo o de una sesión a una sesión.The culture-specific data reflects user preferences, which can vary from machine to machine or session to session.
  • 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.The culture-specific data represents a replacement culture that overrides the settings of a standard culture or a custom culture.

Para evitar las dificultades en el análisis de las cadenas de datos y de tiempo que están asociadas a los cambios en los datos culturales, puede analizar cadenas de fecha y hora con la referencia cultural de todos los idiomas, o puede llamar al método ParseExact o TryParseExact y especificar el formato exacto de la cadena. que se va a analizar.To prevent the difficulties in parsing data and time strings that are associated with changes in cultural data, you can parse date and time strings by using the invariant culture, or you can call the ParseExact or TryParseExact method and specify the exact format of the string to be parsed. Si está serializando y deserializando datos de fecha y hora, puede usar las convenciones de formato de la referencia cultural de todos los idiomas, o puede serializar y deserializar el valor DateTime en un formato binario.If you are serializing and deserializing date and time data, you can either use the formatting conventions of the invariant culture, or you can serialize and deserialize the DateTime value in a binary format.

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 de fecha y hora" en el tema DateTime.For more information see the "Dynamic culture data" section in the CultureInfo topic and the "Persisting DateTime values" section in the DateTime topic.

Elementos de estilo y análisisParsing and style elements

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).All Parse overloads ignore leading, inner, or trailing white-space characters in the input string (which is represented by s in the following table). La fecha y la hora se pueden correlacionar con un par de caracteres de signo de número iniciales y finales ("#", U + 0023) y se pueden incluir con uno o más caracteres NULOs (U + 0000).The date and time can be bracketed with a pair of leading and trailing NUMBER SIGN characters ("#", U+0023), and can be trailed with one or more NULL characters (U+0000).

Además, la sobrecarga Parse(String, IFormatProvider, DateTimeStyles) tiene un parámetro styles que consta de uno o más miembros de la enumeración DateTimeStyles.In addition, the Parse(String, IFormatProvider, DateTimeStyles) overload has a styles parameter that consists of one or more members of the DateTimeStyles enumeration. Este parámetro define cómo se debe interpretar s y cómo debe convertir la operación de análisis s a una fecha y hora.This parameter defines how s should be interpreted and how the parse operation should convert s to a date and time. En la tabla siguiente se describe el efecto de cada miembro DateTimeStyles en la operación de análisis.The following table describes the effect of each DateTimeStyles member on the parse operation.

DateTimeStyles (miembro)DateTimeStyles member Efecto en la conversiónEffect on conversion
AdjustToUniversal Analiza s y, si es necesario, lo convierte en UTC, como se indica a continuación:Parses s and, if necessary, converts it to UTC, as follows:

-Si s incluye un ajuste de zona horaria o si s no contiene ninguna 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 la hora UTC y establece la propiedad Kind en DateTimeKind.Utc.- If s includes a time zone offset, or if s contains no time zone information but styles includes the AssumeLocal flag, the method parses the string, calls ToUniversalTime to convert the returned DateTime value to UTC, and sets the Kind property to DateTimeKind.Utc.
-Si s indica que representa la hora 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 DateTime devuelto y establece el Kind. propiedad que se va a DateTimeKind.Utc.- If s indicates that it represents UTC, or if s does not contain time zone information but styles includes the AssumeUniversal flag, the method parses the string, performs no time zone conversion on the returned DateTime value, and sets the Kind property to DateTimeKind.Utc.
-En todos los demás casos, la marca no tiene ningún efecto.- In all other cases, the flag has no effect.
AllowInnerWhite Este valor se omite.This value is ignored. Siempre se permite el espacio en blanco interno en los elementos de fecha y hora de s.Inner white space is always permitted in the date and time elements of s.
AllowLeadingWhite Este valor se omite.This value is ignored. Siempre se permite el espacio en blanco inicial en los elementos de fecha y hora de s.Leading white space is always permitted in the date and time elements of s.
AllowTrailingWhite Este valor se omite.This value is ignored. Siempre se permite el espacio en blanco final en los elementos de fecha y hora de s.Trailing white space is always permitted in the date and time elements of s.
AllowWhiteSpaces Especifica que s puede contener espacios en blanco iniciales, internos y finales.Specifies that s may contain leading, inner, and trailing white spaces. Éste es el comportamiento predeterminado.This is the default behavior. No se puede invalidar proporcionando un valor de enumeración DateTimeStyles más restrictivo, como None.It cannot be overridden by supplying a more restrictive DateTimeStyles enumeration value such as None.
AssumeLocal Especifica que si s carece de información de zona horaria, se supone la hora local.Specifies that if s lacks any time zone information, local time is assumed. A menos que esté presente la marca AdjustToUniversal, la propiedad Kind del valor DateTime devuelto se establece en DateTimeKind.Local.Unless the AdjustToUniversal flag is present, the Kind property of the returned DateTime value is set to DateTimeKind.Local.
AssumeUniversal Especifica que si s no tiene información de zona horaria, se presupone UTC.Specifies that if s lacks any time zone information, UTC is assumed. A menos que esté presente la marca AdjustToUniversal, el método convierte el valor DateTime devuelto de la hora UTC a la hora local y establece su propiedad Kind en DateTimeKind.Local.Unless the AdjustToUniversal flag is present, the method converts the returned DateTime value from UTC to local time and sets its Kind property to DateTimeKind.Local.
None Aunque es válido, se omite este valor.Although valid, this value is ignored.
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 DateTime que representa una hora local con su propiedad Kind establecida en DateTimeKind.Local.For strings that contain time zone information, tries to prevent the conversion of a date and time string to a DateTime value that represents a local time with its Kind property set to DateTimeKind.Local. Normalmente, este tipo de cadena se crea llamando al método DateTime.ToString(String) y usando el especificador de formato estándar "o", "r" u "u".Typically, such a string is created by calling the DateTime.ToString(String) method and by using the "o", "r", or "u" standard format specifier.

El valor devuelto y DateTime. KindThe return value and DateTime.Kind

Las sobrecargas DateTime.Parse devuelven un valor DateTime cuya propiedad Kind incluye información de zona horaria.The DateTime.Parse overloads return a DateTime value whose Kind property includes time zone information. Puede indicar que la hora es:It can indicate that the time is:

Por lo general, el método Parse devuelve un objeto DateTime cuya propiedad Kind es DateTimeKind.Unspecified.Generally, the Parse method returns a DateTime object whose Kind property is 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 manera diferente, en función de los valores de los parámetros s y styles:However, the Parse method may also perform time zone conversion and set the value of the Kind property differently, depending on the values of the s and styles parameters:

SiIf Conversión de zona horariaTime zone conversion Kind (propiedad)Kind property
s contiene información de zona horaria.s contains time zone information. La fecha y la hora se convierten a la hora de la zona horaria local.The date and time is converted to the time in the local time zone. DateTimeKind.Local
s contiene información de zona horaria y styles incluye la marca AdjustToUniversal.s contains time zone information, and styles includes the AdjustToUniversal flag. La fecha y la hora se convierten en hora universal coordinada (UTC).The date and time is converted to Coordinated Universal Time (UTC). DateTimeKind.Utc
s contiene el designador de zona horaria Z o GMT y styles incluye la marca RoundtripKind.s contains the Z or GMT time zone designator, and styles includes the RoundtripKind flag. La fecha y la hora se interpretan como UTC.The date and time are interpreted as UTC. DateTimeKind.Utc

En el ejemplo siguiente se convierten cadenas de fecha que contienen información de zona horaria en la hora de la zona horaria local:The following example converts date strings that contain time zone information to the time in the local time zone:

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                                             
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 la propiedad Kind de una fecha y hora durante una operación de formato y análisis mediante el uso de la marca DateTimeStyles.RoundtripKind.You can also preserve the value of a date and time's Kind property during a formatting and parsing operation by using the DateTimeStyles.RoundtripKind flag. En el ejemplo siguiente se muestra cómo la marca RoundtripKind afecta a la operación de análisis en valores DateTime que se convierten en cadenas mediante el especificador de formato "o", "r" o "u".The following example illustrates how the RoundtripKind flag affects the parsing operation on DateTime values that are converted to strings by using the "o", "r", or "u" format specifier.

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

Convierte la representación de cadena para una fecha y hora en su DateTime equivalente, usando las convenciones de la referencia cultural de subproceso especificada.Converts the string representation of a date and time to its DateTime equivalent by using the conventions of the current thread culture.

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 van a convertir.A string that contains a date and time to convert. Vea The string to parse (La cadena que se debe analizar) para obtener más información.See The string to parse for more information.

Devoluciones

Objeto equivalente a la fecha y hora contenidas en s.An object that is equivalent to the date and time contained in s.

Excepciones

s es null.s is null.

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

Comentarios

Si s contiene información de zona horaria, este método devuelve un valor DateTime cuya propiedad Kind es DateTimeKind.Local y convierte la fecha y la hora de s a la hora local.If s contains time zone information, this method returns a DateTime value whose Kind property is DateTimeKind.Local and converts the date and time in s to local time. De lo contrario, no realiza ninguna conversión de zona horaria y devuelve un valor DateTime cuya propiedad Kind es DateTimeKind.Unspecified.Otherwise, it performs no time zone conversion and returns a DateTime value whose Kind property is DateTimeKind.Unspecified.

Esta sobrecarga intenta analizar s mediante las convenciones de formato de la referencia cultural actual.This overload attempts to parse s by using the formatting conventions of the current culture. La referencia cultural actual se indica mediante la propiedad CurrentCulture.The current culture is indicated by the CurrentCulture property. Para analizar una cadena mediante las convenciones de formato de una referencia cultural concreta, llame a las sobrecargas Parse(String, IFormatProvider) o Parse(String, IFormatProvider, DateTimeStyles).To parse a string using the formatting conventions of a specific culture, call the Parse(String, IFormatProvider) or the Parse(String, IFormatProvider, DateTimeStyles) overloads.

Esta sobrecarga intenta analizar s mediante el estilo DateTimeStyles.AllowWhiteSpaces.This overload attempts to parse s by using DateTimeStyles.AllowWhiteSpaces style.

EjemploExample

En el ejemplo siguiente se analiza la representación de cadena de varios valores de fecha y hora por:The following example parses the string representation of several date and time values by:

  • Usar el proveedor de formato predeterminado, que proporciona las convenciones de formato de la referencia cultural del subproceso actual del equipo utilizado para generar la salida de ejemplo.Using the default format provider, which provides the formatting conventions of the current thread culture of the computer used to produce the example output. La salida de este ejemplo refleja las convenciones de formato de la referencia cultural en-US.The output from this example reflects the formatting conventions of the en-US culture.

  • Usar el valor de estilo predeterminado, que es AllowWhiteSpaces.Using the default style value, which is AllowWhiteSpaces.

Controla la excepción FormatException que se produce cuando el método intenta analizar la representación de cadena de una fecha y hora usando algunas otras convenciones de formato de la referencia cultural.It handles the FormatException exception that is thrown when the method tries to parse the string representation of a date and time by using some other culture's formatting conventions. También se muestra cómo analizar correctamente un valor de fecha y hora que no utiliza las convenciones de formato de la referencia cultural del subproceso actual.It also shows how to successfully parse a date and time value that does not use the formatting conventions of the current thread culture.

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

Consulte también:

Parse(String, IFormatProvider)

Convierte la representación de cadena para una fecha y hora en su DateTime equivalente, usando la información de formato específica de la referencia cultural especificada.Converts the string representation of a date and time to its DateTime equivalent by using culture-specific format information.

public:
 static DateTime Parse(System::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 van a convertir.A string that contains a date and time to convert. Vea The string to parse (La cadena que se debe analizar) para obtener más información.See The string to parse for more information.

provider
IFormatProvider

Objeto que proporciona información de formato específica de la referencia cultural acerca de s.An object that supplies culture-specific format information about s. Vea Parsing and cultural conventions (Convenciones culturales y análisis).See Parsing and cultural conventions

Devoluciones

Objeto equivalente a la fecha y hora contenidas en s, tal como especifica provider.An object that is equivalent to the date and time contained in s as specified by provider.

Excepciones

s es null.s is null.

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

Comentarios

Si s contiene información de zona horaria, este método devuelve un valor DateTime cuya propiedad Kind es DateTimeKind.Local y convierte la fecha y la hora de s a la hora local.If s contains time zone information, this method returns a DateTime value whose Kind property is DateTimeKind.Local and converts the date and time in s to local time. De lo contrario, no realiza ninguna conversión de zona horaria y devuelve un valor DateTime cuya propiedad Kind es DateTimeKind.Unspecified.Otherwise, it performs no time zone conversion and returns a DateTime value whose Kind property is DateTimeKind.Unspecified.

Esta sobrecarga intenta analizar s mediante el estilo DateTimeStyles.AllowWhiteSpaces.This overload attempts to parse s by using the DateTimeStyles.AllowWhiteSpaces style.

EjemploExample

En el ejemplo siguiente se analiza una matriz de cadenas de fecha mediante las convenciones de las referencias culturales en-US, fr-FR y de-DE.The following example parses an array of date strings by using the conventions of the en-US, fr-FR, and de-DE cultures. Muestra que las representaciones de cadena de una sola fecha se pueden interpretar de forma diferente en distintas referencias culturales.It demonstrates that the string representations of a single date can be interpreted differently across different cultures.

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

Consulte también:

Parse(ReadOnlySpan<Char>, IFormatProvider, DateTimeStyles)

Convierte un intervalo de memoria que contiene una representación de cadena de una fecha y hora en el objeto DateTime equivalente mediante la información de formato específica de la referencia cultural y un estilo de formato especificados.Converts a memory span that contains string representation of a date and time to its DateTime equivalent by using culture-specific format information and a formatting style.

public static DateTime Parse (ReadOnlySpan<char> s, IFormatProvider provider = null, 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 = null, Optional styles As DateTimeStyles = System.Globalization.DateTimeStyles.None) As DateTime

Parámetros

s
ReadOnlySpan<Char>

El intervalo de memoria que contiene la cadena que se analizará.The memory span that contains the string to parse. Vea The string to parse (La cadena que se debe analizar) para obtener más información.See The string to parse for more information.

provider
IFormatProvider

Objeto que proporciona información de formato específica de la referencia cultural acerca de s.An object that supplies culture-specific format information about s. Vea Parsing and cultural conventions (Convenciones culturales y análisis).See Parsing and cultural conventions

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 define cómo interpretar la fecha analizada respecto a la zona horaria actual o la fecha actual.A bitwise combination of the enumeration values that indicates the style elements that can be present in s for the parse operation to succeed, and that defines how to interpret the parsed date in relation to the current time zone or the current date. Un valor que se especifica de forma habitual es None.A typical value to specify is None.

Devoluciones

Objeto equivalente a la fecha y hora contenidas en s, tal como especifican provider y styles.An object that is equivalent to the date and time contained in s, as specified by provider and styles.

Excepciones

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

styles contiene una combinación no válida de valores DateTimeStyles.styles contains an invalid combination of DateTimeStyles values. Por ejemplo, AssumeLocal y AssumeUniversal.For example, both AssumeLocal and AssumeUniversal.

Parse(String, IFormatProvider, DateTimeStyles)

Convierte la representación de cadena de una fecha y hora en el objeto DateTime equivalente, usando la información de formato específica de la referencia cultural y un estilo de formato especificados.Converts the string representation of a date and time to its DateTime equivalent by using culture-specific format information and a formatting style.

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);
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 van a convertir.A string that contains a date and time to convert. Vea The string to parse (La cadena que se debe analizar) para obtener más información.See The string to parse for more information.

provider
IFormatProvider

Objeto que proporciona información de formato específica de la referencia cultural acerca de s.An object that supplies culture-specific formatting information about s. Vea Parsing and cultural conventions (Convenciones culturales y análisis).See Parsing and cultural conventions

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 define cómo interpretar la fecha analizada respecto a la zona horaria actual o la fecha actual.A bitwise combination of the enumeration values that indicates the style elements that can be present in s for the parse operation to succeed, and that defines how to interpret the parsed date in relation to the current time zone or the current date. Un valor que se especifica de forma habitual es None.A typical value to specify is None.

Devoluciones

Objeto equivalente a la fecha y hora contenidas en s, tal como especifican provider y styles.An object that is equivalent to the date and time contained in s, as specified by provider and styles.

Excepciones

s es null.s is null.

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

styles contiene una combinación no válida de valores DateTimeStyles.styles contains an invalid combination of DateTimeStyles values. Por ejemplo, AssumeLocal y AssumeUniversal.For example, both AssumeLocal and AssumeUniversal.

Comentarios

Esta sobrecarga del método convierte la fecha y hora en s y establece la propiedad Kind del valor DateTime devuelto de la manera siguiente:This method overload converts the date and time in s and sets the Kind property of the returned DateTime value as follows:

SiIf Conversión de zona horariaTime zone conversion Kind (propiedad)Kind property
s no contiene información de zona horaria.s contains no time zone information. Ninguno.None. DateTimeKind.Unspecified
s contiene información de zona horaria.s contains time zone information. A la hora de la zona horaria localTo the time in the local time zone DateTimeKind.Local
s contiene información de zona horaria y styles incluye la marca DateTimeStyles.AdjustToUniversal.s contains time zone information, and styles includes the DateTimeStyles.AdjustToUniversal flag. A la hora universal coordinada (UTC)To Coordinated Universal Time (UTC) DateTimeKind.Utc
s contiene el designador de zona horaria Z o GMT y styles incluye DateTimeStyles.RoundtripKind.s contains the Z or GMT time zone designator, and styles includes the DateTimeStyles.RoundtripKind. Ninguno.None. DateTimeKind.Utc

EjemploExample

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 @no__t 2 resultantes.The following example demonstrates the Parse(String, IFormatProvider, DateTimeStyles) method and displays the value of the Kind property of the resulting DateTime values.

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

Consulte también:

Se aplica a