TimeSpan.TryParse TimeSpan.TryParse TimeSpan.TryParse TimeSpan.TryParse Method

Definizione

Converte la rappresentazione di stringa specificata di un intervallo di tempo nell'equivalente TimeSpan e restituisce un valore che indica se la conversione è stata eseguita correttamente.Converts the specified string representation of a time interval to its TimeSpan equivalent and returns a value that indicates whether the conversion succeeded.

Overload

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

Converte la rappresentazione di stringa di un intervallo di tempo nell'equivalente TimeSpan e restituisce un valore che indica se la conversione è stata eseguita correttamente.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) TryParse(String, IFormatProvider, TimeSpan) TryParse(String, IFormatProvider, TimeSpan) TryParse(String, IFormatProvider, TimeSpan)

Converte la rappresentazione di stringa di un intervallo di tempo nell'equivalente TimeSpan usando le informazioni di formattazione specifiche delle impostazioni cultura indicate e restituisce un valore che indica se la conversione è stata eseguita correttamente.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) TryParse(ReadOnlySpan<Char>, IFormatProvider, TimeSpan) TryParse(ReadOnlySpan<Char>, IFormatProvider, TimeSpan) 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 *  -> bool
Public Shared Function TryParse (input As ReadOnlySpan(Of Char), formatProvider As IFormatProvider, ByRef result As TimeSpan) As Boolean

Parametri

Restituisce

TryParse(ReadOnlySpan<Char>, TimeSpan) TryParse(ReadOnlySpan<Char>, TimeSpan) TryParse(ReadOnlySpan<Char>, TimeSpan) 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> *  -> bool
Public Shared Function TryParse (s As ReadOnlySpan(Of Char), ByRef result As TimeSpan) As Boolean

Parametri

Restituisce

TryParse(String, TimeSpan) TryParse(String, TimeSpan) TryParse(String, TimeSpan) TryParse(String, TimeSpan)

Converte la rappresentazione di stringa di un intervallo di tempo nell'equivalente TimeSpan e restituisce un valore che indica se la conversione è stata eseguita correttamente.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 *  -> bool
Public Shared Function TryParse (s As String, ByRef result As TimeSpan) As Boolean

Parametri

s
String String String String

Stringa che specifica l'intervallo di tempo da convertire.A string that specifies the time interval to convert.

result
TimeSpan TimeSpan TimeSpan TimeSpan

Quando questo metodo viene restituito, contiene un oggetto che rappresenta l'intervallo di tempo specificato da s o Zero in caso di conversione non riuscita.When this method returns, contains an object that represents the time interval specified by s, or Zero if the conversion failed. Questo parametro viene passato non inizializzato.This parameter is passed uninitialized.

Restituisce

true se s è stato convertito correttamente; in caso contrario, false.true if s was converted successfully; otherwise, false. Questa operazione restituisce false se il parametro s è null o Empty, presenta un formato non valido, rappresenta un intervallo di tempo minore di MinValue o maggiore di MaxValue o almeno un componente giorni, ore, minuti o secondi non è compreso nel relativo intervallo valido.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.

Esempi

L'esempio seguente usa il TryParse metodo per creare TimeSpan gli oggetti da valido TimeSpan stringhe e per indicare quando l'operazione di analisi non è riuscita perché la stringa di intervallo di tempo non è valida.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

Commenti

Il TryParse metodo è simile al TimeSpan.Parse(String) metodo, ad eccezione del fatto che non genera un'eccezione se la conversione non riesce.The TryParse method is like the TimeSpan.Parse(String) method, except that it does not throw an exception if the conversion fails.

Il s parametro contiene una specifica di intervallo di tempo nel 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]

Gli elementi tra parentesi quadre ([e]) sono facoltativi.Elements in square brackets ([ and ]) are optional. Una selezione dall'elenco delle alternative racchiuso tra parentesi graffe ({e}) e separati da barre verticali (|) è obbligatorio.One selection from the list of alternatives enclosed in braces ({ and }) and separated by vertical bars (|) is required. La tabella seguente descrive i singoli elementi.The following table describes each element.

ElementoElement DescrizioneDescription
wsws Spazio vuoto facoltativo.Optional white space.
- Un segno meno (-) facoltativo, che indica un valore negativo TimeSpan.An optional minus sign, which indicates a negative TimeSpan.
dd Giorni, compreso tra 0 e 10675199.Days, ranging from 0 to 10675199.
.. Un simbolo di distinzione delle impostazioni cultura che separa i giorni dalle ore.A culture-sensitive symbol that separates days from hours. Formato della lingua inglese viene utilizzato un punto (".") caratteri.The invariant format uses a period (".") character.
hhhh Ore, compreso tra 0 e 23.Hours, ranging from 0 to 23.
:: Il simbolo di separatore di ora distinzione delle impostazioni cultura.The culture-sensitive time separator symbol. Formato invariant Usa i due punti (":") caratteri.The invariant format uses a colon (":") character.
mmmm Minuti, compreso tra 0 e 59.Minutes, ranging from 0 to 59.
ssss Facoltativi secondi, compreso tra 0 e 59.Optional seconds, ranging from 0 to 59.
.. Un simbolo di distinzione delle impostazioni cultura che separa i secondi dalle frazioni di secondo.A culture-sensitive symbol that separates seconds from fractions of a second. Formato della lingua inglese viene utilizzato un punto (".") caratteri.The invariant format uses a period (".") character.
ffff Frazioni di secondo facoltativi, costituita da uno a sette cifre decimali.Optional fractional seconds, consisting of one to seven decimal digits.

I componenti di s collettivamente deve specificare un intervallo di tempo che è maggiore o uguale a TimeSpan.MinValue e minore o uguale 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.

Il Parse(String) metodo tenta di analizzare s usando ognuno dei formati di specifiche delle impostazioni cultura per le impostazioni cultura correnti.The Parse(String) method tries to parse s by using each of the culture-specific formats for the current culture.

Note per i chiamantiNotes to callers

In alcuni casi, quando un componente dell'intervallo di tempo nella stringa da analizzare contiene più di sette cifre, operazioni che abbia esito positivo in .NET Framework 3.5 e versioni precedenti di analisi potrebbero avere esito negativo e generare un OverflowException in .NET Framework 4 e versioni successive.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. L'esempio seguente illustra questo scenario.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) TryParse(String, IFormatProvider, TimeSpan) TryParse(String, IFormatProvider, TimeSpan) TryParse(String, IFormatProvider, TimeSpan)

Converte la rappresentazione di stringa di un intervallo di tempo nell'equivalente TimeSpan usando le informazioni di formattazione specifiche delle impostazioni cultura indicate e restituisce un valore che indica se la conversione è stata eseguita correttamente.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 *  -> bool
Public Shared Function TryParse (input As String, formatProvider As IFormatProvider, ByRef result As TimeSpan) As Boolean

Parametri

input
String String String String

Stringa che specifica l'intervallo di tempo da convertire.A string that specifies the time interval to convert.

formatProvider
IFormatProvider IFormatProvider IFormatProvider IFormatProvider

Oggetto che fornisce informazioni di formattazione specifiche delle impostazioni cultura.An object that supplies culture-specific formatting information.

result
TimeSpan TimeSpan TimeSpan TimeSpan

Quando questo metodo viene restituito, contiene un oggetto che rappresenta l'intervallo di tempo specificato da input o Zero in caso di conversione non riuscita.When this method returns, contains an object that represents the time interval specified by input, or Zero if the conversion failed. Questo parametro viene passato non inizializzato.This parameter is passed uninitialized.

Restituisce

true se input è stato convertito correttamente; in caso contrario, false.true if input was converted successfully; otherwise, false. Questa operazione restituisce false se il parametro input è null o Empty, presenta un formato non valido, rappresenta un intervallo di tempo minore di MinValue o maggiore di MaxValue o almeno un componente giorni, ore, minuti o secondi non è compreso nel relativo intervallo valido.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.

Esempi

L'esempio seguente definisce una matrice di CultureInfo oggetti e viene utilizzato ogni oggetto nelle chiamate al TryParse(String, IFormatProvider, TimeSpan) metodo per analizzare gli elementi in una matrice di stringhe.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. Nell'esempio viene illustrato come le convenzioni delle impostazioni cultura specifiche influenzano l'operazione di formattazione.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

Commenti

Il TryParse(String, IFormatProvider, TimeSpan) metodo è simile al Parse(String, IFormatProvider) metodo, ad eccezione del fatto che non genera un'eccezione se la conversione non riesce.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.

Il input parametro contiene una specifica di intervallo di tempo nel 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]

Gli elementi tra parentesi quadre ([e]) sono facoltativi.Elements in square brackets ([ and ]) are optional. Una selezione dall'elenco delle alternative racchiuso tra parentesi graffe ({e}) e separati da barre verticali (|) è obbligatorio.One selection from the list of alternatives enclosed in braces ({ and }) and separated by vertical bars (|) is required. La tabella seguente descrive i singoli elementi.The following table describes each element.

ElementoElement DescrizioneDescription
wsws Spazio vuoto facoltativo.Optional white space.
- Un segno meno (-) facoltativo, che indica un valore negativo TimeSpan.An optional minus sign, which indicates a negative TimeSpan.
dd Giorni, compreso tra 0 e 10675199.Days, ranging from 0 to 10675199.
.. Un simbolo di distinzione delle impostazioni cultura che separa i giorni dalle ore.A culture-sensitive symbol that separates days from hours. Formato della lingua inglese viene utilizzato un punto (".") caratteri.The invariant format uses a period (".") character.
hhhh Ore, compreso tra 0 e 23.Hours, ranging from 0 to 23.
:: Il simbolo di separatore di ora distinzione delle impostazioni cultura.The culture-sensitive time separator symbol. Formato invariant Usa i due punti (":") caratteri.The invariant format uses a colon (":") character.
mmmm Minuti, compreso tra 0 e 59.Minutes, ranging from 0 to 59.
ssss Facoltativi secondi, compreso tra 0 e 59.Optional seconds, ranging from 0 to 59.
.. Un simbolo di distinzione delle impostazioni cultura che separa i secondi dalle frazioni di secondo.A culture-sensitive symbol that separates seconds from fractions of a second. Formato della lingua inglese viene utilizzato un punto (".") caratteri.The invariant format uses a period (".") character.
ffff Frazioni di secondo facoltativi, costituita da uno a sette cifre decimali.Optional fractional seconds, consisting of one to seven decimal digits.

I componenti di input collettivamente deve specificare un intervallo di tempo che è maggiore o uguale a TimeSpan.MinValue e minore o uguale 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.

Il TryParse(String, IFormatProvider, TimeSpan) metodo tenta di analizzare input usando ognuno dei formati di specifiche delle impostazioni cultura per le impostazioni cultura specificate da 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.

Il formatProvider parametro è un IFormatProvider implementazione che fornisce informazioni specifiche delle impostazioni cultura sul formato della stringa restituita.The formatProvider parameter is an IFormatProvider implementation that provides culture-specific information about the format of the returned string. Il formatProvider parametro può essere uno dei seguenti:The formatProvider parameter can be any of the following:

Se formatProvider viene null, il DateTimeFormatInfo viene usato l'oggetto associato a impostazioni cultura correnti.If formatProvider is null, the DateTimeFormatInfo object that is associated with the current culture is used.

Note per i chiamantiNotes to callers

In alcuni casi, quando un componente dell'intervallo di tempo nella stringa da analizzare contiene più di sette cifre, operazioni di analisi che abbia esito positivo e restituiscono in .NET Framework 3.5 e versioni precedenti versioni potrebbero non riuscire e restituire in.NET Framework le versioni 4 e versioni successive, l'esempio seguente illustra questo scenario.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'

Si applica a