TimeSpan.TryParse Método

Definição

Converte a representação de cadeia de caracteres especificada de um intervalo de tempo em seu TimeSpan equivalente e retorna um valor que indica se a conversão foi bem-sucedida.Converts the specified string representation of a time interval to its TimeSpan equivalent and returns a value that indicates whether the conversion succeeded.

Sobrecargas

TryParse(ReadOnlySpan<Char>, IFormatProvider, TimeSpan)
TryParse(ReadOnlySpan<Char>, TimeSpan)
TryParse(String, TimeSpan)

Converte a representação de cadeia de caracteres de um intervalo de tempo no equivalente de TimeSpan e retorna um valor que indica se a conversão foi bem-sucedida.Converts the string representation of a time interval to its TimeSpan equivalent and returns a value that indicates whether the conversion succeeded.

TryParse(String, IFormatProvider, TimeSpan)

Converte a representação de cadeia de caracteres de um intervalo de tempo em seu TimeSpan equivalente usando as informações especificadas de formatação específicas da cultura e retorna um valor que indica se a conversão foi bem-sucedida.Converts the string representation of a time interval to its TimeSpan equivalent by using the specified culture-specific formatting information, and returns a value that indicates whether the conversion succeeded.

TryParse(ReadOnlySpan<Char>, IFormatProvider, TimeSpan)

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);
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

formatProvider
IFormatProvider
result
TimeSpan

Retornos

TryParse(ReadOnlySpan<Char>, TimeSpan)

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

result
TimeSpan

Retornos

TryParse(String, TimeSpan)

Converte a representação de cadeia de caracteres de um intervalo de tempo no equivalente de TimeSpan e retorna um valor que indica se a conversão foi bem-sucedida.Converts the string representation of a time interval to its TimeSpan equivalent and returns a value that indicates whether the conversion succeeded.

public:
 static bool TryParse(System::String ^ s, [Runtime::InteropServices::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 de caracteres que especifica o intervalo de tempo a ser convertido.A string that specifies the time interval to convert.

result
TimeSpan

Quando esse método retorna, contém um objeto que representa o intervalo de tempo especificado por s ou Zero caso a conversão falhe.When this method returns, contains an object that represents the time interval specified by s, or Zero if the conversion failed. Este parâmetro é passado não inicializado.This parameter is passed uninitialized.

Retornos

true caso s tenha sido convertido com êxito; do contrário, false.true if s was converted successfully; otherwise, false. Essa operação retornará false se o parâmetro s for null ou Empty, tiver um formato inválido, representar um intervalo de tempo menor que MinValue ou maior que MaxValue, ou tiver, pelo menos, um componente de dias, horas, minutos ou segundos fora do intervalo válido.This operation returns false if the s parameter is null or Empty, has an invalid format, represents a time interval that is less than MinValue or greater than MaxValue, or has at least one days, hours, minutes, or seconds component outside its valid range.

Exemplos

O exemplo a seguir usa TryParse o método para TimeSpan criar objetos de TimeSpan cadeias de caracteres válidas e para indicar quando a operação de análise falhou porque a cadeia de caracteres de intervalo de tempo é inválida.The following example uses the TryParse method to create TimeSpan objects from valid TimeSpan strings and to indicate when the parse operation has failed because the time span string is invalid.

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

Comentários

O TryParse método é como o TimeSpan.Parse(String) método, exceto pelo fato de que ele não lança uma exceção se a conversão falhar.The TryParse method is like the TimeSpan.Parse(String) method, except that it does not throw an exception if the conversion fails.

O s parâmetro contém uma especificação de intervalo de tempo no formato:The s parameter contains a time interval specification in the form:

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

Os elementos entre colchetes ([ e ]) são opcionais.Elements in square brackets ([ and ]) are optional. É necessária uma seleção da lista de alternativas entre chaves ({e}) e separadas por barras verticais (|).One selection from the list of alternatives enclosed in braces ({ and }) and separated by vertical bars (|) is required. A tabela a seguir descreve cada elemento.The following table describes each element.

ElementoElement DescriçãoDescription
wsws Espaço em branco opcional.Optional white space.
- Um sinal de subtração opcional, que indica um TimeSpan negativo.An optional minus sign, which indicates a negative TimeSpan.
dd Dias, variando de 0 a 10675199.Days, ranging from 0 to 10675199.
.. Um símbolo sensível à cultura que separa dias de horas.A culture-sensitive symbol that separates days from hours. O formato invariável usa um caractere de ponto final (".").The invariant format uses a period (".") character.
hhhh Horas, variando de 0 a 23.Hours, ranging from 0 to 23.
:: O símbolo separador de hora sensível à cultura.The culture-sensitive time separator symbol. O formato invariável usa um caractere de dois-pontos (":").The invariant format uses a colon (":") character.
mmmm Minutos, variando de 0 a 59.Minutes, ranging from 0 to 59.
ssss Segundos opcionais, variando de 0 a 59.Optional seconds, ranging from 0 to 59.
.. Um símbolo sensível à cultura que separa segundos de frações de um segundo.A culture-sensitive symbol that separates seconds from fractions of a second. O formato invariável usa um caractere de ponto final (".").The invariant format uses a period (".") character.
ffff Segundos fracionários opcionais, consistindo em um a sete dígitos decimais.Optional fractional seconds, consisting of one to seven decimal digits.

Os componentes do s devem especificar coletivamente um intervalo de tempo maior ou igual a TimeSpan.MinValue e menor ou igual a TimeSpan.MaxValue.The components of s must collectively specify a time interval that is greater than or equal to TimeSpan.MinValue and less than or equal to TimeSpan.MaxValue.

O Parse(String) método tenta analisar s usando cada um dos formatos específicos de cultura para a cultura atual.The Parse(String) method tries to parse s by using each of the culture-specific formats for the current culture.

Observações para os chamadoresNotes to callers

Em alguns casos, quando um componente de intervalo de tempo na cadeia de caracteres a ser analisado contém mais de sete dígitos, as operações de análise com êxito no .NET Framework 3,5 e versões anteriores podem falhar OverflowException e lançar um no .NET Framework 4 e versões posteriores.In some cases, when a time interval component in the string to be parsed contains more than seven digits, parsing operations that succeed in the .NET Framework 3.5 and earlier versions may fail and throw an OverflowException in the .NET Framework 4 and later versions. O exemplo a seguir ilustra esse cenário.The following example illustrates this scenario.

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'

TryParse(String, IFormatProvider, TimeSpan)

Converte a representação de cadeia de caracteres de um intervalo de tempo em seu TimeSpan equivalente usando as informações especificadas de formatação específicas da cultura e retorna um valor que indica se a conversão foi bem-sucedida.Converts the string representation of a time interval to its TimeSpan equivalent by using the specified culture-specific formatting information, and returns a value that indicates whether the conversion succeeded.

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);
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 de caracteres que especifica o intervalo de tempo a ser convertido.A string that specifies the time interval to convert.

formatProvider
IFormatProvider

Um objeto que fornece informações de formatação específicas de cultura.An object that supplies culture-specific formatting information.

result
TimeSpan

Quando esse método retorna, contém um objeto que representa o intervalo de tempo especificado por input ou Zero caso a conversão falhe.When this method returns, contains an object that represents the time interval specified by input, or Zero if the conversion failed. Este parâmetro é passado não inicializado.This parameter is passed uninitialized.

Retornos

true caso input tenha sido convertido com êxito; do contrário, false.true if input was converted successfully; otherwise, false. Essa operação retornará false se o parâmetro input for null ou Empty, tiver um formato inválido, representar um intervalo de tempo menor que MinValue ou maior que MaxValue, ou tiver, pelo menos, um componente de dias, horas, minutos ou segundos fora do intervalo válido.This operation returns false if the input parameter is null or Empty, has an invalid format, represents a time interval that is less than MinValue or greater than MaxValue, or has at least one days, hours, minutes, or seconds component outside its valid range.

Exemplos

O exemplo a seguir define uma matriz CultureInfo de objetos e usa cada objeto em chamadas para o TryParse(String, IFormatProvider, TimeSpan) método para analisar os elementos em uma matriz de cadeia de caracteres.The following example defines an array of CultureInfo objects, and uses each object in calls to the TryParse(String, IFormatProvider, TimeSpan) method to parse the elements in a string array. O exemplo ilustra como as convenções de uma cultura específica influenciam a operação de formatação.The example illustrates how the conventions of a specific culture influence the formatting operation.

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

Comentários

O TryParse(String, IFormatProvider, TimeSpan) método é como o Parse(String, IFormatProvider) método, exceto pelo fato de que ele não lança uma exceção se a conversão falhar.The TryParse(String, IFormatProvider, TimeSpan) method is like the Parse(String, IFormatProvider) method, except that it does not throw an exception if the conversion fails.

O input parâmetro contém uma especificação de intervalo de tempo no formato:The input parameter contains a time interval specification in the form:

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

Os elementos entre colchetes ([ e ]) são opcionais.Elements in square brackets ([ and ]) are optional. É necessária uma seleção da lista de alternativas entre chaves ({e}) e separadas por barras verticais (|).One selection from the list of alternatives enclosed in braces ({ and }) and separated by vertical bars (|) is required. A tabela a seguir descreve cada elemento.The following table describes each element.

ElementoElement DescriçãoDescription
wsws Espaço em branco opcional.Optional white space.
- Um sinal de subtração opcional, que indica um TimeSpan negativo.An optional minus sign, which indicates a negative TimeSpan.
dd Dias, variando de 0 a 10675199.Days, ranging from 0 to 10675199.
.. Um símbolo sensível à cultura que separa dias de horas.A culture-sensitive symbol that separates days from hours. O formato invariável usa um caractere de ponto final (".").The invariant format uses a period (".") character.
hhhh Horas, variando de 0 a 23.Hours, ranging from 0 to 23.
:: O símbolo separador de hora sensível à cultura.The culture-sensitive time separator symbol. O formato invariável usa um caractere de dois-pontos (":").The invariant format uses a colon (":") character.
mmmm Minutos, variando de 0 a 59.Minutes, ranging from 0 to 59.
ssss Segundos opcionais, variando de 0 a 59.Optional seconds, ranging from 0 to 59.
.. Um símbolo sensível à cultura que separa segundos de frações de um segundo.A culture-sensitive symbol that separates seconds from fractions of a second. O formato invariável usa um caractere de ponto final (".").The invariant format uses a period (".") character.
ffff Segundos fracionários opcionais, consistindo em um a sete dígitos decimais.Optional fractional seconds, consisting of one to seven decimal digits.

Os componentes do input devem especificar coletivamente um intervalo de tempo maior ou igual a TimeSpan.MinValue e menor ou igual a TimeSpan.MaxValue.The components of input must collectively specify a time interval that is greater than or equal to TimeSpan.MinValue and less than or equal to TimeSpan.MaxValue.

O TryParse(String, IFormatProvider, TimeSpan) método tenta analisar input usando cada um dos formatos específicos de cultura para a cultura especificada por formatProvider.The TryParse(String, IFormatProvider, TimeSpan) method tries to parse input by using each of the culture-specific formats for the culture specified by formatProvider.

O formatProvider parâmetro é uma IFormatProvider implementação que fornece informações específicas de cultura sobre o formato da cadeia de caracteres retornada.The formatProvider parameter is an IFormatProvider implementation that provides culture-specific information about the format of the returned string. O parâmetro formatProvider pode ser um dos seguintes:The formatProvider parameter can be any of the following:

Caso formatProvider seja null, o objeto DateTimeFormatInfo que está associado à cultura atual é usado.If formatProvider is null, the DateTimeFormatInfo object that is associated with the current culture is used.

Observações para os chamadoresNotes to callers

Em alguns casos, quando um componente de intervalo de tempo na cadeia de caracteres a ser analisado contém mais de sete dígitos, as operações de análise com êxito e retorno no .NET Framework 3,5 e versões anteriores podem falhar e retornar na estrutura The.net 4 e versões posteriores, o exemplo a seguir ilustra esse cenário.In some cases, when a time interval component in the string to be parsed contains more than seven digits, parsing operations that succeed and return in the .NET Framework 3.5 and earlier versions may fail and return in the.NET Framework 4 and later versions, The following example illustrates this scenario.

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'

Aplica-se a