Este artículo se tradujo automáticamente. Para ver el artículo en inglés, active la casilla Inglés. Además, puede mostrar el texto en inglés en una ventana emergente si mueve el puntero del mouse sobre el texto.
Traducción
Inglés

Método DateTime.Parse

 

Publicado: octubre de 2016

Convierte la representación de cadena de una fecha y hora en el objeto DateTime equivalente.

Espacio de nombres:   System
Ensamblado:  mscorlib (en mscorlib.dll)

NombreDescripción
System_CAPS_pubmethodSystem_CAPS_staticParse(String)

Convierte la representación de cadena de una fecha y hora en el objeto DateTime equivalente.

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

System_CAPS_pubmethodSystem_CAPS_staticParse(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 el estilo de formato especificados.

Para obtener orientación adicional acerca de cómo elegir una sobrecarga, consulte qué método se debe llamar?

DateTime.Parse(String s)

Para realizar la conversión, usa las convenciones de formato de la referencia cultural del subproceso actual e interpreta la cadena basándose en el DateTimeStyles.AllowWhiteSpaces marca de estilo (ejemplo).

DateTime.Parse(String s, IFormatProvider provider)

Para realizar la conversión, usa las convenciones de formato de una referencia cultural especificada e interpreta la cadena basándose en el DateTimeStyles.AllowWhiteSpaces marca de estilo (ejemplo).

DateTime.Parse(String s, IFormatProvider provider, DateTypeStyles styles)

Para realizar la conversión, usa las convenciones de formato de una referencia cultural especificada e interpreta la cadena basándose en los indicadores de estilo especificado (ejemplo).

Se trata de una lista completa de parámetros para el Parse (método). Para los parámetros utilizados por cada sobrecarga, vea la sintaxis de sobrecarga anterior.

Parámetro

Tipo

Descripción

s

String

Cadena que contiene la fecha y hora que se va a convertir. Consulte para analizar la cadena de.

Valor predeterminado: ninguno (parámetro se utiliza en todas las sobrecargas)

provider

IFormatProvider

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

Valor predeterminado: CultureInfo.CurrentCulture

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. Un valor que se especifica de forma habitual es DateTimeStyles.None. Consulte elementos de análisis y el estilo.

Valor predeterminado: DateTimeStyles.AllowWhiteSpaces

Tipo: DateTime
un objeto que es equivalente a la fecha y hora contenidas en s.

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

Si

Conversión de zona horaria

Kind (propiedad)

s contiene información de zona horaria.

La fecha y hora se convierte a la hora en la zona horaria local.

DateTimeKind.Local

s contiene información de zona horaria, y styles incluye la AdjustToUniversalmarca.

La fecha y hora se convierte a la hora Universal coordinada (UTC).

DateTimeKind.Utc

s contiene el designador de zona horaria Z o GMT, y styles incluye la RoundtripKind marca.

La fecha y hora se interpretan como 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:

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 {0} to {1} time {2}", 
                           dateString, 
                           convertedDate.Kind.ToString(), 
                           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                                             

También puede conservar el valor de fecha y del hora Kind propiedad durante un formato y análisis operación utilizando la DateTimeStyles.RoundtripKind marca. En 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".

   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: {0} {1} time.", 
                        roundtripDate, roundtripDate.Kind);                                          
      DateTime noRoundtripDate = DateTime.Parse(formattedDate, null, 
                                                DateTimeStyles.None);
      Console.WriteLine("   Without RoundtripKind flag: {0} {1} time.", 
                         noRoundtripDate, noRoundtripDate.Kind);                                          
   }         
// 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.      

Excepción

Condición

Iniciada por

ArgumentNullException

El valor de s es null.

Todas las sobrecargas

FormatException

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

Todas las sobrecargas

ArgumentException

styles contiene una combinación no válida de DateTimeStyles valores (por ejemplo, incluye ambos AssumeLocal y AssumeUniversal).

Parse(String, IFormatProvider, DateTimeStyles)

TO

Llame a

Analizar una cadena de fecha y hora utilizando las convenciones de la referencia cultural actual.

Parse(String) sobrecarga

Analizar una cadena de fecha y hora utilizando las convenciones de una referencia cultural concreta.

Parse(String, IFormatProvider)sobrecargar (vea análisis y las convenciones culturales)

Analizar una cadena de fecha y hora con los elementos de estilo especiales (como espacios en blanco o sin espacios en blanco).

Parse(String, IFormatProvider, DateTimeStyles) sobrecarga

Analizar una cadena de fecha y hora y realizar una conversión a UTC u hora local.

Parse(String, IFormatProvider, DateTimeStyles) sobrecarga

Analizar una cadena de fecha y hora sin control de excepciones.

Método DateTime.TryParse

Restaurar (ida y vuelta) un valor de fecha y hora que se crea una operación de formato.

Pase la cadena de formato estándar "o" u "r" para el ToString(String) método y llamar a la Parse(String, IFormatProvider, DateTimeStyles)sobrecarga con DateTimeStyles.RoundtripKind

Analizar una cadena de fecha y hora en un formato fijo a través de límites de equipo (y posiblemente culturales).

DateTime.ParseExact o DateTime.TryParseExact (método)

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

System_CAPS_importantImportante

Dado que la representación de cadena de una fecha y hora debe cumplir un modelo reconocido, siempre debe usar el control de excepciones al llamar a la Parse método para analizar la entrada del usuario. Si no desea controlar las excepciones, puede llamar a la DateTime.TryParse método para analizar la cadena de fecha y hora; este método devuelve un valor que indica si la operación de análisis se realizó correctamente.

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

  • Una cadena con una componente de fecha y hora.

  • Una cadena con una fecha pero sin componente de hora. Si el componente de hora no está presente, el método supone 12:00 de la noche. Si el componente de fecha con 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 se utiliza una sobrecarga con un valor no nulo provider argumento).

  • Una cadena con una hora pero sin componente de fecha. El método supone la fecha actual a menos que llame a la Parse(String, IFormatProvider, DateTimeStyles) sobrecarga e incluir DateTimeStyles.NoCurrentDateDefaulten la styles parámetro, en el que caso, el método supone el 1 de enero, 0001.

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

    2008-11-01T19:35:00.0000000Z
    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:

    El sábado, 01 de noviembre de 2008 19:35:00 GMT

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

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

Si s es la representación de cadena de un día bisiesto de un año bisiesto en el calendario utilizado por el método de análisis (consulte convenciones culturales y análisis), el Parse método analiza s correctamente. Si s es la representación de cadena de un día bisiesto de un no año bisiesto, el método inicia una FormatException excepción.

Dado que el Parse método intenta analizar la representación de cadena de una fecha y hora utilizando las reglas de formato de la cultura actual o especificada, si se intenta analizar una cadena entre referencias culturales diferentes puede producir un error. Para analizar una fecha concreta y el formato de hora entre diferentes configuraciones regionales, use una de las sobrecargas de la DateTime.ParseExact (método) y proporcione un especificador de formato.

Todas las sobrecargas de la Parse (método) son dependientes de la referencia cultural a menos que la cadena que se va a analizar se ajusta al patrón de ISO 8601. El análisis utiliza operación información de formato en un DateTimeFormatInfo objeto derivado como sigue:

Si se llama a

Y provider es

Información de formato se deriva

Parse(String)

-

La referencia cultural del subproceso actual (DateTimeFormatInfo.CurrentInfo propiedad)

Parse(String, IFormatProvider) o Parse(String, IFormatProvider, DateTimeStyles)

Objeto DateTimeFormatInfo

Especificado DateTimeFormatInfo objeto

Parse(String, IFormatProvider) o Parse(String, IFormatProvider, DateTimeStyles)

null

La referencia cultural del subproceso actual (DateTimeFormatInfo.CurrentInfo propiedad)

Parse(String, IFormatProvider) o Parse(String, IFormatProvider, DateTimeStyles)

Objeto CultureInfo

La propiedad CultureInfo.DateTimeFormat

Parse(String, IFormatProvider) o Parse(String, IFormatProvider, DateTimeStyles)

Personalizado IFormatProvider implementación

El método IFormatProvider.GetFormat

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

Si se analiza una cadena de fecha y hora mediante el uso de un DateTimeFormatInfo objeto con configuraciones personalizadas que son diferentes de los de una referencia cultural estándar, utilice la ParseExact método en lugar de laParse método para mejorar las posibilidades de una conversión correcta. Una cadena de hora y fecha no estándar pueden ser complicada y difícil de analizar. ElParse método intenta analizar una cadena con modelos implícitos de análisis, todos los cuales se pueden producir un error. En cambio, el ParseExact método requiere que se designen explícitamente uno o varios modelos exactos de análisis que se lleven a cabo correctamente. Para obtener más información, consulte la sección "DateTimeFormatInfo y datos dinámicos" en el DateTimeFormatInfo tema.

System_CAPS_importantImportante

Tenga en cuenta que las convenciones de formato para una determinada referencia cultural son dinámicas y pueden estar sujetos a cambios. Esto significa que las operaciones de análisis que dependen de las convenciones de formato de la referencia cultural (actual) de forma predeterminada o que especifican una IFormatProvider objeto que representa una referencia cultural distinta de la referencia cultural invariable inesperadamente puede fallar si se produce alguno de los siguientes:

  • Los datos específicos de la referencia cultural cambió entre las versiones principales o secundarias de .NET Framework o como resultado de una actualización de la versión existente de .NET Framework.

  • Los datos específicos de la referencia cultural reflejan las preferencias del usuario, que pueden variar de un equipo a otro o de una sesión a otra.

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

Para evitar las dificultades para analizar cadenas de fecha y hora que están asociadas con los cambios de datos de referencia culturales, puede analizar cadenas de fecha y hora utilizando la referencia cultural invariable, o puede llamar a la ParseExacto TryParseExact (método) y especifique el formato exacto de la cadena que se va a analizar. Si está serializando y deserializingdate y la hora de los datos, puede utilizar las convenciones de formato de la referencia cultural invariable, o puede serializar y deserializethe DateTime valor en formato binario.

Para obtener más información, consulte la sección "datos de referencia cultural dinámico" en la CultureInfo sección tema y los valores de fecha y hora de persistentes de"" en el DateTime tema.

Todos los Parsesobrecargas omitirán los caracteres de espacio en blanco iniciales, interiores o finales en s. La fecha y hora pueden ir entre corchetes con un par de iniciales y finales de los caracteres de signo de número ("#", u+0023) y pueden terminar con uno o más caracteres NULL (u+0000).

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

Miembro DateTimeStyles

Efecto en la conversión

AdjustToUniversal

Analiza s y, si es necesario, lo convierte a UTC, como sigue:

  • Si s incluye un desplazamiento 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 en hora UTC y establece la Kind propiedad DateTimeKind.Utc.

  • Si 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 se realiza ninguna conversión de zona horaria en el valor devuelto DateTime valor y establece el Kind propiedad DateTimeKind.Utc.

  • En los demás casos, la marca no tiene ningún efecto.

AllowInnerWhite

Este valor se omite. Siempre se permite el espacio en blanco interno en los elementos de fecha y hora de s.

AllowLeadingWhite

Este valor se omite. Espacio en blanco inicial siempre se permite en los elementos de fecha y hora de s.

AllowTrailingWhite

Este valor se omite. Espacio en blanco final siempre se permite en los elementos de fecha y hora de s.

AllowWhiteSpaces

Especifica que s puede contener, internos y finales espacios en blanco. Éste es el comportamiento predeterminado. No se puede invalidar proporcionando más restrictiva DateTimeStyles valor de enumeración como None.

AssumeLocal

Especifica que si s falta se supone que cualquier información de zona horaria, hora local. A menos que el AdjustToUniversal marca está presente, el Kind propiedad de devuelto DateTime el valor DateTimeKind.Local.

AssumeUniversal

Especifica que si s falta se supone que cualquier información de zona horaria UTC. A menos que el AdjustToUniversal marca está presente, el método convierte el valor devuelto DateTime valor de la hora UTC en hora local y establece su Kind propiedad DateTimeKind.Local.

None

Aunque sea válido, este valor se omite.

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. Normalmente, esta cadena se crea mediante una llamada a la DateTime.ToString(String) (método) y con el especificador de formato estándar "o", "r" o "u".

En el ejemplo siguiente se analiza la representación de cadena de varios valores de fecha y hora con valores de proveedor y el estilo predeterminados: las convenciones de formato de la referencia cultural en-US, que es la referencia cultural del subproceso actual del equipo utilizado para generar el resultado del ejemplo, y el AllowWhiteSpaces marca de estilo. Controla el FormatExceptionconvenciones 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. También 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.

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.

En el ejemplo siguiente se analiza una matriz de cadenas de fecha usando las convenciones de en-US, fr-FR y de las referencias culturales. Demuestra que las representaciones de cadena de una fecha única pueden interpretar de forma diferente entre referencias culturales diferentes.

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.

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.

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.

.NET Framework

Se admiten todas las sobrecargas en: 4.5, 4, 3.5, 3.0, 2.0, 1.1, 1.0

.NET Framework Client Profile

Se admiten todas las sobrecargas en: 4, 3.5 SP1

Biblioteca de clases portable

Se admiten todas las sobrecargas

.NET para aplicaciones de la Tienda Windows

Se admiten todas las sobrecargas en: Windows 8

Volver al principio
Mostrar: