TimeSpan.TryParse Método

Definición

Espacio de nombres:: System

Ensamblados:: netstandard.dll, System.Runtime.dll

Ensamblado:: System.Runtime.dll

Ensamblado:: netstandard.dll

Ensamblados:: mscorlib.dll, System.Runtime.dll

Ensamblado:: mscorlib.dll

Importante

Parte de la información hace referencia a la versión preliminar del producto, que puede haberse modificado sustancialmente antes de lanzar la versión definitiva. Microsoft no otorga ninguna garantía, explícita o implícita, con respecto a la información proporcionada aquí.

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

Sobrecargas

Nombre	Description
TryParse(ReadOnlySpan<Char>, TimeSpan)	Convierte la representación de intervalo de un intervalo en su TimeSpan equivalente y devuelve un valor que indica si la conversión se realizó correctamente.
TryParse(String, TimeSpan)	Convierte la representación de cadena de un intervalo de tiempo en su TimeSpan equivalente 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 en su TimeSpan equivalente mediante la información de formato específica de la referencia cultural especificada 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 TimeSpan equivalente mediante la información de formato específica de la referencia cultural especificada y devuelve un valor que indica si la conversión se realizó correctamente.

TryParse(ReadOnlySpan<Char>, TimeSpan)

Source:: TimeSpan.cs

Source:: TimeSpan.cs

Source:: TimeSpan.cs

Source:: TimeSpan.cs

Source:: TimeSpan.cs

Convierte la representación de intervalo de un intervalo en su TimeSpan equivalente y devuelve un valor que indica si la conversión se realizó 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>

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

result: TimeSpan

Cuando este método devuelve , contiene un objeto que representa el intervalo de tiempo especificado por so Zero si se produjo un error en la conversión. Este parámetro se pasa sin inicializar.

Devoluciones

Boolean

true es si s se ha convertido correctamente; de lo contrario, falsees . Esta operación devuelve false si el s parámetro es null o 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 un componente de días, horas, minutos o segundos fuera de su intervalo válido.

Se aplica a

TryParse(String, TimeSpan)

Source:: TimeSpan.cs

Source:: TimeSpan.cs

Source:: TimeSpan.cs

Source:: TimeSpan.cs

Source:: TimeSpan.cs

Convierte la representación de cadena de un intervalo de tiempo en su TimeSpan equivalente 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

Cuando este método devuelve , contiene un objeto que representa el intervalo de tiempo especificado por so Zero si se produjo un error en la conversión. Este parámetro se pasa sin inicializar.

Devoluciones

Boolean

Ejemplos

En el ejemplo siguiente se usa el TryParse método para crear TimeSpan objetos a partir de cadenas válidas TimeSpan e indicar cuándo se ha producido un error en la operación de análisis 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

open System

let parseTimeSpan intervalStr =
    // Write the first part of the output line.
    printf $"%20s{intervalStr}   "

    // Parse the parameter, and then convert it back to a string.
    match TimeSpan.TryParse intervalStr with
    | true, intervalVal ->
        let intervalToStr = string intervalVal

        // Pad the end of the TimeSpan string with spaces if it 
        // does not contain milliseconds.
        let pIndex = intervalToStr.IndexOf ':'
        let pIndex = intervalToStr.IndexOf('.', pIndex)
        let intervalToStr =
            if pIndex < 0 then
                intervalToStr + "        "
            else intervalStr
        printfn $"{intervalToStr,21}"
        // Handle failure of TryParse method.
    | _ ->
        printfn "Parse operation failed."

printfn "%20s   %21s" "String to Parse" "TimeSpan"
printfn "%20s   %21s" "---------------" "---------------------"

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 Run()
        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

Método TryParse(System.String,System.TimeSpan@)

El TimeSpan.TryParse(String, TimeSpan) método es similar al TimeSpan.Parse(String) método , salvo que 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 con el formato :

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

Los elementos entre corchetes ([ y ]) son opcionales. Es obligatorio escoger una alternativa de la lista encerrada entre llaves ({ y }) y separada por barras verticales (|). En esta tabla se describe cada elemento.

Elemento	Description
Ws	Espacio en blanco opcional.
-	Un signo menos opcional, que indica un TimeSpan negativo.
d	Días comprendidos entre 0 y 10675199.
.	Un símbolo sensible a la cultura que separa días de horas. El formato invariable usa un carácter de punto (".").
hh	Horas, entre 0 y 23.
:	El símbolo separador de tiempo sensible a la cultura. El formato invariante utiliza un carácter de dos puntos (":").
milímetro	Minutos, entre 0 y 59.
ss	Segundos opcionales, entre 0 y 59.
.	Un símbolo sensible a la cultura que separa los segundos de las fracciones de un segundo. El formato invariable usa un carácter de punto (".").
ff	Fracciones opcionales de segundos, que constan de uno a siete dígitos decimales.

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

El método Parse(String) intenta interpretar s utilizando cada uno de los formatos específicos de la cultura actual.

método TryParse(String, IFormatProvider, TimeSpan)

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

El input parámetro contiene una especificación de intervalo de tiempo con el formato :

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

Elemento	Description
Ws	Espacio en blanco opcional.
-	Un signo menos opcional, que indica un TimeSpan negativo.
d	Días comprendidos entre 0 y 10675199.
.	Un símbolo sensible a la cultura que separa días de horas. El formato invariable usa un carácter de punto (".").
hh	Horas, entre 0 y 23.
:	El símbolo separador de tiempo sensible a la cultura. El formato invariante utiliza un carácter de dos puntos (":").
milímetro	Minutos, entre 0 y 59.
ss	Segundos opcionales, entre 0 y 59.
.	Un símbolo sensible a la cultura que separa los segundos de las fracciones de un segundo. El formato invariable usa un carácter de punto (".").
ff	Fracciones opcionales de segundos, que constan de uno a siete dígitos decimales.

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

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

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

Objeto CultureInfo que representa la referencia cultural cuyas convenciones de formato se van a reflejar en la cadena devuelta. El DateTimeFormatInfo objeto devuelto por la CultureInfo.DateTimeFormat propiedad define el formato de la cadena devuelta.
Objeto DateTimeFormatInfo que define el formato de la cadena devuelta.
Objeto personalizado que implementa la IFormatProvider interfaz . Su IFormatProvider.GetFormat método devuelve un DateTimeFormatInfo objeto que proporciona información de formato.

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

Se aplica a

TryParse(ReadOnlySpan<Char>, IFormatProvider, TimeSpan)

Source:: TimeSpan.cs

Source:: TimeSpan.cs

Source:: TimeSpan.cs

Source:: TimeSpan.cs

Source:: TimeSpan.cs

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

public:
 static bool TryParse(ReadOnlySpan<char> input, IFormatProvider ^ formatProvider, [Runtime::InteropServices::Out] TimeSpan % result) = ISpanParsable<TimeSpan>::TryParse;

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>

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

Cuando este método devuelve , contiene un objeto que representa el intervalo de tiempo especificado por inputo Zero si se produjo un error en la conversión. Este parámetro se pasa sin inicializar.

Devoluciones

Boolean

true es si input se ha convertido correctamente; de lo contrario, falsees . Esta operación devuelve false si el input parámetro es null o 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 un componente de días, horas, minutos o segundos fuera de su intervalo válido.

Se aplica a

TryParse(String, IFormatProvider, TimeSpan)

Source:: TimeSpan.cs

Source:: TimeSpan.cs

Source:: TimeSpan.cs

Source:: TimeSpan.cs

Source:: TimeSpan.cs

Convierte la representación de cadena de un intervalo de tiempo en su TimeSpan equivalente mediante la información de formato específica de la referencia cultural especificada 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(System::String ^ input, IFormatProvider ^ formatProvider, [Runtime::InteropServices::Out] TimeSpan % result) = IParsable<TimeSpan>::TryParse;

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

Devoluciones

Boolean

Ejemplos

En el ejemplo siguiente se define una matriz de CultureInfo objetos y se usa cada objeto en llamadas al TryParse(String, IFormatProvider, TimeSpan) método para analizar los 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

open System
open System.Globalization

let 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" |]
let cultures = 
    [| CultureInfo "en-US" 
       CultureInfo "ru-RU"
       CultureInfo.InvariantCulture |] 

let mutable header = String.Format("{0,-17}", "String")
for culture in cultures do
    header <- 
        if culture.Equals CultureInfo.InvariantCulture then
            String.Format("{0,20}", "Invariant")
        else
            String.Format("{0,20}", culture.Name)

printfn $"{header}\n"

for value in values do
    printf $"{value,-17}"
    for culture in cultures do
        match TimeSpan.TryParse(value, culture) with
        | true, interval -> 
            printfn $"{interval,20:c}"
        | _ ->
            printfn "%20s" "Unable to Parse"
// 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

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

' 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

Método TryParse(System.String,System.TimeSpan@)

El TimeSpan.TryParse(String, TimeSpan) método es similar al TimeSpan.Parse(String) método , salvo que 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 con el formato :

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

Elemento	Description
Ws	Espacio en blanco opcional.
-	Un signo menos opcional, que indica un TimeSpan negativo.
d	Días comprendidos entre 0 y 10675199.
.	Un símbolo sensible a la cultura que separa días de horas. El formato invariable usa un carácter de punto (".").
hh	Horas, entre 0 y 23.
:	El símbolo separador de tiempo sensible a la cultura. El formato invariante utiliza un carácter de dos puntos (":").
milímetro	Minutos, entre 0 y 59.
ss	Segundos opcionales, entre 0 y 59.
.	Un símbolo sensible a la cultura que separa los segundos de las fracciones de un segundo. El formato invariable usa un carácter de punto (".").
ff	Fracciones opcionales de segundos, que constan de uno a siete dígitos decimales.

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

El método Parse(String) intenta interpretar s utilizando cada uno de los formatos específicos de la cultura actual.

método TryParse(String, IFormatProvider, TimeSpan)

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

El input parámetro contiene una especificación de intervalo de tiempo con el formato :

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

Elemento	Description
Ws	Espacio en blanco opcional.
-	Un signo menos opcional, que indica un TimeSpan negativo.
d	Días comprendidos entre 0 y 10675199.
.	Un símbolo sensible a la cultura que separa días de horas. El formato invariable usa un carácter de punto (".").
hh	Horas, entre 0 y 23.
:	El símbolo separador de tiempo sensible a la cultura. El formato invariante utiliza un carácter de dos puntos (":").
milímetro	Minutos, entre 0 y 59.
ss	Segundos opcionales, entre 0 y 59.
.	Un símbolo sensible a la cultura que separa los segundos de las fracciones de un segundo. El formato invariable usa un carácter de punto (".").
ff	Fracciones opcionales de segundos, que constan de uno a siete dígitos decimales.

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

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

Objeto CultureInfo que representa la referencia cultural cuyas convenciones de formato se van a reflejar en la cadena devuelta. El DateTimeFormatInfo objeto devuelto por la CultureInfo.DateTimeFormat propiedad define el formato de la cadena devuelta.
Objeto DateTimeFormatInfo que define el formato de la cadena devuelta.
Objeto personalizado que implementa la IFormatProvider interfaz . Su IFormatProvider.GetFormat método devuelve un DateTimeFormatInfo objeto que proporciona información de formato.

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

Se aplica a

Comentarios

¿Le ha resultado útil esta página?