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 TimeSpan.ParseExact (String, String, IFormatProvider, TimeSpanStyles)

 

Publicado: octubre de 2016

Convierte la representación de cadena de un intervalo de tiempo en su equivalente de TimeSpan, usando el formato y los estilos especificados, y la información de formato específica de la referencia cultural. 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
Type: System.String

Cadena que especifica el intervalo de tiempo que se va a convertir.

format
Type: System.String

Cadena de formato estándar o personalizado que define el formato requerido de input.

formatProvider
Type: System.IFormatProvider

Objeto que proporciona información de formato específica de la referencia cultural.

styles
Type: 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

Type: System.TimeSpan

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

Exception Condition
ArgumentException

styles es un valor de TimeSpanStyles no válido.

ArgumentNullException

El valor de 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 del intervalo válido.

El ParseExact método analiza la representación de cadena de un intervalo de tiempo, que debe estar en el formato definido por el format parámetro, excepto los caracteres de espacio en blanco que iniciales y finales se omiten. Dado que input debe ajustarse al formato de format exactamente, siempre debe 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 a la TryParseExact(String, String, IFormatProvider, TimeSpanStyles, TimeSpan) método en su lugar.

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

System_CAPS_importantImportante

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

El formatProvider parámetro es un IFormatProvider implementación 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 formatProvider parámetro puede ser cualquiera de las siguientes acciones:

Si formatProvider es null, el DateTimeFormatInfo se usa el objeto que está asociado a la referencia cultural actual.

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

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

Plataforma universal de Windows
Disponible desde 8
.NET Framework
Disponible desde 4.0
Biblioteca de clases portable
Se admite en: plataformas portátiles de .NET
Silverlight
Disponible desde 4.0
Windows Phone Silverlight
Disponible desde 7.1
Windows Phone
Disponible desde 8.1
Volver al principio
Mostrar: