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

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
Tipo: System.String
Cadena que especifica el intervalo de tiempo que se va a convertir.
result
Tipo: 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 finalizó correctamente. Este parámetro se pasa sin inicializar.

Valor devuelto

Tipo: System.Boolean
Es true si s se convirtió correctamente; de lo contrario, es 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 método es TryParse como el método TimeSpan.Parse(String) excepto en que no produce ninguna excepción si hay un error de conversión.

El parámetro s contiene una especificación de intervalo de tiempo en la estructura:

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

Los elementos entre corchetes ([ y ]) son opcionales. Se requiere una selección de la lista de alternativas entre llaves ({ y }) y separadas por barras verticales (|) son obligatorias. En la tabla siguiente se describe cada elemento.

Elemento

Descripción

eb

Espacio en blanco opcional.

-

Un signo menos opcional, que indica un TimeSpan negativo.

d

Días, comprendidos entre 0 y 10675199

.

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

hh

Horas, comprendidas entre 0 y 23.

:

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

mm

Minutos, comprendidos entre 0 y 59.

ss

Segundos opcionales, comprendidos entre 0 y 59.

.

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

ff

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

Los componentes de s deben especificar, en conjunto, un intervalo de tiempo mayor o igual que TimeSpan.MinValue y menor o igual que TimeSpan.MaxValue.

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

Notas para los llamadores

En algunos casos, cuando un componente de intervalo de tiempo en la cadena que se va a analizar contiene más de siete dígitos, las operaciones de análisis que son correctas en .NET Framework 3.5 y en versiones anteriores pueden producir una excepción OverflowException en .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 método TryParse para crear objetos TimeSpan a partir de cadenas TimeSpan válidas y para indicar cuando se ha producido un error en la operación del análisis debido a que la cadena del 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


.NET Framework

Compatible con: 4.5.2, 4.5.1, 4.5, 4, 3.5, 3.0, 2.0

.NET Framework Client Profile

Compatible con: 4, 3.5 SP1

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:
© 2014 Microsoft