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

 

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, y devuelve un valor que indica si la conversión se realizó correctamente. 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 bool TryParseExact(
	string input,
	string format,
	IFormatProvider formatProvider,
	TimeSpanStyles styles,
	out TimeSpan result
)

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

Uno o varios valores de enumeración que indican el estilo de input.

result
Type: System.TimeSpan

El resultado que devuelve este método contiene un objeto que representa el intervalo de tiempo especificado por input, o TimeSpan.Zero si la conversión no se realizó correctamente. Este parámetro se pasa sin inicializar.

Valor devuelto

Type: System.Boolean

true si input se convirtió correctamente; en caso contrario, false.

El TryParseExact(String, String, IFormatProvider, TimeSpanStyles, TimeSpan) 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. Este método es similar a la ParseExact(String, String, IFormatProvider, TimeSpanStyles) método, salvo que TI no produce una excepción si se produce un error en la conversión.

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.

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 analizadas usando las 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;
      if (TimeSpan.TryParseExact(intervalString, format, 
                                 culture, TimeSpanStyles.AssumeNegative, out interval))
         Console.WriteLine("'{0}' ({1}) --> {2}", intervalString, format, interval);
      else   
         Console.WriteLine("Unable to parse '{0}' using format {1}",
                           intervalString, format);

      // Parse hour:minute:second value with "g" specifier.
      intervalString = "17:14:48";
      format = "g";
      culture = CultureInfo.InvariantCulture;
      if (TimeSpan.TryParseExact(intervalString, format, 
                                 culture, TimeSpanStyles.AssumeNegative, out interval))
         Console.WriteLine("'{0}' ({1}) --> {2}", intervalString, format, interval);
      else
         Console.WriteLine("Unable to parse '{0}' using format {1}",
                           intervalString, format);

      // Parse hours:minute.second value with custom format specifier.     
      intervalString = "17:14:48.153";
      format = @"h\:mm\:ss\.fff";
      culture = null;
      if (TimeSpan.TryParseExact(intervalString, format, 
                                 culture, TimeSpanStyles.AssumeNegative, out interval))
         Console.WriteLine("'{0}' ({1}) --> {2}", intervalString, format, interval);
      else
         Console.WriteLine("Unable to parse '{0}' using format {1}",
                           intervalString, format);   

      // 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;
      if (TimeSpan.TryParseExact(intervalString, format, 
                                 culture, TimeSpanStyles.AssumeNegative, out interval))
         Console.WriteLine("'{0}' ({1}) --> {2}", intervalString, format, interval);
      else   
         Console.WriteLine("Unable to parse '{0}' using format {1}",
                           intervalString, format);   

      // 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;
      if (TimeSpan.TryParseExact(intervalString, format, 
                                 culture, TimeSpanStyles.AssumeNegative, out interval))
         Console.WriteLine("'{0}' ({1}) --> {2}", intervalString, format, interval);
      else   
         Console.WriteLine("Unable to parse '{0}' using format {1}",
                           intervalString, format);

      // 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");
      if (TimeSpan.TryParseExact(intervalString, format, 
                                 culture, TimeSpanStyles.AssumeNegative, out interval))
         Console.WriteLine("'{0}' ({1}) --> {2}", intervalString, format, interval);
      else   
         Console.WriteLine("Unable to parse '{0}' using format {1}",
                           intervalString, format);

      // Parse a single number using the "c" standard format string. 
      intervalString = "12";
      format = "c";
      if (TimeSpan.TryParseExact(intervalString, format, 
                                 null, TimeSpanStyles.AssumeNegative, out interval))
         Console.WriteLine("'{0}' ({1}) --> {2}", intervalString, format, interval);
      else   
         Console.WriteLine("Unable to parse '{0}' using format {1}",
                           intervalString, format);

      // Parse a single number using the "%h" custom format string. 
      format = "%h";
      if (TimeSpan.TryParseExact(intervalString, format, 
                                 null, TimeSpanStyles.AssumeNegative, out interval))
         Console.WriteLine("'{0}' ({1}) --> {2}", intervalString, format, interval);
      else   
         Console.WriteLine("Unable to parse '{0}' using format {1}",
                           intervalString, format);

      // Parse a single number using the "%s" custom format string. 
      format = "%s";
      if (TimeSpan.TryParseExact(intervalString, format, 
                                 null, TimeSpanStyles.AssumeNegative, out interval))
         Console.WriteLine("'{0}' ({1}) --> {2}", intervalString, format, interval);
      else   
         Console.WriteLine("Unable to parse '{0}' using format {1}",
                           intervalString, format);
   }
}
// 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: