DateTime.Parse DateTime.Parse DateTime.Parse DateTime.Parse Method

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) Parse(String) Parse(String) 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) Parse(String, IFormatProvider) Parse(String, IFormatProvider) 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) Parse(ReadOnlySpan<Char>, IFormatProvider, DateTimeStyles) 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) Parse(String, IFormatProvider, DateTimeStyles) Parse(String, IFormatProvider, DateTimeStyles) 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

Ver numerosos ejemplos que llaman a la DateTime.Parse método se intercalan en la comentarios sección de este artículo y en la documentación de la persona DateTime.Parse sobrecargas.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

Los 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.The 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 DateTime.Parse ejemplos, que se incluyen en un proyecto .NET Core 2.0 para C# y un proyecto .NET Core 2.0 para Visual Basic, desde el dotnet / repositorio de GitHub de ejemplos.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:

¿Qué método se debe llamar?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. Parse(String, IFormatProvider) sobrecargar (vea análisis y las convenciones culturales)Parse(String, IFormatProvider) overload (see Parsing and Cultural Conventions)
Analizar una cadena de fecha y hora con elementos de estilo especial (como espacios en blanco o sin espacios 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
Analizar una cadena de fecha y hora en 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
Analizar una cadena de fecha y hora y realizar 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 control de 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" u "r" para el ToString(String) método y llamar a la Parse(String, IFormatProvider, DateTimeStyles) sobrecargar 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
Analizar una cadena de fecha y hora en un formato fijo a través de límites de máquina (y posiblemente culturales).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

La cadena para analizarThe string to parse

El Parse método intenta convertir la representación de cadena de un valor de fecha y hora en su DateTime equivalente.The Parse method tries to convert the string representation of a date and time value to its DateTime equivalent. Se intenta analizar la cadena de entrada completamente sin producir una FormatException excepción.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 porque el formato de cadena no reconocido, la Parse método produce una FormatException, mientras que el TryParse devuelve del método false.If the parsing operation fails because of an unrecognized string format, the Parse method throws a FormatException, whereas the TryParse method returns false. Como control de excepciones puede ser costoso, debe usar Parse cuando se espera que la operación de análisis se realizó 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 están probable que análisis de errores, especialmente porque un origen de entrada no es de confianza, o tener valores predeterminados razonables para sustituir las 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 a analizarse puede tener cualquiera de las siguientes formas:The string to be parsed can take any of the following forms:

  • Una cadena con una componente de fecha y hora.A string with a date and a time component.

  • Una cadena con una fecha, pero ningún componente de tiempo.A string with a date but no time component. Si el componente de hora no está presente, el método supone 12:00 de la noche.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 según el Calendar.TwoDigitYearMax de calendario actual de la referencia cultural actual o el calendario actual de la referencia cultural especificada (si usa una sobrecarga con un valor no null provider argumento).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 sólo el mes y año, pero ningún componente de día.A string with a date component that includes only the month and the year but no day component. El método supone que el primer día del mes.The method assumes the first day of the month.

  • Una cadena con un componente de fecha que incluye sólo el mes y día, pero no hay ningún componente de año.A string with a date component that includes only the month and the day but no year component. El método supone que el año actual.The method assumes the current year.

  • Una cadena con un tiempo, pero ningún componente de fecha.A string with a time but no date component. El método supone que la fecha actual, a menos que llame a la Parse(String, IFormatProvider, DateTimeStyles) sobrecarga e incluyen DateTimeStyles.NoCurrentDateDefault en el styles argumento, en el que caso, el método supone 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 tiempo que incluye solo la hora y un designador AM/PM, con ningún 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 supone que la fecha actual y una hora con ningún 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 Parse(String, IFormatProvider, DateTimeStyles) sobrecarga e incluyen DateTimeStyles.NoCurrentDateDefault en el styles argumento, en el que caso, el método supone 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 en 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.0000000Z""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 de noviembre de 2008 19:35:00 hora peninsular española""Sat, 01 Nov 2008 19:35:00 GMT"

  • Una cadena que incluye la fecha y hora junto con 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"

El ejemplo siguiente analiza las cadenas en cada uno de estos formatos mediante el uso de 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 usado por el método de análisis (consulte convenciones culturales y análisis), el Parse método 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 de un año bisiesto, el método produce una FormatException.If the input string represents a leap day in a non-leap year, the method throws a FormatException.

Dado que el Parse método intenta analizar la representación de cadena de una fecha y hora mediante el uso de las reglas de formato de la actual o una referencia cultural especificada, al intentar analizar una cadena entre referencias culturales diferentes puede producir un error.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 una fecha concreta y el formato de hora entre distintas configuraciones regionales, use una de las sobrecargas de los DateTime.ParseExact método 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.

Convenciones culturales y análisisParsing and cultural conventions

Todas las sobrecargas de la Parse método afectan a la referencia cultural a menos que la cadena que se puede analizar (representada mediante s en la tabla siguiente) se ajusta al patrón de 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 DateTimeFormatInfo objeto derivado como sigue: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 se llama aIf you call Y provider esAnd provider is Se deriva de la información de formatoFormatting information is derived from
Parse(String) - La referencia cultural del subproceso actual (DateTimeFormatInfo.CurrentInfo propiedad)The current thread culture (DateTimeFormatInfo.CurrentInfo property)
Parse(String, IFormatProvider) o Parse(String, IFormatProvider, DateTimeStyles)Parse(String, IFormatProvider) or Parse(String, IFormatProvider, DateTimeStyles) Un DateTimeFormatInfo objetoa DateTimeFormatInfo object Especificado DateTimeFormatInfo objetoThe specified DateTimeFormatInfo object
Parse(String, IFormatProvider) o Parse(String, IFormatProvider, DateTimeStyles)Parse(String, IFormatProvider) or Parse(String, IFormatProvider, DateTimeStyles) null La referencia cultural del subproceso actual (DateTimeFormatInfo.CurrentInfo propiedad)The current thread culture (DateTimeFormatInfo.CurrentInfo property)
Parse(String, IFormatProvider) o Parse(String, IFormatProvider, DateTimeStyles)Parse(String, IFormatProvider) or Parse(String, IFormatProvider, DateTimeStyles) Un CultureInfo objetoa 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) Custom IFormatProvider implementaciónCustom IFormatProvider implementation El método IFormatProvider.GetFormatThe IFormatProvider.GetFormat method

Cuando la información de formato se deriva un DateTimeFormatInfo objeto, el DateTimeFormatInfo.Calendar propiedad 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 se analiza una cadena de fecha y hora mediante el uso de un DateTimeFormatInfo objeto con configuraciones personalizadas que son diferentes de las de una referencia cultural estándar, use el ParseExact método en lugar de la Parse método 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 hora y fecha no estándar pueden ser complicada y difícil de analizar.A non-standard date and time string can be complicated and difficult to parse. El Parse método intenta analizar una cadena con varios modelos de análisis implícito, que podría producir un error.The Parse method tries to parse a string with several implicit parse patterns, all of which might fail. En cambio, el ParseExact método requiere que se designe explícitamente uno o varios modelos de análisis exacto que es probables que se realice correctamente.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 y dinámico de datos" en el DateTimeFormatInfo tema.For more information, see the "DateTimeFormatInfo and Dynamic Data" section in the DateTimeFormatInfo topic.

Importante

Tenga en cuenta que las convenciones de formato para una determinada referencia cultural son dinámicas y pueden estar sujetos a cambio.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 de forma predeterminada (actual) o que especifican un IFormatProvider objeto que representa una referencia cultural que no sea la referencia cultural invariable inesperadamente puede producir un error si se produce alguna de las siguientes acciones: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 ha cambiado entre versiones principales o secundarias de .NET Framework o como resultado de una actualización de la versión existente de .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 otro o sesiones.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 para analizar cadenas de fecha y hora que están asociadas con los cambios en los datos de referencia culturales, puede analizar cadenas de fecha y hora mediante el uso de la referencia cultural invariable, o bien puede llamar el ParseExact o TryParseExact método y especificar el formato exacto de la cadena que se puede 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 deserializar los datos de fecha y hora, puede usar las convenciones de formato de la referencia cultural invariable, o puede serializar y deserializar la DateTime valor 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, consulte la sección "datos de referencia cultural dinámica" en el CultureInfo tema y los "valores de fecha y hora de persistencia" sección en el DateTime tema.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

Todos los Parse sobrecargas omitir los caracteres de espacio en blanco iniciales, internas o finales en la cadena de entrada (representada 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 hora pueden ir entre corchetes con un par de caracteres de signo de número ("#", u+0023) iniciales y finales y pueden terminar con uno o más caracteres NULL (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, el Parse(String, IFormatProvider, DateTimeStyles) sobrecarga tiene un styles parámetro que consta de uno o varios miembros de la DateTimeStyles enumeración.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 s deben interpretarse y cómo se 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 DateTimeStyles miembro en la operación de análisis.The following table describes the effect of each DateTimeStyles member on the parse operation.

Miembro DateTimeStylesDateTimeStyles member Efecto sobre la conversiónEffect on conversion
AdjustToUniversal Analiza s y, si es necesario, lo convierte a UTC, como sigue:Parses s and, if necessary, converts it to UTC, as follows:

-If s incluye un ajuste de zona horaria, o si s no contiene ninguna información de zona horaria, pero styles incluye la AssumeLocal marca, el método analiza la cadena de llamadas ToUniversalTime para convertir el valor devuelto DateTime valor UTC y establece la Kind propiedad 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.
-If s indica que representa la hora UTC, o si s no contiene información de zona horaria, pero styles incluye la AssumeUniversal marca, el método analiza la cadena, no realiza ninguna conversión de zona horaria en el valor devuelto DateTime valor y establece el Kind propiedad 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. Espacio en blanco interno siempre se permite 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. Espacio en blanco inicial siempre se permite 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. Espacio en blanco final siempre se permite 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, internos y los espacios en blanco finales.Specifies that s may contain leading, inner, and trailing white spaces. Éste es el comportamiento predeterminado.This is the default behavior. Se puede reemplazar proporcionando más restrictivo DateTimeStyles valor de enumeración como None.It cannot be overridden by supplying a more restrictive DateTimeStyles enumeration value such as None.
AssumeLocal Especifica que si s falta, se supone que cualquier información de zona horaria, hora local.Specifies that if s lacks any time zone information, local time is assumed. A menos que el AdjustToUniversal marcador está presente, el Kind propiedad devuelto del DateTime valor 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 falta, se supone que cualquier información de zona horaria UTC.Specifies that if s lacks any time zone information, UTC is assumed. A menos que el AdjustToUniversal marca está presente, el método convierte el valor devuelto DateTime valor a la hora UTC en hora local y establece su Kind propiedad 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 sea válido, este valor se omite.Although valid, this value is ignored.
RoundtripKind Para las cadenas que contienen información de zona horaria, intenta evitar la conversión de una cadena de fecha y hora en un DateTime valor que representa una hora local con su Kind propiedad 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, se crea este tipo de cadena mediante una llamada a la DateTime.ToString(String) método y con el especificador de formato estándar "o", "r" o "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

El DateTime.Parse sobrecargas devuelven un DateTime cuyo valor Kind propiedad incluye la 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 Parse método devuelve un DateTime cuyo Kind propiedad es DateTimeKind.Unspecified.Generally, the Parse method returns a DateTime object whose Kind property is DateTimeKind.Unspecified. Sin embargo, el Parse método también puede realizar la conversión de zona horaria y establezca el valor de la Kind propiedad diferente, según los valores de la s y styles parámetros: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 hora se convierte a la hora en 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 AdjustToUniversal marca.s contains time zone information, and styles includes the AdjustToUniversal flag. La fecha y hora se convierte 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 RoundtripKind marca.s contains the Z or GMT time zone designator, and styles includes the RoundtripKind flag. La fecha y hora se interpretan como hora UTC.The date and time are interpreted as UTC. DateTimeKind.Utc

El ejemplo siguiente convierte las cadenas de fecha que contienen información de zona horaria a la hora en 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 una fecha y del hora Kind propiedad durante la operación de análisis mediante el uso y un formato el DateTimeStyles.RoundtripKind marca.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. El ejemplo siguiente se muestra cómo el RoundtripKind marca afecta a la operación de análisis en DateTime valores 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) Parse(String) Parse(String) 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 String String String

Cadena que contiene una fecha y hora que se van a convertir.A string that contains a date and time to convert. 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 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 DateTime cuyo valor Kind propiedad es DateTimeKind.Local y convierte la fecha y hora en 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. En caso contrario, realiza ninguna conversión de zona horaria y se devuelve un DateTime cuyo valor Kind propiedad 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 utilizando 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 el CurrentCulture propiedad.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 la Parse(String, IFormatProvider) o Parse(String, IFormatProvider, DateTimeStyles) sobrecargas.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 utilizando DateTimeStyles.AllowWhiteSpaces estilo.This overload attempts to parse s by using DateTimeStyles.AllowWhiteSpaces style.

EjemploExample

El ejemplo siguiente 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:

  • Con el proveedor de formato predeterminado, que proporciona las convenciones de formato de la referencia cultural del subproceso actual del equipo usado 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. El resultado 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.

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

Controla el FormatException las convenciones de formato de excepción que se produce cuando el método intenta analizar la representación de cadena de una fecha y hora mediante el uso de alguna otra 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 muestra cómo analizar correctamente un valor de fecha y hora que no usa 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) Parse(String, IFormatProvider) Parse(String, IFormatProvider) 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 String String String

Cadena que contiene una fecha y hora que se van a convertir.A string that contains a date and time to convert. 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 IFormatProvider IFormatProvider 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 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 DateTime cuyo valor Kind propiedad es DateTimeKind.Local y convierte la fecha y hora en 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. En caso contrario, realiza ninguna conversión de zona horaria y se devuelve un DateTime cuyo valor Kind propiedad 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 utilizando el DateTimeStyles.AllowWhiteSpaces estilo.This overload attempts to parse s by using the DateTimeStyles.AllowWhiteSpaces style.

EjemploExample

El ejemplo siguiente analiza una matriz de cadenas de fecha mediante las convenciones de en-US, fr-FR y referencias culturales 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 pueden interpretarse de manera distinta en diferentes 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) Parse(ReadOnlySpan<Char>, IFormatProvider, DateTimeStyles) 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 IFormatProvider IFormatProvider 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 DateTimeStyles DateTimeStyles 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) Parse(String, IFormatProvider, DateTimeStyles) Parse(String, IFormatProvider, DateTimeStyles) 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 String String String

Cadena que contiene una fecha y hora que se van a convertir.A string that contains a date and time to convert. 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 IFormatProvider IFormatProvider 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 DateTimeStyles DateTimeStyles 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.

Comentarios

Esta sobrecarga del método convierte la fecha y hora en s y establece el Kind propiedad devuelto del DateTime valor como sigue: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 ninguna 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. En la hora de la zona horaria localTo the time in the local time zone DateTimeKind.Local
s contiene información de zona horaria, y "estilos incluye el DateTimeStyles.AdjustToUniversal marca.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 la DateTimeStyles.RoundtripKind.s contains the Z or GMT time zone designator, and styles includes the DateTimeStyles.RoundtripKind. Ninguno.None. Utc

EjemploExample

En el ejemplo siguiente se muestra el Parse(String, IFormatProvider, DateTimeStyles) método y muestra el valor de la Kind propiedad del resultante DateTime valores.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