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.TryParse (String, TimeSpan)

 

Publicado: octubre de 2016

Convierte la representación de cadena de un intervalo de tiempo en su equivalente de TimeSpan y devuelve un valor que indica si la conversión se realizó correctamente.

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

public static bool TryParse(
	string s,
	out TimeSpan result
)

Parámetros

s
Type: System.String

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

result
Type: System.TimeSpan

El resultado que devuelve este método contiene un objeto que representa el intervalo de tiempo especificado por s, 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 s se convirtió correctamente; en caso contrario, false. Esta operación devuelve false si el parámetro s es null o String.Empty, tiene un formato no válido, representa un intervalo de tiempo menor que TimeSpan.MinValue o mayor que TimeSpan.MaxValue, o tiene al menos uno de sus componentes de días, horas, minutos o segundos fuera del intervalo válido.

El TryParse método es similar a la TimeSpan.Parse(String) método, salvo que TI no produce una excepción si se produce un error en la conversión.

El s parámetro contiene una especificación de intervalo de tiempo en el formulario:

[ws][-]{ d | d. hh:mm[:ss[. ff]] | hh:mm[:ss[. ff]] }[ws]

Los elementos de los corchetes ([ y ]) son opcionales. Una selección en la lista de alternativas entre llaves ({y}) y separados por barras verticales (|) es necesario. En la tabla siguiente describe cada elemento.

Elemento

Descripción

eb

Espacio en blanco opcional.

-

Un signo opcional, lo que indica un negativo TimeSpan.

d

Días, comprendidos entre 0 y 10675199.

.

Un símbolo de cuenta de la referencia cultural que separa los días de horas. El formato invariable usa un punto (".") .

hh

Horas, comprendido entre 0 y 23.

:

El símbolo de separador de hora de la cuenta de la referencia cultural. El formato invariable usa dos puntos (":") caracteres.

mm

Minutos, comprendidos entre 0 y 59.

ss

Segundos opcionales, comprendidos entre 0 y 59.

.

Un símbolo de cuenta de la referencia cultural que separa los segundos de fracciones de segundo. El formato invariable usa un punto (".") .

ff

Fracciones de segundo opcionales, que consta de uno a siete dígitos decimales.

Los componentes de s colectivamente se debe especificar un intervalo de tiempo es mayor o igual que TimeSpan.MinValue y menor o igual que TimeSpan.MaxValue.

El Parse(String) método intenta analizar s con cada uno de los formatos específicos de la referencia cultural para la referencia cultural actual.

Notas para llamadores:

En algunos casos, cuando un componente de intervalo de tiempo en la cadena para analizarse contiene más de siete dígitos, análisis de las operaciones que se realizan correctamente en el .NET Framework 3.5 y versiones anteriores pueden producir errores y producir un OverflowException en el .NET Framework 4, en el ejemplo siguiente se muestra este escenario.

string value = "000000006";
TimeSpan interval;
if (TimeSpan.TryParse(value, out interval))
   Console.WriteLine("{0} --> {1}", value, interval);
else
   Console.WriteLine("Unable to parse '{0}'", value);
// Output from .NET Framework 3.5 and earlier versions:
//       000000006 --> 6.00:00:00
// Output from .NET Framework 4:
//       Unable to parse //000000006//

En el ejemplo siguiente se usa el TryParse método para crear TimeSpan objetos desde válido TimeSpan cadenas y para indicar si la operación de análisis ha fallado porque la cadena de intervalo de tiempo no es válida.

using System;

public class TryParse
{
   private static void ParseTimeSpan(string intervalStr)
   {
      // Write the first part of the output line.
      Console.Write( "{0,20}   ", intervalStr );

      // Parse the parameter, and then convert it back to a string.
      TimeSpan intervalVal; 
      if (TimeSpan.TryParse(intervalStr, out intervalVal)) 
      {
         string intervalToStr = intervalVal.ToString();

         // Pad the end of the TimeSpan string with spaces if it 
         // does not contain milliseconds.
         int pIndex = intervalToStr.IndexOf(':');
         pIndex = intervalToStr.IndexOf('.', pIndex);
         if (pIndex < 0)
            intervalToStr += "        ";

         Console.WriteLine("{0,21}", intervalToStr);
         // Handle failure of TryParse method.
      }
      else
      {
         Console.WriteLine("Parse operation failed.");
      }
   } 

   public static void Main()
   {
        Console.WriteLine( "{0,20}   {1,21}", 
            "String to Parse", "TimeSpan" );    
        Console.WriteLine( "{0,20}   {1,21}", 
            "---------------", "---------------------" );    

        ParseTimeSpan("0");
        ParseTimeSpan("14");
        ParseTimeSpan("1:2:3");
        ParseTimeSpan("0:0:0.250");
        ParseTimeSpan("10.20:30:40.50");
        ParseTimeSpan("99.23:59:59.9999999");
        ParseTimeSpan("0023:0059:0059.0099");
        ParseTimeSpan("23:0:0");
        ParseTimeSpan("24:0:0");
        ParseTimeSpan("0:59:0");
        ParseTimeSpan("0:60:0");
        ParseTimeSpan("0:0:59");
        ParseTimeSpan("0:0:60");
        ParseTimeSpan("10:");
        ParseTimeSpan("10:0");
        ParseTimeSpan(":10");
        ParseTimeSpan("0:10");
        ParseTimeSpan("10:20:");
        ParseTimeSpan("10:20:0");
        ParseTimeSpan(".123");
        ParseTimeSpan("0.12:00");
        ParseTimeSpan("10.");
        ParseTimeSpan("10.12");
        ParseTimeSpan("10.12:00");
   }
}
//            String to Parse                TimeSpan
//            ---------------   ---------------------
//                          0        00:00:00
//                         14     14.00:00:00
//                      1:2:3        01:02:03
//                  0:0:0.250        00:00:00.2500000
//             10.20:30:40.50     10.20:30:40.5000000
//        99.23:59:59.9999999     99.23:59:59.9999999
//        0023:0059:0059.0099        23:59:59.0099000
//                     23:0:0        23:00:00
//                     24:0:0   Parse operation failed.
//                     0:59:0        00:59:00
//                     0:60:0   Parse operation failed.
//                     0:0:59        00:00:59
//                     0:0:60   Parse operation failed.
//                        10:   Parse operation failed.
//                       10:0        10:00:00
//                        :10   Parse operation failed.
//                       0:10        00:10:00
//                     10:20:   Parse operation failed.
//                    10:20:0        10:20:00
//                       .123   Parse operation failed.
//                    0.12:00        12:00:00
//                        10.   Parse operation failed.
//                      10.12   Parse operation failed.
//                   10.12:00     10.12:00:00

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