DateTime.ParseExact (Método) (String, String, IFormatProvider, DateTimeStyles)

El método DateTime.ParseExact(String, String, IFormatProvider, DateTimeStyles) analiza la representación de cadena de una fecha, que debe estar en un formato definido por el parámetro format. También requiere que los elementos de fecha y hora de s aparezcan en el orden especificado por format. Si s no coincide con el modelo del parámetro format y se produce cualquiera de las variaciones definidas por el parámetro style, el método inicia una excepción FormatException. En cambio, el método DateTime.Parse(String, IFormatProvider, DateTimeStyles) analiza la representación de cadena de una fecha en cualquiera de los formatos reconocidos por el objeto DateTimeFormatInfo del proveedor de formato. El método DateTime.Parse(String, IFormatProvider, DateTimeStyles) también permite que los elementos de fecha y hora de s aparezcan en cualquier orden.

Si el parámetro s contiene solamente una hora pero ninguna fecha, se usa la fecha actual, a menos que el parámetro style incluya el marcador DateTimeStyles.NoCurrentDateDefault, en cuyo caso se usa fecha predeterminada (DateTime.Date.MinValue). Si el parámetro s contiene sólo una fecha pero ninguna hora, se utiliza la medianoche (00:00:00). El parámetro style también determina si el parámetro s puede contener caracteres de espacio en blanco iniciales, interiores o finales.

Si el parámetro s no incluye información de zona horaria, la propiedad Kind del objeto DateTime devuelto será DateTimeKind.Unspecified. Este comportamiento puede modificarse utilizando el marcador DateTimeStyles.AssumeLocal, que devuelve un valor DateTime cuya propiedad Kind es DateTimeKind.Local, o utilizando los marcadores DateTimeStyles.AssumeUniversal y DateTimeStyles.AdjustToUniversal, que devuelven un valor DateTime cuya propiedad Kind es DateTimeKind.Utc. Si s incluye información de la zona horaria, la hora se convierte a la hora local, si es necesario, y la propiedad Kind del objeto DateTime devuelto se establece en DateTimeKind.Local. Este comportamiento puede modificarse usando el marcador DateTimeStyles.RoundtripKind para no convertir la hora universal coordinada (UTC) en una hora local y establecer la propiedad Kind en DateTimeKind.Utc.

El parámetro format define el modelo necesario del parámetro s. Puede estar compuesto por uno o varios de los especificadores de formato personalizados de la tabla Cadenas de formato de fecha y hora personalizadas o por un especificador de formato estándar único, que identifica un modelo predefinido, en la tabla Cadenas con formato de fecha y hora estándar.

Si no usa los separadores de fecha u hora de un modelo de formato personalizado, utilice la referencia cultural de todos los idiomas para el parámetro provider y el formato más extenso de cada especificador de formato personalizado. Por ejemplo, si desea establecer horas en el modelo, especifique el formato largo, "HH", en lugar del formato corto, "H".

Nota
En lugar de exigir que s se ajuste a un único formato para que la operación de análisis se realice correctamente, puede llamar al método DateTime.ParseExact(String, String[], IFormatProvider, DateTimeStyles) y especificar varios formatos permitidos. Esto hace que la operación de análisis tenga más probabilidades de realizarse correctamente.

El parámetro styles incluye uno o más miembros de la enumeración DateTimeStyles que determinan si pueden aparecer espacios en blanco no definidos por format en s y dónde pueden aparecer, y controla el comportamiento exacto de la operación de análisis. En la tabla siguiente se describe el modo en que la operación del método ParseExact(String, String, IFormatProvider, DateTimeStyles) afecta a cada uno de los miembros de la enumeración DateTimeStyles.

Los símbolos y cadenas de fecha y hora concretos (como los nombres de los días de la semana de un idioma determinado) que se usan en s se definen con el parámetro provider, al igual que el formato exacto de s si format es una cadena de especificador de formato estándar. El parámetro provider puede ser uno de los siguientes:

• Un objeto CultureInfo que representa la referencia cultural utilizada para interpretar s. El objeto DateTimeFormatInfo devuelto por su propiedad DateTimeFormat define los símbolos y el formato en s.

• Objeto DateTimeFormatInfo que define el formato de los datos de fecha y hora.

• Una implementación IFormatProvider personalizada cuyo método GetFormat devuelve el objeto CultureInfo o el objeto DateTimeFormatInfo que proporciona información de formato.

Si provider es null, se usa el objeto CultureInfo que corresponde a la referencia cultural actual.

En .NET Framework 4, el método ParseExact produce FormatException si la cadena que se va a analizar contiene un componente de hora y un designador AM/PM que no concuerdan. En .NET Framework 3.5 y en versiones anteriores, el designador AM/PM se pasa por alto.

En el siguiente ejemplo se muestra el método ParseExact(String, String, IFormatProvider). Observe que la cadena " 5/01/2009 8:30 AM" no puede analizarse correctamente cuando el parámetro styles es igual a DateTimeStyles.None porque no se permiten espacios iniciales en format. Además, no puede analizarse correctamente la cadena "5/01/2009 09:00" cuando format es igual "MM/dd/yyyy hh:mm" porque el número de mes de la cadena de fecha no va precedido de un cero inicial, que es lo que exige format.

CultureInfo enUS = new CultureInfo("en-US"); 
string dateString;
DateTime dateValue;

// Parse date with no style flags.
dateString = " 5/01/2009 8:30 AM";
try {
   dateValue = DateTime.ParseExact(dateString, "g", enUS, DateTimeStyles.None);
   Console.WriteLine("Converted '{0}' to {1} ({2}).", dateString, dateValue, 
                     dateValue.Kind);
}                           
catch (FormatException) {
   Console.WriteLine("'{0}' is not in an acceptable format.", dateString);
}
// Allow a leading space in the date string.
try {
   dateValue = DateTime.ParseExact(dateString, "g", enUS, DateTimeStyles.AllowLeadingWhite);
   Console.WriteLine("Converted '{0}' to {1} ({2}).", dateString, dateValue, 
                     dateValue.Kind);
}                           
catch (FormatException) {
   Console.WriteLine("'{0}' is not in an acceptable format.", dateString);
}

// Use custom formats with M and MM.
dateString = "5/01/2009 09:00";
try {
   dateValue = DateTime.ParseExact(dateString, "M/dd/yyyy hh:mm", enUS, DateTimeStyles.None);
   Console.WriteLine("Converted '{0}' to {1} ({2}).", dateString, dateValue, 
                     dateValue.Kind);
}                           
catch (FormatException) {
   Console.WriteLine("'{0}' is not in an acceptable format.", dateString);
}
// Allow a leading space in the date string.
try {
   dateValue = DateTime.ParseExact(dateString, "MM/dd/yyyy hh:mm", enUS, DateTimeStyles.None);
   Console.WriteLine("Converted '{0}' to {1} ({2}).", dateString, dateValue, 
                     dateValue.Kind);
}                           
catch (FormatException) {
   Console.WriteLine("'{0}' is not in an acceptable format.", dateString);
}

// Parse a string with time zone information.
dateString = "05/01/2009 01:30:42 PM -05:00"; 
try {
   dateValue = DateTime.ParseExact(dateString, "MM/dd/yyyy hh:mm:ss tt zzz", enUS, DateTimeStyles.None);
   Console.WriteLine("Converted '{0}' to {1} ({2}).", dateString, dateValue, 
                     dateValue.Kind);
}                           
catch (FormatException) {
   Console.WriteLine("'{0}' is not in an acceptable format.", dateString);
}
// Allow a leading space in the date string.
try {
   dateValue = DateTime.ParseExact(dateString, "MM/dd/yyyy hh:mm:ss tt zzz", enUS, 
                               DateTimeStyles.AdjustToUniversal);
   Console.WriteLine("Converted '{0}' to {1} ({2}).", dateString, dateValue, 
                     dateValue.Kind);
}                           
catch (FormatException) {
   Console.WriteLine("'{0}' is not in an acceptable format.", dateString);
}

// Parse a string represengting UTC.
dateString = "2008-06-11T16:11:20.0904778Z";
try {
   dateValue = DateTime.ParseExact(dateString, "o", CultureInfo.InvariantCulture, 
                               DateTimeStyles.None);
   Console.WriteLine("Converted '{0}' to {1} ({2}).", dateString, dateValue, 
                     dateValue.Kind);
}                           
catch (FormatException) {
   Console.WriteLine("'{0}' is not in an acceptable format.", dateString);
}
try {
   dateValue = DateTime.ParseExact(dateString, "o", CultureInfo.InvariantCulture, 
                               DateTimeStyles.RoundtripKind);
   Console.WriteLine("Converted '{0}' to {1} ({2}).", dateString, dateValue, 
                     dateValue.Kind);
}                           
catch (FormatException) {
   Console.WriteLine("'{0}' is not in an acceptable format.", dateString);
}
// The example displays the following output:
//    ' 5/01/2009 8:30 AM' is not in an acceptable format.
//    Converted ' 5/01/2009 8:30 AM' to 5/1/2009 8:30:00 AM (Unspecified).
//    Converted '5/01/2009 09:00' to 5/1/2009 9:00:00 AM (Unspecified).
//    '5/01/2009 09:00' is not in an acceptable format.
//    Converted '05/01/2009 01:30:42 PM -05:00' to 5/1/2009 11:30:42 AM (Local).
//    Converted '05/01/2009 01:30:42 PM -05:00' to 5/1/2009 6:30:42 PM (Utc).
//    Converted '2008-06-11T16:11:20.0904778Z' to 6/11/2008 9:11:20 AM (Local).
//    Converted '2008-06-11T16:11:20.0904778Z' to 6/11/2008 4:11:20 PM (Utc).

.NET Framework

.NET Framework Client Profile

Windows 7, Windows Vista SP1 o posterior, Windows XP SP3, Windows XP SP2 x64 Edition, Windows Server 2008 (no se admite Server Core), Windows Server 2008 R2 (se admite Server Core con SP1 o posterior), Windows Server 2003 SP2

Referencia

Otros recursos