TimeSpan.TryParse Método

Definição

Espaço de Nomes:: System

Assemblagens:: netstandard.dll, System.Runtime.dll

Assemblagem:: System.Runtime.dll

Assemblagem:: netstandard.dll

Assemblagens:: mscorlib.dll, System.Runtime.dll

Assemblagem:: mscorlib.dll

Importante

Algumas informações dizem respeito a um produto pré-lançado que pode ser substancialmente modificado antes de ser lançado. A Microsoft não faz garantias, de forma expressa ou implícita, em relação à informação aqui apresentada.

Converte a representação de cadeia especificada de um intervalo de tempo para o seu TimeSpan equivalente e devolve um valor que indica se a conversão foi bem-sucedida.

Sobrecargas

Name	Descrição
TryParse(ReadOnlySpan<Char>, TimeSpan)	Converte a representação do span de um intervalo de tempo para o seu TimeSpan equivalente e devolve um valor que indica se a conversão foi bem-sucedida.
TryParse(String, TimeSpan)	Converte a representação da cadeia de um intervalo de tempo para o seu TimeSpan equivalente e devolve um valor que indica se a conversão foi bem-sucedida.
TryParse(ReadOnlySpan<Char>, IFormatProvider, TimeSpan)	Converte a representação de intervalo de tempo para o seu TimeSpan equivalente usando a informação de formatação específica da cultura e retorna um valor que indica se a conversão teve sucesso.
TryParse(String, IFormatProvider, TimeSpan)	Converte a representação da cadeia de um intervalo de tempo para o seu TimeSpan equivalente usando a informação de formatação específica da cultura especificada, e devolve um valor que indica se a conversão foi bem-sucedida.

TryParse(ReadOnlySpan<Char>, TimeSpan)

Origem:: TimeSpan.cs

Origem:: TimeSpan.cs

Origem:: TimeSpan.cs

Origem:: TimeSpan.cs

Origem:: TimeSpan.cs

Converte a representação do span de um intervalo de tempo para o seu TimeSpan equivalente e devolve um valor que indica se a conversão foi bem-sucedida.

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>

Um intervalo que contém os caracteres que representam o intervalo de tempo a converter.

result: TimeSpan

Quando este método retorna, contém um objeto que representa o intervalo de tempo especificado por s, ou Zero se a conversão falhou. Este parâmetro é passado sem inicializar.

Devoluções

Boolean

true se s foi convertido com sucesso; caso contrário, false. Esta operação retorna false se o s parâmetro for null ou Empty, tiver um formato inválido, representar um intervalo de tempo menor que TimeSpan.MinValue ou maior que TimeSpan.MaxValue, ou tiver pelo menos um componente de dias, horas, minutos ou segundos fora do seu intervalo válido.

Aplica-se a

TryParse(String, TimeSpan)

Origem:: TimeSpan.cs

Origem:: TimeSpan.cs

Origem:: TimeSpan.cs

Origem:: TimeSpan.cs

Origem:: TimeSpan.cs

Converte a representação da cadeia de um intervalo de tempo para o seu TimeSpan equivalente e devolve um valor que indica se a conversão foi bem-sucedida.

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

Uma cadeia que especifica o intervalo de tempo a converter.

result: TimeSpan

Quando este método retorna, contém um objeto que representa o intervalo de tempo especificado por s, ou Zero se a conversão falhou. Este parâmetro é passado sem inicializar.

Devoluções

Boolean

Exemplos

O exemplo seguinte utiliza o TryParse método para criar TimeSpan objetos a partir de cadeias válidas TimeSpan e para indicar quando a operação de análise falhou porque a cadeia de intervalo de tempo é invá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

Observações

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

O TimeSpan.TryParse(String, TimeSpan) método é como o TimeSpan.Parse(String) método, exceto que ele não lança uma exceção se a conversão falhar.

O s parâmetro contém uma especificação de intervalo de tempo no formato:

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

Os elementos entre parênteses retos ([ e ]) são opcionais. Uma seleção da lista de alternativas, que está entre chaves ({ e }) e separada por barras verticais (|), é necessária. A tabela a seguir descreve cada elemento.

Elemento	Description
ws	Espaço em branco opcional.
-	Um sinal de menos opcional, que indica um valor negativo TimeSpan.
d	Dias, variando de 0 a 10675199.
.	Um símbolo culturalmente sensível que separa os dias das horas. O formato invariante usa um caractere de ponto (".").
hh	Horário, variando de 0 a 23.
:	O símbolo do separador de tempo adaptado à cultura. O formato invariante usa o caractere dois pontos (":").
mm	Minutos, variando de 0 a 59.
SS	Segundos opcionais, variando de 0 a 59.
.	Um símbolo sensível à cultura que separa segundos de frações de segundo. O formato invariante usa um caractere de ponto (".").
ff	Segundos fracionários opcionais, consistindo de um a sete dígitos decimais.

Os componentes de s devem coletivamente especificar um intervalo de tempo maior ou igual a TimeSpan.MinValue e menor ou igual a TimeSpan.MaxValue.

O Parse(String) método tenta analisar s usando cada um dos formatos específicos da cultura para a cultura atual.

TryParse(String, IFormatProvider, TimeSpan) método

O TryParse(String, IFormatProvider, TimeSpan) método é como o Parse(String, IFormatProvider) método, exceto que ele não lança uma exceção se a conversão falhar.

O input parâmetro contém uma especificação de intervalo de tempo no formato:

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

Elemento	Description
ws	Espaço em branco opcional.
-	Um sinal de menos opcional, que indica um valor negativo TimeSpan.
d	Dias, variando de 0 a 10675199.
.	Um símbolo culturalmente sensível que separa os dias das horas. O formato invariante usa um caractere de ponto (".").
hh	Horário, variando de 0 a 23.
:	O símbolo do separador de tempo adaptado à cultura. O formato invariante usa o caractere dois pontos (":").
mm	Minutos, variando de 0 a 59.
SS	Segundos opcionais, variando de 0 a 59.
.	Um símbolo sensível à cultura que separa segundos de frações de segundo. O formato invariante usa um caractere de ponto (".").
ff	Segundos fracionários opcionais, consistindo de um a sete dígitos decimais.

Os componentes de input devem especificar coletivamente um intervalo de tempo maior ou igual a TimeSpan.MinValue e menor ou igual a TimeSpan.MaxValue.

O TryParse(String, IFormatProvider, TimeSpan) método tenta analisar input usando cada um dos formatos específicos da cultura para a cultura especificada pelo formatProvider.

O formatProvider parâmetro é uma IFormatProvider implementação que fornece informações específicas da cultura sobre o formato da cadeia de caracteres retornada. O formatProvider parâmetro pode ser qualquer um dos seguintes:

Um CultureInfo objeto que representa a cultura cujas convenções de formatação devem ser refletidas na cadeia de caracteres retornada. O DateTimeFormatInfo objeto retornado pela CultureInfo.DateTimeFormat propriedade define a formatação da cadeia de caracteres retornada.
Um DateTimeFormatInfo objeto que define a formatação da cadeia de caracteres retornada.
Um objeto personalizado que implementa a IFormatProvider interface. O método IFormatProvider.GetFormat retorna um objeto DateTimeFormatInfo que fornece informações de formatação.

Se formatProvider é null, o objeto DateTimeFormatInfo associado à cultura atual é usado.

Aplica-se a

TryParse(ReadOnlySpan<Char>, IFormatProvider, TimeSpan)

Origem:: TimeSpan.cs

Origem:: TimeSpan.cs

Origem:: TimeSpan.cs

Origem:: TimeSpan.cs

Origem:: TimeSpan.cs

Converte a representação de intervalo de tempo para o seu TimeSpan equivalente usando a informação de formatação específica da cultura e retorna um valor que indica se a conversão teve sucesso.

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>

Um intervalo que contém os caracteres que representam o intervalo de tempo a converter.

formatProvider: IFormatProvider

Um objeto que fornece informação de formatação específica para cada cultura.

result: TimeSpan

Quando este método retorna, contém um objeto que representa o intervalo de tempo especificado por input, ou Zero se a conversão falhou. Este parâmetro é passado sem inicializar.

Devoluções

Boolean

true se input foi convertido com sucesso; caso contrário, false. Esta operação retorna false se o input parâmetro for null ou Empty, tiver um formato inválido, representar um intervalo de tempo menor que TimeSpan.MinValue ou maior que TimeSpan.MaxValue, ou tiver pelo menos um componente de dias, horas, minutos ou segundos fora do seu intervalo válido.

Aplica-se a

TryParse(String, IFormatProvider, TimeSpan)

Origem:: TimeSpan.cs

Origem:: TimeSpan.cs

Origem:: TimeSpan.cs

Origem:: TimeSpan.cs

Origem:: TimeSpan.cs

Converte a representação da cadeia de um intervalo de tempo para o seu TimeSpan equivalente usando a informação de formatação específica da cultura especificada, e devolve um valor que indica se a conversão foi bem-sucedida.

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

Uma cadeia que especifica o intervalo de tempo a converter.

formatProvider: IFormatProvider

Um objeto que fornece informação de formatação específica para cada cultura.

result: TimeSpan

Quando este método retorna, contém um objeto que representa o intervalo de tempo especificado por input, ou Zero se a conversão falhou. Este parâmetro é passado sem inicializar.

Devoluções

Boolean

Exemplos

O exemplo seguinte define um array de CultureInfo objetos e usa cada objeto em chamadas ao TryParse(String, IFormatProvider, TimeSpan) método para analisar os elementos num array de strings. O exemplo ilustra como as convenções de uma cultura específica influenciam a operação de formatação.

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

Observações

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

O TimeSpan.TryParse(String, TimeSpan) método é como o TimeSpan.Parse(String) método, exceto que ele não lança uma exceção se a conversão falhar.

O s parâmetro contém uma especificação de intervalo de tempo no formato:

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

Elemento	Description
ws	Espaço em branco opcional.
-	Um sinal de menos opcional, que indica um valor negativo TimeSpan.
d	Dias, variando de 0 a 10675199.
.	Um símbolo culturalmente sensível que separa os dias das horas. O formato invariante usa um caractere de ponto (".").
hh	Horário, variando de 0 a 23.
:	O símbolo do separador de tempo adaptado à cultura. O formato invariante usa o caractere dois pontos (":").
mm	Minutos, variando de 0 a 59.
SS	Segundos opcionais, variando de 0 a 59.
.	Um símbolo sensível à cultura que separa segundos de frações de segundo. O formato invariante usa um caractere de ponto (".").
ff	Segundos fracionários opcionais, consistindo de um a sete dígitos decimais.

Os componentes de s devem coletivamente especificar um intervalo de tempo maior ou igual a TimeSpan.MinValue e menor ou igual a TimeSpan.MaxValue.

O Parse(String) método tenta analisar s usando cada um dos formatos específicos da cultura para a cultura atual.

TryParse(String, IFormatProvider, TimeSpan) método

O TryParse(String, IFormatProvider, TimeSpan) método é como o Parse(String, IFormatProvider) método, exceto que ele não lança uma exceção se a conversão falhar.

O input parâmetro contém uma especificação de intervalo de tempo no formato:

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

Elemento	Description
ws	Espaço em branco opcional.
-	Um sinal de menos opcional, que indica um valor negativo TimeSpan.
d	Dias, variando de 0 a 10675199.
.	Um símbolo culturalmente sensível que separa os dias das horas. O formato invariante usa um caractere de ponto (".").
hh	Horário, variando de 0 a 23.
:	O símbolo do separador de tempo adaptado à cultura. O formato invariante usa o caractere dois pontos (":").
mm	Minutos, variando de 0 a 59.
SS	Segundos opcionais, variando de 0 a 59.
.	Um símbolo sensível à cultura que separa segundos de frações de segundo. O formato invariante usa um caractere de ponto (".").
ff	Segundos fracionários opcionais, consistindo de um a sete dígitos decimais.

Os componentes de input devem especificar coletivamente um intervalo de tempo maior ou igual a TimeSpan.MinValue e menor ou igual a TimeSpan.MaxValue.

O TryParse(String, IFormatProvider, TimeSpan) método tenta analisar input usando cada um dos formatos específicos da cultura para a cultura especificada pelo formatProvider.

Um CultureInfo objeto que representa a cultura cujas convenções de formatação devem ser refletidas na cadeia de caracteres retornada. O DateTimeFormatInfo objeto retornado pela CultureInfo.DateTimeFormat propriedade define a formatação da cadeia de caracteres retornada.
Um DateTimeFormatInfo objeto que define a formatação da cadeia de caracteres retornada.
Um objeto personalizado que implementa a IFormatProvider interface. O método IFormatProvider.GetFormat retorna um objeto DateTimeFormatInfo que fornece informações de formatação.

Se formatProvider é null, o objeto DateTimeFormatInfo associado à cultura atual é usado.

Aplica-se a

Comentários

Esta página foi útil?