¿Le resultó útil esta página?
Sus comentarios sobre este contenido son muy importantes. Háganos saber su opinión.
¿Tiene comentarios adicionales?
Caracteres restantes: 1500
Exportar (0) Imprimir
Expandir todo
Este artículo proviene de un motor de traducción automática. Mueva el puntero sobre las frases del artículo para ver el texto original. Más información.
Traducción
Original

TimeSpan.ParseExact (Método) (String, String, IFormatProvider, TimeSpanStyles)

Convierte la representación de cadena de un intervalo de tiempo en su equivalente de TimeSpan, utilizando el formato, los estilos y la información de formato específica de la referencia cultural especificados. El formato de la representación de cadena debe coincidir exactamente con el formato especificado.

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

public static TimeSpan ParseExact(
	string input,
	string format,
	IFormatProvider formatProvider,
	TimeSpanStyles styles
)

Parámetros

input
Tipo: System.String
Cadena que especifica el intervalo de tiempo que se va a convertir.
format
Tipo: System.String
Cadena de formato estándar o personalizado que define el formato requerido de input.
formatProvider
Tipo: System.IFormatProvider
Un objeto que proporciona información de formato específica de la referencia cultural.
styles
Tipo: System.Globalization.TimeSpanStyles
Combinación bit a bit de valores de enumeración que define los elementos de estilo que pueden estar presentes en input.

Valor devuelto

Tipo: System.TimeSpan
Intervalo de tiempo que corresponde a input de acuerdo con lo especificado por format, formatProvider y styles.

ExcepciónCondición
ArgumentException

styles es un valor de TimeSpanStyles no válido.

ArgumentNullException

input es null.

FormatException

input tiene un formato no válido.

OverflowException

input representa un número menor que TimeSpan.MinValue o mayor que TimeSpan.MaxValue.

O bien

Al menos uno de los componentes de días, horas, minutos o segundos de input está fuera de su intervalo válido.

El método ParseExact analiza la representación de cadena de un intervalo de tiempo, que debe estar en el formato definido por el parámetro format, sólo que se omiten los caracteres de espacio en blanco iniciales y finales. Dado que input debe coincidir exactamente con el formato de format, siempre debería usar el control de excepciones al convertir una cadena especificada por el usuario en un intervalo de tiempo. Si prefiere no usar el control de excepciones, puede llamar al método TryParseExact(String, String, IFormatProvider, TimeSpanStyles, TimeSpan).

El parámetro format es una cadena que contiene un solo especificador de formato estándar, o bien, uno o varios especificadores de formato personalizados que definen el formato necesario de input. Para obtener más información sobre cadenas de formato válidos, vea Cadenas de formato TimeSpan estándar y Cadenas de formato TimeSpan personalizado.

Nota importanteImportante

El método ParseExact usa las convenciones de la referencia cultural especificadas por el parámetro formatProvider solo si format es una cadena de formato TimeSpan estándar cuyo valor es "g" o "G". Las cadenas de formato estándar "c", "t" y "T" usan las convenciones de formato de la referencia cultural de todos los idiomas. Las cadenas con formato personalizado definen el formato preciso de la cadena de entrada y usan los caracteres literales para separar los componentes de un intervalo de tiempo.

El parámetro formatProvider es una implementación IFormatProvider que proporciona información específica de la referencia cultural sobre el formato de la cadena devuelta si format es una cadena de formato estándar. El parámetro formatProvider puede ser uno de los siguientes:

Si formatProvider es null, se usa el objeto DateTimeFormatInfo asociado con la referencia cultural actual.

El parámetro styles afecta a la interpretación de cadenas analizadas usando las cadenas con formato personalizado. Determina si input se interpreta como un intervalo de tiempo negativo solo si aparece un signo negativo (TimeSpanStyles.None), o si siempre se interpreta como un intervalo de tiempo negativo (TimeSpanStyles.AssumeNegative). Si no se usa TimeSpanStyles.AssumeNegative, format debe incluir un símbolo de signo negativo literal (como "\-") para analizar un intervalo de tiempo negativo correctamente.

En el ejemplo siguiente se usa el método ParseExact(String, String, IFormatProvider) para analizar varias representaciones de intervalos de tiempo usando varias cadenas de formato y referencias culturales. También usa el valor TimeSpanStyles.AssumeNegative para interpretar cada cadena como un intervalo de tiempo negativo. El resultado del ejemplo muestra que el estilo TimeSpanStyles.AssumeNegative solo afecta al valor devuelto cuando se usa con cadenas con formato personalizado.


using System;
using System.Globalization;

public class Example
{
   public static void Main()
   {
      string intervalString, format;
      TimeSpan interval;
      CultureInfo culture = null;

      // Parse hour:minute value with custom format specifier.
      intervalString = "17:14";
      format = "h\\:mm";
      culture = CultureInfo.CurrentCulture;
      try {
         interval = TimeSpan.ParseExact(intervalString, format, 
                                        culture, TimeSpanStyles.AssumeNegative);
         Console.WriteLine("'{0}' ({1}) --> {2}", intervalString, format, interval);
      }   
      catch (FormatException) {
         Console.WriteLine("'{0}': Bad Format for '{1}'", intervalString, format);
      }   
      catch (OverflowException) {
         Console.WriteLine("'{0}': Overflow", intervalString);
      }      

      // Parse hour:minute:second value with "g" specifier.
      intervalString = "17:14:48";
      format = "g";
      culture = CultureInfo.InvariantCulture;
      try {
         interval = TimeSpan.ParseExact(intervalString, format, 
                                        culture, TimeSpanStyles.AssumeNegative);
         Console.WriteLine("'{0}' ({1}) --> {2}", intervalString, format, interval);
      }
      catch (FormatException) {
         Console.WriteLine("'{0}': Bad Format for '{1}'", intervalString, format);
      }   
      catch (OverflowException) {
         Console.WriteLine("'{0}': Overflow", intervalString);
      } 

      // Parse hours:minute.second value with custom format specifier.     
      intervalString = "17:14:48.153";
      format = @"h\:mm\:ss\.fff";
      culture = null;
      try {
         interval = TimeSpan.ParseExact(intervalString, format, 
                                        culture, TimeSpanStyles.AssumeNegative);
         Console.WriteLine("'{0}' ({1}) --> {2}", intervalString, format, interval);
      }
      catch (FormatException) {
         Console.WriteLine("'{0}': Bad Format for '{1}'", intervalString, format);
      }   
      catch (OverflowException) {
         Console.WriteLine("'{0}': Overflow", intervalString);
      } 

      // Parse days:hours:minute.second value with "G" specifier 
      // and current (en-US) culture.     
      intervalString = "3:17:14:48.153";
      format = "G";
      culture = CultureInfo.CurrentCulture;
      try {
         interval = TimeSpan.ParseExact(intervalString, format, 
                                        culture, TimeSpanStyles.AssumeNegative);
         Console.WriteLine("'{0}' ({1}) --> {2}", intervalString, format, interval);
      }   
      catch (FormatException) {
         Console.WriteLine("'{0}': Bad Format for '{1}'", intervalString, format);
      }
      catch (OverflowException) {
         Console.WriteLine("'{0}': Overflow", intervalString);
      } 

      // Parse days:hours:minute.second value with a custom format specifier.     
      intervalString = "3:17:14:48.153";
      format = @"d\:hh\:mm\:ss\.fff";
      culture = null;
      try {
         interval = TimeSpan.ParseExact(intervalString, format, 
                                        culture, TimeSpanStyles.AssumeNegative);
         Console.WriteLine("'{0}' ({1}) --> {2}", intervalString, format, interval);
      }   
      catch (FormatException) {
         Console.WriteLine("'{0}': Bad Format for '{1}'", intervalString, format);
      }   
      catch (OverflowException) {
         Console.WriteLine("'{0}': Overflow", intervalString);
      } 

      // Parse days:hours:minute.second value with "G" specifier 
      // and fr-FR culture.     
      intervalString = "3:17:14:48,153";
      format = "G";
      culture = new CultureInfo("fr-FR");
      try {
         interval = TimeSpan.ParseExact(intervalString, format, 
                                        culture, TimeSpanStyles.AssumeNegative);
         Console.WriteLine("'{0}' ({1}) --> {2}", intervalString, format, interval);
      }   
      catch (FormatException) {
         Console.WriteLine("'{0}': Bad Format for '{1}'", intervalString, format);
      }   
      catch (OverflowException) {
         Console.WriteLine("'{0}': Overflow", intervalString);
      } 

      // Parse a single number using the "c" standard format string. 
      intervalString = "12";
      format = "c";
      try {
         interval = TimeSpan.ParseExact(intervalString, format, 
                                        null, TimeSpanStyles.AssumeNegative);
         Console.WriteLine("'{0}' ({1}) --> {2}", intervalString, format, interval);
      }   
      catch (FormatException) {
         Console.WriteLine("'{0}': Bad Format for '{1}'", intervalString, format);
      }   
      catch (OverflowException) {
         Console.WriteLine("'{0}': Overflow", intervalString);
      } 

      // Parse a single number using the "%h" custom format string. 
      format = "%h";
      try {
         interval = TimeSpan.ParseExact(intervalString, format, 
                                        null, TimeSpanStyles.AssumeNegative);
         Console.WriteLine("'{0}' ({1}) --> {2}", intervalString, format, interval);
      }   
      catch (FormatException) {
         Console.WriteLine("'{0}': Bad Format for '{1}'", intervalString, format);
      }   
      catch (OverflowException) {
         Console.WriteLine("'{0}': Overflow", intervalString);
      } 

      // Parse a single number using the "%s" custom format string. 
      format = "%s";
      try {
         interval = TimeSpan.ParseExact(intervalString, format, 
                                        null, TimeSpanStyles.AssumeNegative);
         Console.WriteLine("'{0}' ({1}) --> {2}", intervalString, format, interval);
      }   
      catch (FormatException) {
         Console.WriteLine("'{0}': Bad Format for '{1}'", intervalString, format);
      }   
      catch (OverflowException) {
         Console.WriteLine("'{0}': Overflow", intervalString);
      } 
   }
}
// The example displays the following output:
//    '17:14' (h\:mm) --> -17:14:00
//    '17:14:48' (g) --> 17:14:48
//    '17:14:48.153' (h\:mm\:ss\.fff) --> -17:14:48.1530000
//    '3:17:14:48.153' (G) --> 3.17:14:48.1530000
//    '3:17:14:48.153' (d\:hh\:mm\:ss\.fff) --> -3.17:14:48.1530000
//    '3:17:14:48,153' (G) --> 3.17:14:48.1530000
//    '12' (c) --> 12.00:00:00
//    '12' (%h) --> -12:00:00
//    '12' (%s) --> -00:00:12


.NET Framework

Compatible con: 4.5.2, 4.5.1, 4.5, 4

.NET Framework Client Profile

Compatible con: 4

Biblioteca de clases portable

Compatible con: Biblioteca de clases portable

.NET para aplicaciones de la Tienda Windows

Compatible con: Windows 8

.NET para aplicaciones de Windows Phone

Compatible con: Windows Phone 8, Silverlight 8.1

Windows Phone 8.1, Windows Phone 8, Windows 8.1, Windows Server 2012 R2, Windows 8, Windows Server 2012, Windows 7, Windows Vista SP2, Windows Server 2008 (no se admite el rol Server Core), Windows Server 2008 R2 (se admite el rol Server Core con SP1 o versiones posteriores; no se admite Itanium)

.NET Framework no admite todas las versiones de todas las plataformas. Para obtener una lista de las versiones compatibles, vea Requisitos de sistema de .NET Framework.

Adiciones de comunidad

AGREGAR
Mostrar:
© 2015 Microsoft