TimeSpan.TryParse Méthode

Définition

Espace de noms:: System

Assemblys:: netstandard.dll, System.Runtime.dll

Assembly:: System.Runtime.dll

Assembly:: netstandard.dll

Assemblys:: mscorlib.dll, System.Runtime.dll

Assembly:: mscorlib.dll

Important

Certaines informations portent sur la préversion du produit qui est susceptible d’être en grande partie modifiée avant sa publication. Microsoft exclut toute garantie, expresse ou implicite, concernant les informations fournies ici.

Convertit la représentation sous forme de chaîne spécifiée d’un intervalle de temps en son TimeSpan équivalent et retourne une valeur qui indique si la conversion a réussi.

Surcharges

Nom	Description
TryParse(ReadOnlySpan<Char>, TimeSpan)	Convertit la représentation d’étendue d’un intervalle de temps en son TimeSpan équivalent et retourne une valeur qui indique si la conversion a réussi.
TryParse(String, TimeSpan)	Convertit la représentation sous forme de chaîne d’un intervalle de temps en son TimeSpan équivalent et retourne une valeur qui indique si la conversion a réussi.
TryParse(ReadOnlySpan<Char>, IFormatProvider, TimeSpan)	Convertit la représentation d’étendue d’un intervalle de temps en son TimeSpan équivalent à l’aide des informations de mise en forme spécifiques à la culture spécifiées et retourne une valeur qui indique si la conversion a réussi.
TryParse(String, IFormatProvider, TimeSpan)	Convertit la représentation sous forme de chaîne d’un intervalle de temps en son TimeSpan équivalent à l’aide des informations de mise en forme spécifiques à la culture spécifiées et retourne une valeur qui indique si la conversion a réussi.

TryParse(ReadOnlySpan<Char>, TimeSpan)

Source:: TimeSpan.cs

Source:: TimeSpan.cs

Source:: TimeSpan.cs

Source:: TimeSpan.cs

Source:: TimeSpan.cs

Convertit la représentation d’étendue d’un intervalle de temps en son TimeSpan équivalent et retourne une valeur qui indique si la conversion a réussi.

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

Paramètres

s: ReadOnlySpan<Char>

Étendue contenant les caractères représentant l’intervalle de temps à convertir.

result: TimeSpan

Lorsque cette méthode est retournée, contient un objet qui représente l’intervalle de temps spécifié par s, ou Zero si la conversion a échoué. Ce paramètre est passé non initialisé.

Retours

Boolean

true si s elle a été convertie avec succès ; sinon, false. Cette opération retourne false si le s paramètre est null ou Emptya un format non valide, représente un intervalle de temps inférieur à TimeSpan.MinValue ou supérieur à TimeSpan.MaxValue, ou a au moins un jour, des heures, des minutes ou des secondes en dehors de sa plage valide.

S’applique à

TryParse(String, TimeSpan)

Source:: TimeSpan.cs

Source:: TimeSpan.cs

Source:: TimeSpan.cs

Source:: TimeSpan.cs

Source:: TimeSpan.cs

Convertit la représentation sous forme de chaîne d’un intervalle de temps en son TimeSpan équivalent et retourne une valeur qui indique si la conversion a réussi.

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

Paramètres

s: String

Chaîne qui spécifie l’intervalle de temps à convertir.

result: TimeSpan

Lorsque cette méthode est retournée, contient un objet qui représente l’intervalle de temps spécifié par s, ou Zero si la conversion a échoué. Ce paramètre est passé non initialisé.

Retours

Boolean

Exemples

L’exemple suivant utilise la TryParse méthode pour créer TimeSpan des objets à partir de chaînes valides TimeSpan et pour indiquer quand l’opération d’analyse a échoué, car la chaîne d’intervalle de temps n’est pas valide.

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

Remarques

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

La TimeSpan.TryParse(String, TimeSpan) méthode est semblable à la TimeSpan.Parse(String) méthode, sauf qu’elle ne lève pas d’exception si la conversion échoue.

Le s paramètre contient une spécification d’intervalle de temps dans le formulaire :

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

Les éléments entre crochets ([ et ]) sont facultatifs. Une sélection de la liste des alternatives placées entre accolades ({ et }) et séparées par des barres verticales (|) est requise. Le tableau suivant décrit chaque élément.

Élément	Description
Ws	Espace blanc facultatif.
-	Un signe moins facultatif, qui indique que TimeSpan est négatif.
d	Jours, allant de 0 à 10675199.
.	Symbole sensible à la culture qui sépare les jours des heures. Le format invariant utilise un caractère de point (« . »).
Hh	Heures, de 0 à 23.
:	Symbole de séparation temporelle adapté à la culture. Le format invariant utilise un caractère deux-points (« : »).
mm	Minutes, allant de 0 à 59.
ss	Secondes facultatives, allant de 0 à 59.
.	Symbole sensible à la culture qui sépare les secondes des fractions d’une seconde. Le format invariant utilise un caractère de point (« . »).
Ff	Fractions de seconde facultatives, composées d’un à sept chiffres décimaux.

Les composants de s doivent spécifier collectivement un intervalle de temps supérieur ou égal à TimeSpan.MinValue et inférieur ou égal à TimeSpan.MaxValue.

La méthode Parse(String) tente d’analyser s à l’aide de chacun des formats spécifiques à la culture pour la culture actuelle.

méthode TryParse(String, IFormatProvider, TimeSpan)

La TryParse(String, IFormatProvider, TimeSpan) méthode est semblable à la Parse(String, IFormatProvider) méthode, sauf qu’elle ne lève pas d’exception si la conversion échoue.

Le input paramètre contient une spécification d’intervalle de temps dans le formulaire :

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

Élément	Description
Ws	Espace blanc facultatif.
-	Un signe moins facultatif, qui indique que TimeSpan est négatif.
d	Jours, allant de 0 à 10675199.
.	Symbole sensible à la culture qui sépare les jours des heures. Le format invariant utilise un caractère de point (« . »).
Hh	Heures, de 0 à 23.
:	Symbole de séparation temporelle adapté à la culture. Le format invariant utilise un caractère deux-points (« : »).
mm	Minutes, allant de 0 à 59.
ss	Secondes facultatives, allant de 0 à 59.
.	Symbole sensible à la culture qui sépare les secondes des fractions d’une seconde. Le format invariant utilise un caractère de point (« . »).
Ff	Fractions de seconde facultatives, composées d’un à sept chiffres décimaux.

Les composants de input doivent spécifier collectivement un intervalle de temps supérieur ou égal à TimeSpan.MinValue et inférieur ou égal à TimeSpan.MaxValue.

La TryParse(String, IFormatProvider, TimeSpan) méthode tente d’analyser input en utilisant chacun des formats spécifiques à la culture pour la culture spécifiée par formatProvider.

Le paramètre formatProvider est une IFormatProvider implémentation qui fournit des informations spécifiques à la culture sur le format de la chaîne retournée. Le formatProvider paramètre peut être l’un des éléments suivants :

Objet CultureInfo qui représente la culture dont les conventions de mise en forme doivent être reflétées dans la chaîne retournée. L’objet DateTimeFormatInfo retourné par la CultureInfo.DateTimeFormat propriété définit la mise en forme de la chaîne retournée.
Objet DateTimeFormatInfo qui définit la mise en forme de la chaîne retournée.
Objet personnalisé qui implémente l’interface IFormatProvider . Sa IFormatProvider.GetFormat méthode retourne un DateTimeFormatInfo objet qui fournit des informations de mise en forme.

Si formatProvidernull est le cas, l’objet DateTimeFormatInfo associé à la culture actuelle est utilisé.

S’applique à

TryParse(ReadOnlySpan<Char>, IFormatProvider, TimeSpan)

Source:: TimeSpan.cs

Source:: TimeSpan.cs

Source:: TimeSpan.cs

Source:: TimeSpan.cs

Source:: TimeSpan.cs

Convertit la représentation d’étendue d’un intervalle de temps en son TimeSpan équivalent à l’aide des informations de mise en forme spécifiques à la culture spécifiées et retourne une valeur qui indique si la conversion a réussi.

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

Paramètres

input: ReadOnlySpan<Char>

Étendue contenant les caractères représentant l’intervalle de temps à convertir.

formatProvider: IFormatProvider

Objet qui fournit des informations de mise en forme propres à la culture.

result: TimeSpan

Lorsque cette méthode est retournée, contient un objet qui représente l’intervalle de temps spécifié par input, ou Zero si la conversion a échoué. Ce paramètre est passé non initialisé.

Retours

Boolean

true si input elle a été convertie avec succès ; sinon, false. Cette opération retourne false si le input paramètre est null ou Emptya un format non valide, représente un intervalle de temps inférieur à TimeSpan.MinValue ou supérieur à TimeSpan.MaxValue, ou a au moins un jour, des heures, des minutes ou des secondes en dehors de sa plage valide.

S’applique à

TryParse(String, IFormatProvider, TimeSpan)

Source:: TimeSpan.cs

Source:: TimeSpan.cs

Source:: TimeSpan.cs

Source:: TimeSpan.cs

Source:: TimeSpan.cs

Convertit la représentation sous forme de chaîne d’un intervalle de temps en son TimeSpan équivalent à l’aide des informations de mise en forme spécifiques à la culture spécifiées et retourne une valeur qui indique si la conversion a réussi.

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

Paramètres

input: String

Chaîne qui spécifie l’intervalle de temps à convertir.

formatProvider: IFormatProvider

Objet qui fournit des informations de mise en forme propres à la culture.

result: TimeSpan

Lorsque cette méthode est retournée, contient un objet qui représente l’intervalle de temps spécifié par input, ou Zero si la conversion a échoué. Ce paramètre est passé non initialisé.

Retours

Boolean

Exemples

L’exemple suivant définit un tableau d’objets CultureInfo et utilise chaque objet dans les appels à la TryParse(String, IFormatProvider, TimeSpan) méthode pour analyser les éléments d’un tableau de chaînes. L’exemple montre comment les conventions d’une culture spécifique influencent l’opération de mise en forme.

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

Remarques

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

La TimeSpan.TryParse(String, TimeSpan) méthode est semblable à la TimeSpan.Parse(String) méthode, sauf qu’elle ne lève pas d’exception si la conversion échoue.

Le s paramètre contient une spécification d’intervalle de temps dans le formulaire :

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

Élément	Description
Ws	Espace blanc facultatif.
-	Un signe moins facultatif, qui indique que TimeSpan est négatif.
d	Jours, allant de 0 à 10675199.
.	Symbole sensible à la culture qui sépare les jours des heures. Le format invariant utilise un caractère de point (« . »).
Hh	Heures, de 0 à 23.
:	Symbole de séparation temporelle adapté à la culture. Le format invariant utilise un caractère deux-points (« : »).
mm	Minutes, allant de 0 à 59.
ss	Secondes facultatives, allant de 0 à 59.
.	Symbole sensible à la culture qui sépare les secondes des fractions d’une seconde. Le format invariant utilise un caractère de point (« . »).
Ff	Fractions de seconde facultatives, composées d’un à sept chiffres décimaux.

Les composants de s doivent spécifier collectivement un intervalle de temps supérieur ou égal à TimeSpan.MinValue et inférieur ou égal à TimeSpan.MaxValue.

La méthode Parse(String) tente d’analyser s à l’aide de chacun des formats spécifiques à la culture pour la culture actuelle.

méthode TryParse(String, IFormatProvider, TimeSpan)

La TryParse(String, IFormatProvider, TimeSpan) méthode est semblable à la Parse(String, IFormatProvider) méthode, sauf qu’elle ne lève pas d’exception si la conversion échoue.

Le input paramètre contient une spécification d’intervalle de temps dans le formulaire :

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

Élément	Description
Ws	Espace blanc facultatif.
-	Un signe moins facultatif, qui indique que TimeSpan est négatif.
d	Jours, allant de 0 à 10675199.
.	Symbole sensible à la culture qui sépare les jours des heures. Le format invariant utilise un caractère de point (« . »).
Hh	Heures, de 0 à 23.
:	Symbole de séparation temporelle adapté à la culture. Le format invariant utilise un caractère deux-points (« : »).
mm	Minutes, allant de 0 à 59.
ss	Secondes facultatives, allant de 0 à 59.
.	Symbole sensible à la culture qui sépare les secondes des fractions d’une seconde. Le format invariant utilise un caractère de point (« . »).
Ff	Fractions de seconde facultatives, composées d’un à sept chiffres décimaux.

Les composants de input doivent spécifier collectivement un intervalle de temps supérieur ou égal à TimeSpan.MinValue et inférieur ou égal à TimeSpan.MaxValue.

La TryParse(String, IFormatProvider, TimeSpan) méthode tente d’analyser input en utilisant chacun des formats spécifiques à la culture pour la culture spécifiée par formatProvider.

Objet CultureInfo qui représente la culture dont les conventions de mise en forme doivent être reflétées dans la chaîne retournée. L’objet DateTimeFormatInfo retourné par la CultureInfo.DateTimeFormat propriété définit la mise en forme de la chaîne retournée.
Objet DateTimeFormatInfo qui définit la mise en forme de la chaîne retournée.
Objet personnalisé qui implémente l’interface IFormatProvider . Sa IFormatProvider.GetFormat méthode retourne un DateTimeFormatInfo objet qui fournit des informations de mise en forme.

Si formatProvidernull est le cas, l’objet DateTimeFormatInfo associé à la culture actuelle est utilisé.

S’applique à

Commentaires

Cette page a-t-elle été utile ?