TimeSpan.TryParse Metodo

Definizione

Spazio dei nomi:: System

Assembly:: netstandard.dll, System.Runtime.dll

Assembly:: System.Runtime.dll

Assembly:: netstandard.dll

Assembly:: mscorlib.dll, System.Runtime.dll

Assembly:: mscorlib.dll

Importante

Alcune informazioni sono relative alla release non definitiva del prodotto, che potrebbe subire modifiche significative prima della release definitiva. Microsoft non riconosce alcuna garanzia, espressa o implicita, in merito alle informazioni qui fornite.

Converte la rappresentazione di stringa specificata di un intervallo di tempo nell'equivalente TimeSpan e restituisce un valore che indica se la conversione ha avuto esito positivo.

Overload

Nome	Descrizione
TryParse(ReadOnlySpan<Char>, TimeSpan)	Converte la rappresentazione di intervallo di un intervallo di tempo nell'equivalente TimeSpan e restituisce un valore che indica se la conversione ha avuto esito positivo.
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 è riuscita.
TryParse(ReadOnlySpan<Char>, IFormatProvider, TimeSpan)	Converte la rappresentazione di intervallo di un intervallo di tempo nell'equivalente TimeSpan utilizzando le informazioni di formattazione specifiche delle impostazioni cultura specificate e restituisce un valore che indica se la conversione ha avuto esito positivo.
TryParse(String, IFormatProvider, TimeSpan)	Converte la rappresentazione di stringa di un intervallo di tempo nell'equivalente TimeSpan utilizzando le informazioni di formattazione specifiche delle impostazioni cultura specificate e restituisce un valore che indica se la conversione ha avuto esito positivo.

TryParse(ReadOnlySpan<Char>, TimeSpan)

Origine:: TimeSpan.cs

Origine:: TimeSpan.cs

Origine:: TimeSpan.cs

Origine:: TimeSpan.cs

Origine:: TimeSpan.cs

Converte la rappresentazione di intervallo di un intervallo di tempo nell'equivalente TimeSpan e restituisce un valore che indica se la conversione ha avuto esito positivo.

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

Parametri

s: ReadOnlySpan<Char>

Intervallo contenente i caratteri che rappresentano l'intervallo di tempo da convertire.

result: TimeSpan

Quando termina, questo metodo contiene un oggetto che rappresenta l'intervallo di tempo specificato da so Zero se la conversione non è riuscita. Questo parametro viene passato non inizializzato.

Valori restituiti

Boolean

true se s è stata convertita correttamente; in caso contrario, false. Questa operazione restituisce false se il s parametro è null o Empty, ha un formato non valido, rappresenta un intervallo di tempo minore di TimeSpan.MinValue o maggiore di TimeSpan.MaxValue o ha almeno un componente giorni, ore, minuti o secondi al di fuori dell'intervallo valido.

Si applica a

TryParse(String, TimeSpan)

Origine:: TimeSpan.cs

Origine:: TimeSpan.cs

Origine:: TimeSpan.cs

Origine:: TimeSpan.cs

Origine:: TimeSpan.cs

Converte la rappresentazione di stringa di un intervallo di tempo nell'equivalente TimeSpan e restituisce un valore che indica se la conversione è riuscita.

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

Parametri

s: String

Stringa che specifica l'intervallo di tempo da convertire.

result: TimeSpan

Quando termina, questo metodo contiene un oggetto che rappresenta l'intervallo di tempo specificato da so Zero se la conversione non è riuscita. Questo parametro viene passato non inizializzato.

Valori restituiti

Boolean

Esempio

Nell'esempio seguente viene utilizzato il TryParse metodo per creare TimeSpan oggetti da stringhe valide TimeSpan e per indicare quando l'operazione di analisi non è riuscita perché la stringa dell'intervallo di tempo non è valida.

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

Commenti

Metodo TryParse(System.String,System.TimeSpan@)

Il metodo TimeSpan.TryParse(String, TimeSpan) è simile al metodo TimeSpan.Parse(String), ad eccezione del fatto che non genera un'eccezione se la conversione non riesce.

Il parametro s contiene una specifica dell'intervallo di tempo nel formato :

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

Gli elementi tra parentesi quadre ([ e ]) sono facoltativi. È necessaria una selezione dall'elenco di alternative racchiuse tra parentesi graffe ({ e }) e separate da barre verticali (|). La tabella seguente descrive i singoli elementi.

Elemento	Description
Ws	Spazio vuoto facoltativo.
-	Un segno meno opzionale, che indica un TimeSpannegativo.
d	Giorni, compresi tra 0 e 10675199.
.	Un simbolo sensibile alla cultura che separa i giorni dalle ore. Il formato invariante usa un carattere punto (".").
Hh	Ore, comprese tra 0 e 23.
:	Simbolo separatore temporale sensibile alla cultura. Il formato invariante usa il carattere due punti (":").
millimetro	Minuti, compresi tra 0 e 59.
ss	Secondi facoltativi, compresi tra 0 e 59.
.	Simbolo sensibile al contesto culturale che separa i secondi dalle frazioni di secondo. Il formato invariante usa un carattere punto (".").
Ff	Secondi frazionari facoltativi, costituiti da una a sette cifre decimali.

I componenti di s devono specificare collettivamente un intervallo di tempo maggiore o uguale a TimeSpan.MinValue e minore o uguale a TimeSpan.MaxValue.

Il metodo Parse(String) tenta di interpretare s utilizzando ciascuno dei formati specifici per le impostazioni culturali correnti.

Metodo TryParse(String, IFormatProvider, TimeSpan)

Il metodo TryParse(String, IFormatProvider, TimeSpan) è simile al metodo Parse(String, IFormatProvider), ad eccezione del fatto che non genera un'eccezione se la conversione non riesce.

Il parametro input contiene una specifica dell'intervallo di tempo nel formato :

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

Elemento	Description
Ws	Spazio vuoto facoltativo.
-	Un segno meno opzionale, che indica un TimeSpannegativo.
d	Giorni, compresi tra 0 e 10675199.
.	Un simbolo sensibile alla cultura che separa i giorni dalle ore. Il formato invariante usa un carattere punto (".").
Hh	Ore, comprese tra 0 e 23.
:	Simbolo separatore temporale sensibile alla cultura. Il formato invariante usa il carattere due punti (":").
millimetro	Minuti, compresi tra 0 e 59.
ss	Secondi facoltativi, compresi tra 0 e 59.
.	Simbolo sensibile al contesto culturale che separa i secondi dalle frazioni di secondo. Il formato invariante usa un carattere punto (".").
Ff	Secondi frazionari facoltativi, costituiti da una a sette cifre decimali.

I componenti di input devono specificare collettivamente un intervallo di tempo maggiore o uguale a TimeSpan.MinValue e minore o uguale a TimeSpan.MaxValue.

Il metodo TryParse(String, IFormatProvider, TimeSpan) tenta di analizzare input usando ciascuno dei formati specifici delle impostazioni culturali per quella specificata da formatProvider.

Il parametro formatProvider è un'implementazione IFormatProvider che fornisce informazioni specifiche delle impostazioni culturali del formato della stringa restituita. Il parametro formatProvider può essere uno dei seguenti:

Oggetto CultureInfo che rappresenta le impostazioni culturali di cui le convenzioni di formattazione devono riflettersi nella stringa restituita. L'oggetto DateTimeFormatInfo restituito dalla proprietà CultureInfo.DateTimeFormat definisce la formattazione della stringa restituita.
Oggetto DateTimeFormatInfo che definisce la formattazione della stringa restituita.
Oggetto personalizzato che implementa l'interfaccia IFormatProvider. Il metodo IFormatProvider.GetFormat restituisce un oggetto DateTimeFormatInfo che fornisce informazioni di formattazione.

Se formatProvider è null, viene utilizzato l'oggetto DateTimeFormatInfo associato alla cultura attuale.

Si applica a

TryParse(ReadOnlySpan<Char>, IFormatProvider, TimeSpan)

Origine:: TimeSpan.cs

Origine:: TimeSpan.cs

Origine:: TimeSpan.cs

Origine:: TimeSpan.cs

Origine:: TimeSpan.cs

Converte la rappresentazione di intervallo di un intervallo di tempo nell'equivalente TimeSpan utilizzando le informazioni di formattazione specifiche delle impostazioni cultura specificate e restituisce un valore che indica se la conversione ha avuto esito positivo.

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

Parametri

input: ReadOnlySpan<Char>

Intervallo contenente i caratteri che rappresentano l'intervallo di tempo da convertire.

formatProvider: IFormatProvider

Oggetto che fornisce informazioni di formattazione specifiche delle impostazioni cultura.

result: TimeSpan

Quando termina, questo metodo contiene un oggetto che rappresenta l'intervallo di tempo specificato da inputo Zero se la conversione non è riuscita. Questo parametro viene passato non inizializzato.

Valori restituiti

Boolean

true se input è stata convertita correttamente; in caso contrario, false. Questa operazione restituisce false se il input parametro è null o Empty, ha un formato non valido, rappresenta un intervallo di tempo minore di TimeSpan.MinValue o maggiore di TimeSpan.MaxValue o ha almeno un componente giorni, ore, minuti o secondi al di fuori dell'intervallo valido.

Si applica a

TryParse(String, IFormatProvider, TimeSpan)

Origine:: TimeSpan.cs

Origine:: TimeSpan.cs

Origine:: TimeSpan.cs

Origine:: TimeSpan.cs

Origine:: TimeSpan.cs

Converte la rappresentazione di stringa di un intervallo di tempo nell'equivalente TimeSpan utilizzando le informazioni di formattazione specifiche delle impostazioni cultura specificate e restituisce un valore che indica se la conversione ha avuto esito positivo.

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

Parametri

input: String

Stringa che specifica l'intervallo di tempo da convertire.

formatProvider: IFormatProvider

Oggetto che fornisce informazioni di formattazione specifiche delle impostazioni cultura.

result: TimeSpan

Valori restituiti

Boolean

Esempio

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

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

Commenti

Metodo TryParse(System.String,System.TimeSpan@)

Il metodo TimeSpan.TryParse(String, TimeSpan) è simile al metodo TimeSpan.Parse(String), ad eccezione del fatto che non genera un'eccezione se la conversione non riesce.

Il parametro s contiene una specifica dell'intervallo di tempo nel formato :

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

Elemento	Description
Ws	Spazio vuoto facoltativo.
-	Un segno meno opzionale, che indica un TimeSpannegativo.
d	Giorni, compresi tra 0 e 10675199.
.	Un simbolo sensibile alla cultura che separa i giorni dalle ore. Il formato invariante usa un carattere punto (".").
Hh	Ore, comprese tra 0 e 23.
:	Simbolo separatore temporale sensibile alla cultura. Il formato invariante usa il carattere due punti (":").
millimetro	Minuti, compresi tra 0 e 59.
ss	Secondi facoltativi, compresi tra 0 e 59.
.	Simbolo sensibile al contesto culturale che separa i secondi dalle frazioni di secondo. Il formato invariante usa un carattere punto (".").
Ff	Secondi frazionari facoltativi, costituiti da una a sette cifre decimali.

I componenti di s devono specificare collettivamente un intervallo di tempo maggiore o uguale a TimeSpan.MinValue e minore o uguale a TimeSpan.MaxValue.

Il metodo Parse(String) tenta di interpretare s utilizzando ciascuno dei formati specifici per le impostazioni culturali correnti.

Metodo TryParse(String, IFormatProvider, TimeSpan)

Il metodo TryParse(String, IFormatProvider, TimeSpan) è simile al metodo Parse(String, IFormatProvider), ad eccezione del fatto che non genera un'eccezione se la conversione non riesce.

Il parametro input contiene una specifica dell'intervallo di tempo nel formato :

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

Elemento	Description
Ws	Spazio vuoto facoltativo.
-	Un segno meno opzionale, che indica un TimeSpannegativo.
d	Giorni, compresi tra 0 e 10675199.
.	Un simbolo sensibile alla cultura che separa i giorni dalle ore. Il formato invariante usa un carattere punto (".").
Hh	Ore, comprese tra 0 e 23.
:	Simbolo separatore temporale sensibile alla cultura. Il formato invariante usa il carattere due punti (":").
millimetro	Minuti, compresi tra 0 e 59.
ss	Secondi facoltativi, compresi tra 0 e 59.
.	Simbolo sensibile al contesto culturale che separa i secondi dalle frazioni di secondo. Il formato invariante usa un carattere punto (".").
Ff	Secondi frazionari facoltativi, costituiti da una a sette cifre decimali.

I componenti di input devono specificare collettivamente un intervallo di tempo maggiore o uguale a TimeSpan.MinValue e minore o uguale a TimeSpan.MaxValue.

Il metodo TryParse(String, IFormatProvider, TimeSpan) tenta di analizzare input usando ciascuno dei formati specifici delle impostazioni culturali per quella specificata da formatProvider.

Oggetto CultureInfo che rappresenta le impostazioni culturali di cui le convenzioni di formattazione devono riflettersi nella stringa restituita. L'oggetto DateTimeFormatInfo restituito dalla proprietà CultureInfo.DateTimeFormat definisce la formattazione della stringa restituita.
Oggetto DateTimeFormatInfo che definisce la formattazione della stringa restituita.
Oggetto personalizzato che implementa l'interfaccia IFormatProvider. Il metodo IFormatProvider.GetFormat restituisce un oggetto DateTimeFormatInfo che fornisce informazioni di formattazione.

Se formatProvider è null, viene utilizzato l'oggetto DateTimeFormatInfo associato alla cultura attuale.

Si applica a

Commenti e suggerimenti

Questa pagina è stata utile?