TimeSpan.TryParse Método

Definición

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

Sobrecargas

TryParse(ReadOnlySpan<Char>, IFormatProvider, TimeSpan)

Convierte la representación de intervalo de un intervalo de tiempo en su valor TimeSpan equivalente mediante la información de formato específica de la referencia cultural, y devuelve un valor que indica si la conversión se ha realizado correctamente.

TryParse(ReadOnlySpan<Char>, TimeSpan)

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

TryParse(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.

TryParse(String, IFormatProvider, TimeSpan)

Convierte la representación de cadena de un intervalo de tiempo en su equivalente de TimeSpan usando la información de formato específica de la referencia cultural, y devuelve un valor que indica si la conversión se realizó correctamente.

TryParse(ReadOnlySpan<Char>, IFormatProvider, TimeSpan)

Convierte la representación de intervalo de un intervalo de tiempo en su valor TimeSpan equivalente mediante la información de formato específica de la referencia cultural, y devuelve un valor que indica si la conversión se ha realizado correctamente.

public:
 static bool TryParse(ReadOnlySpan<char> input, IFormatProvider ^ formatProvider, [Runtime::InteropServices::Out] TimeSpan % result);
public static bool TryParse (ReadOnlySpan<char> input, IFormatProvider? formatProvider, out TimeSpan result);
public static bool TryParse (ReadOnlySpan<char> input, IFormatProvider formatProvider, out TimeSpan result);
static member TryParse : ReadOnlySpan<char> * IFormatProvider * TimeSpan -> bool
Public Shared Function TryParse (input As ReadOnlySpan(Of Char), formatProvider As IFormatProvider, ByRef result As TimeSpan) As Boolean

Parámetros

input
ReadOnlySpan<Char>

Un intervalo que contiene los caracteres que representan el intervalo de tiempo que se va a convertir.

formatProvider
IFormatProvider

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

result
TimeSpan

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

Devoluciones

Boolean

true si input se convirtió correctamente; en caso contrario, false. Esta operación devuelve false si el parámetro input es null o Empty, tiene un formato no válido, representa un intervalo de tiempo menor que MinValue o mayor que MaxValue, o tiene al menos uno de sus componentes de días, horas, minutos o segundos fuera del intervalo válido.

Se aplica a

TryParse(ReadOnlySpan<Char>, TimeSpan)

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

public:
 static bool TryParse(ReadOnlySpan<char> s, [Runtime::InteropServices::Out] TimeSpan % result);
public static bool TryParse (ReadOnlySpan<char> s, out TimeSpan result);
static member TryParse : ReadOnlySpan<char> * TimeSpan -> bool
Public Shared Function TryParse (s As ReadOnlySpan(Of Char), ByRef result As TimeSpan) As Boolean

Parámetros

s
ReadOnlySpan<Char>

Un intervalo que contiene los caracteres que representan el intervalo de tiempo que se va a convertir.

result
TimeSpan

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

Devoluciones

Boolean

true si s se convirtió correctamente; en caso contrario, false. Esta operación devuelve false si el parámetro s es null o Empty, tiene un formato no válido, representa un intervalo de tiempo menor que MinValue o mayor que MaxValue, o tiene al menos uno de sus componentes de días, horas, minutos o segundos fuera del intervalo válido.

Se aplica a

TryParse(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.

public:
 static bool TryParse(System::String ^ s, [Runtime::InteropServices::Out] TimeSpan % result);
public static bool TryParse (string s, out TimeSpan result);
public static bool TryParse (string? s, out TimeSpan result);
static member TryParse : string * TimeSpan -> bool
Public Shared Function TryParse (s As String, ByRef result As TimeSpan) As Boolean

Parámetros

s
String

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

result
TimeSpan

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

Devoluciones

Boolean

true si s se convirtió correctamente; en caso contrario, false. Esta operación devuelve false si el parámetro s es null o Empty, tiene un formato no válido, representa un intervalo de tiempo menor que MinValue o mayor que MaxValue, o tiene al menos uno de sus componentes de días, horas, minutos o segundos fuera del intervalo válido.

Ejemplos

En el ejemplo siguiente se usa el método para crear objetos a partir de cadenas válidas e indicar cuándo se ha dado error en la operación de análisis porque la cadena de intervalo de tiempo TryParse TimeSpan no es TimeSpan 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
Module TryParse
    Sub ParseTimeSpan( intervalStr As String )
        ' Write the first part of the output line.
        Console.Write( "{0,20}   ", intervalStr )

        ' Parse the parameter, and then convert it back to a string.
         Dim intervalVal As TimeSpan 
         If TimeSpan.TryParse( intervalStr, intervalVal ) Then
            Dim intervalToStr As String = intervalVal.ToString( )
   
            ' Pad the end of the TimeSpan string with spaces if it 
            ' does not contain milliseconds.
            Dim pIndex As Integer = intervalToStr.IndexOf( ":"c )
            pIndex = intervalToStr.IndexOf( "."c, pIndex )
            If pIndex < 0 Then   intervalToStr &= "        "
   
            Console.WriteLine( "{0,21}", intervalToStr )
         ' Handle failure of TryParse method.
         Else
            Console.WriteLine("Parse operation failed.")
        End If
    End Sub 

    Public Sub 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")
    End Sub 
End Module 
' This example generates the following output:
'            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

Comentarios

El método es como el método , salvo que no produce TryParse TimeSpan.Parse(String) 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. Se requiere una selección de la lista de alternativas entre llaves ({ y }) y separadas por barras verticales (|). En esta tabla se describe cada elemento.

Elemento Descripción
ws Espacio en blanco opcional.
- Signo menos opcional, que indica un TimeSpan negativo.
d Días, que van de 0 a 10675199.
. Símbolo que tiene en cuenta la referencia cultural que separa los días de las horas. El formato invariable usa un carácter de punto (".").
hh Horas, que van de 0 a 23.
: Símbolo de separador de tiempo que tiene en cuenta la referencia cultural. El formato invariable usa un carácter de dos puntos (":").
mm Minutos, que van de 0 a 59.
ss Segundos opcionales, que van de 0 a 59.
. Símbolo que tiene en cuenta la referencia cultural que separa los segundos de las fracciones de segundo. El formato invariable usa un carácter de punto (".").
Ff Fracciones de segundo opcionales, que constan de uno a siete dígitos decimales.

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

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

Notas para los autores de la llamada

En algunos casos, cuando un componente de intervalo de tiempo de la cadena que se va a analizar contiene más de siete dígitos, las operaciones de análisis que se completan correctamente en .NET Framework 3.5 y versiones anteriores pueden producir un error y producir un error en el .NET Framework 4 y versiones OverflowException posteriores. Este escenario se ilustra en el ejemplo siguiente.

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//
Dim value As String = "000000006"
Dim interval As TimeSpan
If TimeSpan.TryParse(value, interval) Then
   Console.WriteLine("{0} --> {1}", value, interval)
Else
   Console.WriteLine("Unable to parse '{0}'", value)
End If
' Output from .NET Framework 3.5 and earlier versions:
'       000000006 --> 6.00:00:00
' Output from .NET Framework 4:
'       Unable to parse '000000006'

Se aplica a

TryParse(String, IFormatProvider, TimeSpan)

Convierte la representación de cadena de un intervalo de tiempo en su equivalente de TimeSpan usando la información de formato específica de la referencia cultural, y devuelve un valor que indica si la conversión se realizó correctamente.

public:
 static bool TryParse(System::String ^ input, IFormatProvider ^ formatProvider, [Runtime::InteropServices::Out] TimeSpan % result);
public static bool TryParse (string input, IFormatProvider formatProvider, out TimeSpan result);
public static bool TryParse (string? input, IFormatProvider? formatProvider, out TimeSpan result);
static member TryParse : string * IFormatProvider * TimeSpan -> bool
Public Shared Function TryParse (input As String, formatProvider As IFormatProvider, ByRef result As TimeSpan) As Boolean

Parámetros

input
String

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

formatProvider
IFormatProvider

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

result
TimeSpan

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

Devoluciones

Boolean

true si input se convirtió correctamente; en caso contrario, false. Esta operación devuelve false si el parámetro input es null o Empty, tiene un formato no válido, representa un intervalo de tiempo menor que MinValue o mayor que MaxValue, o tiene al menos uno de sus componentes de días, horas, minutos o segundos fuera del intervalo válido.

Ejemplos

En el ejemplo siguiente se define una matriz de objetos y se usa cada objeto en las llamadas al método para analizar los CultureInfo TryParse(String, IFormatProvider, TimeSpan) elementos de una matriz de cadenas. En el ejemplo se muestra cómo las convenciones de una referencia cultural específica influyen en la operación de formato.

using System;
using System.Globalization;

public class Example
{
   public static void Main()
   {
      string[] values = { "6", "6:12", "6:12:14", "6:12:14:45", 
                          "6.12:14:45", "6:12:14:45.3448", 
                          "6:12:14:45,3448", "6:34:14:45" };
      CultureInfo[] cultures = { new CultureInfo("en-US"), 
                                 new CultureInfo("ru-RU"),
                                 CultureInfo.InvariantCulture };
      
      string header = String.Format("{0,-17}", "String");
      foreach (CultureInfo culture in cultures)
         header += culture.Equals(CultureInfo.InvariantCulture) ? 
                      String.Format("{0,20}", "Invariant") :
                      String.Format("{0,20}", culture.Name);

      Console.WriteLine(header);
      Console.WriteLine();
      
      foreach (string value in values)
      {
         Console.Write("{0,-17}", value);
         foreach (CultureInfo culture in cultures)
         {
            TimeSpan interval = new TimeSpan();
            if (TimeSpan.TryParse(value, culture, out interval))
               Console.Write("{0,20}", interval.ToString("c"));
            else
               Console.Write("{0,20}", "Unable to Parse");
         }
         Console.WriteLine();                                
      }
   }
}
// The example displays the following output:
//    String                          en-US               ru-RU           Invariant
//    
//    6                          6.00:00:00          6.00:00:00          6.00:00:00
//    6:12                         06:12:00            06:12:00            06:12:00
//    6:12:14                      06:12:14            06:12:14            06:12:14
//    6:12:14:45                 6.12:14:45          6.12:14:45          6.12:14:45
//    6.12:14:45                 6.12:14:45          6.12:14:45          6.12:14:45
//    6:12:14:45.3448    6.12:14:45.3448000     Unable to Parse  6.12:14:45.3448000
//    6:12:14:45,3448       Unable to Parse  6.12:14:45.3448000     Unable to Parse
//    6:34:14:45            Unable to Parse     Unable to Parse     Unable to Parse
Imports System.Globalization

Module Example
   Public Sub Main()
      Dim values() As String = { "6", "6:12", "6:12:14", "6:12:14:45", 
                                 "6.12:14:45", "6:12:14:45.3448", 
                                 "6:12:14:45,3448", "6:34:14:45" }
      Dim cultures() As CultureInfo = { New CultureInfo("en-US"), 
                                        New CultureInfo("ru-RU"),
                                        CultureInfo.InvariantCulture }
      
      Dim header As String = String.Format("{0,-17}", "String")
      For Each culture As CultureInfo In cultures
         header += If(culture.Equals(CultureInfo.InvariantCulture), 
                      String.Format("{0,20}", "Invariant"),
                      String.Format("{0,20}", culture.Name))
      Next
      Console.WriteLine(header)
      Console.WriteLine()
      
      For Each value As String In values
         Console.Write("{0,-17}", value)
         For Each culture As CultureInfo In cultures
            Dim interval As New TimeSpan()
            If TimeSpan.TryParse(value, culture, interval) Then
               Console.Write("{0,20}", interval.ToString("c"))
            Else
               Console.Write("{0,20}", "Unable to Parse")
            End If     
         Next
         Console.WriteLine()                                
      Next
   End Sub
End Module
' The example displays the following output:
'    String                          en-US               ru-RU           Invariant
'    
'    6                          6.00:00:00          6.00:00:00          6.00:00:00
'    6:12                         06:12:00            06:12:00            06:12:00
'    6:12:14                      06:12:14            06:12:14            06:12:14
'    6:12:14:45                 6.12:14:45          6.12:14:45          6.12:14:45
'    6.12:14:45                 6.12:14:45          6.12:14:45          6.12:14:45
'    6:12:14:45.3448    6.12:14:45.3448000     Unable to Parse  6.12:14:45.3448000
'    6:12:14:45,3448       Unable to Parse  6.12:14:45.3448000     Unable to Parse
'    6:34:14:45            Unable to Parse     Unable to Parse     Unable to Parse

Comentarios

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

El input 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. Se requiere una selección de la lista de alternativas entre llaves ({ y }) y separadas por barras verticales (|). En esta tabla se describe cada elemento.

Elemento Descripción
ws Espacio en blanco opcional.
- Signo menos opcional, que indica un TimeSpan negativo.
d Días, que van de 0 a 10675199.
. Símbolo que tiene en cuenta la referencia cultural que separa los días de las horas. El formato invariable usa un carácter de punto (".").
hh Horas, que van de 0 a 23.
: Símbolo de separador de tiempo que tiene en cuenta la referencia cultural. El formato invariable usa un carácter de dos puntos (":").
mm Minutos, que van de 0 a 59.
ss Segundos opcionales, que van de 0 a 59.
. Símbolo que tiene en cuenta la referencia cultural que separa los segundos de las fracciones de segundo. El formato invariable usa un carácter de punto (".").
Ff Fracciones de segundo opcionales, que constan de uno a siete dígitos decimales.

Los componentes de deben especificar colectivamente un intervalo de tiempo mayor o igual que input y menor o igual que TimeSpan.MinValue TimeSpan.MaxValue .

El método intenta analizar utilizando cada uno de los formatos específicos de la TryParse(String, IFormatProvider, TimeSpan) referencia cultural para la referencia cultural especificada por input formatProvider .

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

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

Notas para los autores de la llamada

En algunos casos, cuando un componente de intervalo de tiempo de la cadena que se va a analizar contiene más de siete dígitos, las operaciones de análisis que se completan correctamente y devuelven en .NET Framework 3.5 y versiones anteriores pueden producir un error y devolverse en the.NET Framework 4 y versiones true false posteriores. 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//
Dim value As String = "000000006"
Dim interval As TimeSpan
If TimeSpan.TryParse(value, interval) Then
   Console.WriteLine("{0} --> {1}", value, interval)
Else
   Console.WriteLine("Unable to parse '{0}'", value)
End If
' Output from .NET Framework 3.5 and earlier versions:
'       000000006 --> 6.00:00:00
' Output from .NET Framework 4:
'       Unable to parse '000000006'

Se aplica a