Partage via

TimeSpan.TryParseExact Méthode

  • Référence

Définition

Espace de noms:
System
Assembly:
System.Runtime.dll
Assembly:
netstandard.dll
Assembly:
mscorlib.dll

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

Surcharges

TryParseExact(ReadOnlySpan<Char>, String[], IFormatProvider, TimeSpanStyles, TimeSpan)

Convertit la représentation d’étendue spécifiée d’un intervalle de temps en son TimeSpan équivalent à l’aide des formats spécifiés, des informations et des styles de format spécifiques à la culture. Le format de la représentation sous forme de chaîne doit correspondre exactement à l’un des formats spécifiés.
TryParseExact(String, String, IFormatProvider, TimeSpanStyles, TimeSpan)

Convertit la représentation sous forme de chaîne d’un intervalle de temps en son TimeSpan équivalent à l’aide des informations et des styles de format spécifiques à la culture spécifiés. Le format de la représentation sous forme de chaîne doit correspondre exactement au format spécifié.
TryParseExact(ReadOnlySpan<Char>, ReadOnlySpan<Char>, IFormatProvider, TimeSpanStyles, TimeSpan)

Convertit la représentation d’étendue spécifiée d’un intervalle de temps en son TimeSpan équivalent à l’aide du format spécifié, des informations de format spécifiques à la culture et des styles, et retourne une valeur qui indique si la conversion a réussi. Le format de la représentation sous forme de chaîne doit correspondre exactement au format spécifié.
TryParseExact(String, String[], IFormatProvider, TimeSpan)

Convertit la représentation sous forme de chaîne spécifiée d’un intervalle de temps en son équivalent TimeSpan à l’aide des formats spécifiés et des informations de format propres à la culture. Le format de la représentation sous forme de chaîne doit correspondre exactement à l’un des formats spécifiés.
TryParseExact(String, String[], IFormatProvider, TimeSpanStyles, TimeSpan)

Convertit la représentation sous forme de chaîne spécifiée d’un intervalle de temps en son équivalent TimeSpan à l’aide des formats spécifiés, des informations et des styles de format spécifiques à la culture. Le format de la représentation sous forme de chaîne doit correspondre exactement à l’un des formats spécifiés.
TryParseExact(ReadOnlySpan<Char>, String[], IFormatProvider, TimeSpan)

Convertit la représentation d’étendue spécifiée d’un intervalle de temps en son TimeSpan équivalent à l’aide des formats spécifiés et des informations de format propres à la culture. Le format de la représentation sous forme de chaîne doit correspondre exactement à l’un des formats spécifiés.
TryParseExact(ReadOnlySpan<Char>, ReadOnlySpan<Char>, IFormatProvider, TimeSpan)

Convertit la représentation d’étendue spécifiée d’un intervalle de temps en son équivalent TimeSpan à l’aide des informations de format spécifiques à la culture et au format spécifiés. Le format de la représentation sous forme de chaîne doit correspondre exactement au format spécifié.
TryParseExact(String, 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 format spécifiques à la culture et au format spécifiés. Le format de la représentation sous forme de chaîne doit correspondre exactement au format spécifié.

TryParseExact(ReadOnlySpan<Char>, String[], IFormatProvider, TimeSpanStyles, TimeSpan)

Source:
TimeSpan.cs
Source:
TimeSpan.cs
Source:
TimeSpan.cs

Convertit la représentation d’étendue spécifiée d’un intervalle de temps en son TimeSpan équivalent à l’aide des formats spécifiés, des informations et des styles de format spécifiques à la culture. Le format de la représentation sous forme de chaîne doit correspondre exactement à l’un des formats spécifiés.

public:
 static bool TryParseExact(ReadOnlySpan<char> input, cli::array <System::String ^> ^ formats, IFormatProvider ^ formatProvider, System::Globalization::TimeSpanStyles styles, [Runtime::InteropServices::Out] TimeSpan % result);
public static bool TryParseExact (ReadOnlySpan<char> input, string?[]? formats, IFormatProvider? formatProvider, System.Globalization.TimeSpanStyles styles, out TimeSpan result);
public static bool TryParseExact (ReadOnlySpan<char> input, string[] formats, IFormatProvider formatProvider, System.Globalization.TimeSpanStyles styles, out TimeSpan result);
public static bool TryParseExact (ReadOnlySpan<char> input, string[] formats, IFormatProvider? formatProvider, System.Globalization.TimeSpanStyles styles, out TimeSpan result);
static member TryParseExact : ReadOnlySpan<char> * string[] * IFormatProvider * System.Globalization.TimeSpanStyles * TimeSpan -> bool
Public Shared Function TryParseExact (input As ReadOnlySpan(Of Char), formats As String(), formatProvider As IFormatProvider, styles As TimeSpanStyles, ByRef result As TimeSpan) As Boolean

Paramètres

input
ReadOnlySpan<Char>

Étendue contenant les caractères qui représentent un intervalle de temps à convertir.

formats
String[]

Tableau de chaînes de format standard ou personnalisées qui définissent les formats acceptables de input.

formatProvider
IFormatProvider

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

styles
TimeSpanStyles

Une ou plusieurs valeurs d’énumération qui indiquent le style de input.

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 a été convertie avec succès ; sinon, false.

S’applique à

TryParseExact(String, String, IFormatProvider, TimeSpanStyles, TimeSpan)

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 et des styles de format spécifiques à la culture spécifiés. Le format de la représentation sous forme de chaîne doit correspondre exactement au format spécifié.

public:
 static bool TryParseExact(System::String ^ input, System::String ^ format, IFormatProvider ^ formatProvider, System::Globalization::TimeSpanStyles styles, [Runtime::InteropServices::Out] TimeSpan % result);
public static bool TryParseExact (string input, string format, IFormatProvider formatProvider, System.Globalization.TimeSpanStyles styles, out TimeSpan result);
public static bool TryParseExact (string? input, string? format, IFormatProvider? formatProvider, System.Globalization.TimeSpanStyles styles, out TimeSpan result);
public static bool TryParseExact (string? input, string format, IFormatProvider? formatProvider, System.Globalization.TimeSpanStyles styles, out TimeSpan result);
static member TryParseExact : string * string * IFormatProvider * System.Globalization.TimeSpanStyles * TimeSpan -> bool
Public Shared Function TryParseExact (input As String, format As String, formatProvider As IFormatProvider, styles As TimeSpanStyles, ByRef result As TimeSpan) As Boolean

Paramètres

input
String

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

format
String

Chaîne de format standard ou personnalisée qui définit le format requis de input.

formatProvider
IFormatProvider

Objet qui fournit des informations de mise en forme spécifiques à la culture.

styles
TimeSpanStyles

Une ou plusieurs valeurs d’énumération qui indiquent le style de input.

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 a été convertie avec succès ; sinon, false.

Exemples

L’exemple suivant utilise la méthode ParseExact(String, String, IFormatProvider) pour analyser plusieurs représentations sous forme de chaînes d’intervalles de temps à l’aide de différentes chaînes de format et cultures. Il utilise également la valeur TimeSpanStyles.AssumeNegative pour interpréter chaque chaîne comme un intervalle de temps négatif. La sortie de l’exemple illustre que le style TimeSpanStyles.AssumeNegative affecte la valeur de retour uniquement lorsqu’il est utilisé avec des chaînes de format personnalisées.

using System;
using System.Globalization;

public class Example
{
   public static void Main()
   {
      string intervalString, format;
      TimeSpan interval;
      CultureInfo culture = null;
      
      // Parse hour:minute value with custom format specifier.
      intervalString = "17:14";
      format = "h\\:mm";
      culture = CultureInfo.CurrentCulture;
      if (TimeSpan.TryParseExact(intervalString, format, 
                                 culture, TimeSpanStyles.AssumeNegative, out interval))
         Console.WriteLine("'{0}' ({1}) --> {2}", intervalString, format, interval);
      else   
         Console.WriteLine("Unable to parse '{0}' using format {1}",
                           intervalString, format);
      
      // Parse hour:minute:second value with "g" specifier.
      intervalString = "17:14:48";
      format = "g";
      culture = CultureInfo.InvariantCulture;
      if (TimeSpan.TryParseExact(intervalString, format, 
                                 culture, TimeSpanStyles.AssumeNegative, out interval))
         Console.WriteLine("'{0}' ({1}) --> {2}", intervalString, format, interval);
      else
         Console.WriteLine("Unable to parse '{0}' using format {1}",
                           intervalString, format);
      
      // Parse hours:minute.second value with custom format specifier.     
      intervalString = "17:14:48.153";
      format = @"h\:mm\:ss\.fff";
      culture = null;
      if (TimeSpan.TryParseExact(intervalString, format, 
                                 culture, TimeSpanStyles.AssumeNegative, out interval))
         Console.WriteLine("'{0}' ({1}) --> {2}", intervalString, format, interval);
      else
         Console.WriteLine("Unable to parse '{0}' using format {1}",
                           intervalString, format);   

      // Parse days:hours:minute.second value with "G" specifier 
      // and current (en-US) culture.     
      intervalString = "3:17:14:48.153";
      format = "G";
      culture = CultureInfo.CurrentCulture;
      if (TimeSpan.TryParseExact(intervalString, format, 
                                 culture, TimeSpanStyles.AssumeNegative, out interval))
         Console.WriteLine("'{0}' ({1}) --> {2}", intervalString, format, interval);
      else   
         Console.WriteLine("Unable to parse '{0}' using format {1}",
                           intervalString, format);   
            
      // Parse days:hours:minute.second value with a custom format specifier.     
      intervalString = "3:17:14:48.153";
      format = @"d\:hh\:mm\:ss\.fff";
      culture = null;
      if (TimeSpan.TryParseExact(intervalString, format, 
                                 culture, TimeSpanStyles.AssumeNegative, out interval))
         Console.WriteLine("'{0}' ({1}) --> {2}", intervalString, format, interval);
      else   
         Console.WriteLine("Unable to parse '{0}' using format {1}",
                           intervalString, format);
      
      // Parse days:hours:minute.second value with "G" specifier 
      // and fr-FR culture.     
      intervalString = "3:17:14:48,153";
      format = "G";
      culture = new CultureInfo("fr-FR");
      if (TimeSpan.TryParseExact(intervalString, format, 
                                 culture, TimeSpanStyles.AssumeNegative, out interval))
         Console.WriteLine("'{0}' ({1}) --> {2}", intervalString, format, interval);
      else   
         Console.WriteLine("Unable to parse '{0}' using format {1}",
                           intervalString, format);

      // Parse a single number using the "c" standard format string. 
      intervalString = "12";
      format = "c";
      if (TimeSpan.TryParseExact(intervalString, format, 
                                 null, TimeSpanStyles.AssumeNegative, out interval))
         Console.WriteLine("'{0}' ({1}) --> {2}", intervalString, format, interval);
      else   
         Console.WriteLine("Unable to parse '{0}' using format {1}",
                           intervalString, format);
      
      // Parse a single number using the "%h" custom format string. 
      format = "%h";
      if (TimeSpan.TryParseExact(intervalString, format, 
                                 null, TimeSpanStyles.AssumeNegative, out interval))
         Console.WriteLine("'{0}' ({1}) --> {2}", intervalString, format, interval);
      else   
         Console.WriteLine("Unable to parse '{0}' using format {1}",
                           intervalString, format);
      
      // Parse a single number using the "%s" custom format string. 
      format = "%s";
      if (TimeSpan.TryParseExact(intervalString, format, 
                                 null, TimeSpanStyles.AssumeNegative, out interval))
         Console.WriteLine("'{0}' ({1}) --> {2}", intervalString, format, interval);
      else   
         Console.WriteLine("Unable to parse '{0}' using format {1}",
                           intervalString, format);
   }
}
// The example displays the following output:
//    '17:14' (h\:mm) --> -17:14:00
//    '17:14:48' (g) --> 17:14:48
//    '17:14:48.153' (h\:mm\:ss\.fff) --> -17:14:48.1530000
//    '3:17:14:48.153' (G) --> 3.17:14:48.1530000
//    '3:17:14:48.153' (d\:hh\:mm\:ss\.fff) --> -3.17:14:48.1530000
//    '3:17:14:48,153' (G) --> 3.17:14:48.1530000
//    '12' (c) --> 12.00:00:00
//    '12' (%h) --> -12:00:00
//    '12' (%s) --> -00:00:12

open System
open System.Globalization

do
    // Parse hour:minute value with custom format specifier.
    let intervalString = "17:14"
    let format = "h\\:mm"
    let culture = CultureInfo.CurrentCulture
    match TimeSpan.TryParseExact(intervalString, format, culture, TimeSpanStyles.AssumeNegative) with
    | true, interval ->
        printfn $"'{intervalString}' ({format}) --> {interval}"
    | _ ->   
        printfn $"Unable to parse '{intervalString}' using format {format}" 
    
    // Parse hour:minute:second value with "g" specifier.
    let intervalString = "17:14:48"
    let format = "g"
    let culture = CultureInfo.InvariantCulture
    match TimeSpan.TryParseExact(intervalString, format, culture, TimeSpanStyles.AssumeNegative) with
    | true, interval ->
        printfn $"'{intervalString}' ({format}) --> {interval}"
    | _ ->
        printfn $"Unable to parse '{intervalString}' using format {format}" 
    
    // Parse hours:minute.second value with custom format specifier.     
    let intervalString = "17:14:48.153"
    let format = @"h\:mm\:ss\.fff"
    let culture = null
    match TimeSpan.TryParseExact(intervalString, format, culture, TimeSpanStyles.AssumeNegative) with
    | true, interval ->
        printfn $"'{intervalString}' ({format}) --> {interval}"
    | _ ->
        printfn $"Unable to parse '{intervalString}' using format {format}"    

    // Parse days:hours:minute.second value with "G" specifier 
    // and current (en-US) culture.     
    let intervalString = "3:17:14:48.153"
    let format = "G"
    let culture = CultureInfo.CurrentCulture
    match TimeSpan.TryParseExact(intervalString, format, culture, TimeSpanStyles.AssumeNegative) with
    | true, interval ->
        printfn $"'{intervalString}' ({format}) --> {interval}"
    | _ ->   
        printfn $"Unable to parse '{intervalString}' using format {format}"    
        
    // Parse days:hours:minute.second value with a custom format specifier.     
    let intervalString = "3:17:14:48.153"
    let format = @"d\:hh\:mm\:ss\.fff"
    let culture = null
    match TimeSpan.TryParseExact(intervalString, format, culture, TimeSpanStyles.AssumeNegative) with
    | true, interval ->
        printfn $"'{intervalString}' ({format}) --> {interval}"
    | _ ->   
        printfn $"Unable to parse '{intervalString}' using format {format}" 
    
    // Parse days:hours:minute.second value with "G" specifier 
    // and fr-FR culture.     
    let intervalString = "3:17:14:48,153"
    let format = "G"
    let culture = new CultureInfo("fr-FR")
    match TimeSpan.TryParseExact(intervalString, format, culture, TimeSpanStyles.AssumeNegative) with
    | true, interval ->
        printfn $"'{intervalString}' ({format}) --> {interval}"
    | _ ->   
        printfn $"Unable to parse '{intervalString}' using format {format}" 

    // Parse a single number using the "c" standard format string. 
    let intervalString = "12"
    let format = "c"
    match TimeSpan.TryParseExact(intervalString, format, null, TimeSpanStyles.AssumeNegative) with
    | true, interval ->
        printfn $"'{intervalString}' ({format}) --> {interval}"
    | _ ->   
        printfn $"Unable to parse '{intervalString}' using format {format}" 
    
    // Parse a single number using the "%h" custom format string. 
    let format = "%h"
    match TimeSpan.TryParseExact(intervalString, format, null, TimeSpanStyles.AssumeNegative) with
    | true, interval ->
        printfn $"'{intervalString}' ({format}) --> {interval}"
    | _ ->   
        printfn $"Unable to parse '{intervalString}' using format {format}" 
    
    // Parse a single number using the "%s" custom format string. 
    let format = "%s"
    match TimeSpan.TryParseExact(intervalString, format, null, TimeSpanStyles.AssumeNegative) with
    | true, interval ->
        printfn $"'{intervalString}' ({format}) --> {interval}"
    | _ ->   
        printfn $"Unable to parse '{intervalString}' using format {format}" 
// The example displays the following output:
//    '17:14' (h\:mm) --> -17:14:00
//    '17:14:48' (g) --> 17:14:48
//    '17:14:48.153' (h\:mm\:ss\.fff) --> -17:14:48.1530000
//    '3:17:14:48.153' (G) --> 3.17:14:48.1530000
//    '3:17:14:48.153' (d\:hh\:mm\:ss\.fff) --> -3.17:14:48.1530000
//    '3:17:14:48,153' (G) --> 3.17:14:48.1530000
//    '12' (c) --> 12.00:00:00
//    '12' (%h) --> -12:00:00
//    '12' (%s) --> -00:00:12

Imports System.Globalization

Module Example
   Public Sub Main()
      Dim intervalString, format As String
      Dim interval As TimeSpan
      Dim culture As CultureInfo = Nothing
      
      ' Parse hour:minute value with custom format specifier.
      intervalString = "17:14"
      format = "h\:mm"
      culture = CultureInfo.CurrentCulture
      If TimeSpan.TryParseExact(intervalString, format, 
                                culture, TimeSpanStyles.AssumeNegative, interval) Then
         Console.WriteLine("'{0}' ({1}) --> {2}", intervalString, format, interval)
      Else
         Console.WriteLine("Unable to parse '{0}' using format {1}",
                           intervalString, format)   
      End If
      
      ' Parse hour:minute:second value with "g" specifier.
      intervalString = "17:14:48"
      format = "g"
      culture = CultureInfo.InvariantCulture
      If TimeSpan.TryParseExact(intervalString, format, 
                                culture, TimeSpanStyles.AssumeNegative, interval) Then
         Console.WriteLine("'{0}' ({1}) --> {2}", intervalString, format, interval)
      Else
         Console.WriteLine("Unable to parse '{0}' using format {1}",
                           intervalString, format)   
      End If
      
      ' Parse hours:minute.second value with custom format specifier.     
      intervalString = "17:14:48.153"
      format = "h\:mm\:ss\.fff"
      culture = Nothing
      If TimeSpan.TryParseExact(intervalString, format, 
                                culture, TimeSpanStyles.AssumeNegative, interval) Then
         Console.WriteLine("'{0}' ({1}) --> {2}", intervalString, format, interval)
      Else
         Console.WriteLine("Unable to parse '{0}' using format {1}",
                           intervalString, format)   
      End If 

      ' Parse days:hours:minute.second value with "G" specifier 
      ' and current (en-US) culture.     
      intervalString = "3:17:14:48.153"
      format = "G"
      culture = CultureInfo.CurrentCulture
      If TimeSpan.TryParseExact(intervalString, format, 
                                culture, TimeSpanStyles.AssumeNegative, interval) Then
         Console.WriteLine("'{0}' ({1}) --> {2}", intervalString, format, interval)
      Else
         Console.WriteLine("Unable to parse '{0}' using format {1}",
                           intervalString, format)   
      End If 
            
      ' Parse days:hours:minute.second value with a custom format specifier.     
      intervalString = "3:17:14:48.153"
      format = "d\:hh\:mm\:ss\.fff"
      culture = Nothing
      If TimeSpan.TryParseExact(intervalString, format, 
                                culture, TimeSpanStyles.AssumeNegative, interval) Then
         Console.WriteLine("'{0}' ({1}) --> {2}", intervalString, format, interval)
      Else
         Console.WriteLine("Unable to parse '{0}' using format {1}",
                           intervalString, format)   
      End If 
      
      ' Parse days:hours:minute.second value with "G" specifier 
      ' and fr-FR culture.     
      intervalString = "3:17:14:48,153"
      format = "G"
      culture = New CultureInfo("fr-FR")
      If TimeSpan.TryParseExact(intervalString, format, 
                                culture, TimeSpanStyles.AssumeNegative, interval) Then
         Console.WriteLine("'{0}' ({1}) --> {2}", intervalString, format, interval)
      Else
         Console.WriteLine("Unable to parse '{0}' using format {1}",
                           intervalString, format)
      End If 

      ' Parse a single number using the "c" standard format string. 
      intervalString = "12"
      format = "c"
      If TimeSpan.TryParseExact(intervalString, format, 
                                Nothing, TimeSpanStyles.AssumeNegative, interval) Then
         Console.WriteLine("'{0}' ({1}) --> {2}", intervalString, format, interval)
      Else
         Console.WriteLine("Unable to parse '{0}' using format {1}",
                           intervalString, format)   
      End If 
      
      ' Parse a single number using the "%h" custom format string. 
      format = "%h"
      If TimeSpan.TryParseExact(intervalString, format, 
                                Nothing, TimeSpanStyles.AssumeNegative, interval) Then
         Console.WriteLine("'{0}' ({1}) --> {2}", intervalString, format, interval)
      Else
         Console.WriteLine("Unable to parse '{0}' using format {1}",
                           intervalString, format)   
      End If 
      
      ' Parse a single number using the "%s" custom format string. 
      format = "%s"
      If TimeSpan.TryParseExact(intervalString, format, 
                                Nothing, TimeSpanStyles.AssumeNegative, interval) Then
         Console.WriteLine("'{0}' ({1}) --> {2}", intervalString, format, interval)
      Else
         Console.WriteLine("Unable to parse '{0}' using format {1}",
                           intervalString, format)   
      End If 
   End Sub
End Module
' The example displays the following output:
'    '17:14' (h\:mm) --> -17:14:00
'    '17:14:48' (g) --> 17:14:48
'    '17:14:48.153' (h\:mm\:ss\.fff) --> -17:14:48.1530000
'    '3:17:14:48.153' (G) --> 3.17:14:48.1530000
'    '3:17:14:48.153' (d\:hh\:mm\:ss\.fff) --> -3.17:14:48.1530000
'    '3:17:14:48,153' (G) --> 3.17:14:48.1530000
'    '12' (c) --> 12.00:00:00
'    '12' (%h) --> -12:00:00
'    '12' (%s) --> -00:00:12

Remarques

La méthode TryParseExact(String, String, IFormatProvider, TimeSpanStyles, TimeSpan) analyse la représentation sous forme de chaîne d’un intervalle de temps, qui doit être au format défini par le paramètre format, sauf que les caractères d’espace blanc de début et de fin sont ignorés. Cette méthode est similaire à la méthode ParseExact(String, String, IFormatProvider, TimeSpanStyles), sauf qu’elle ne lève pas d’exception si la conversion échoue.

Le paramètre format est une chaîne qui contient un spécificateur de format standard unique, ou un ou plusieurs spécificateurs de format personnalisés qui définissent le format requis de input. Pour plus d’informations sur les chaînes de format valides, consultez chaînes de format timeSpan standard et chaînes de format TimeSpan personnalisées.

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

Si formatProvider est null, l’objet DateTimeFormatInfo associé à la culture actuelle est utilisé.

Le paramètre styles affecte l’interprétation des chaînes analysées à l’aide de chaînes de format personnalisées. Elle détermine si input est interprétée comme un intervalle de temps négatif uniquement si un signe négatif est présent (TimeSpanStyles.None), ou s’il est toujours interprété comme un intervalle de temps négatif (TimeSpanStyles.AssumeNegative). Si TimeSpanStyles.AssumeNegative n’est pas utilisé, format doit inclure un symbole de signe négatif littéral (tel que « \- ») pour analyser correctement un intervalle de temps négatif.

Voir aussi

S’applique à

TryParseExact(ReadOnlySpan<Char>, ReadOnlySpan<Char>, IFormatProvider, TimeSpanStyles, TimeSpan)

Source:
TimeSpan.cs
Source:
TimeSpan.cs
Source:
TimeSpan.cs

Convertit la représentation d’étendue spécifiée d’un intervalle de temps en son TimeSpan équivalent à l’aide du format spécifié, des informations de format spécifiques à la culture et des styles, et retourne une valeur qui indique si la conversion a réussi. Le format de la représentation sous forme de chaîne doit correspondre exactement au format spécifié.

public:
 static bool TryParseExact(ReadOnlySpan<char> input, ReadOnlySpan<char> format, IFormatProvider ^ formatProvider, System::Globalization::TimeSpanStyles styles, [Runtime::InteropServices::Out] TimeSpan % result);
public static bool TryParseExact (ReadOnlySpan<char> input, ReadOnlySpan<char> format, IFormatProvider? formatProvider, System.Globalization.TimeSpanStyles styles, out TimeSpan result);
public static bool TryParseExact (ReadOnlySpan<char> input, ReadOnlySpan<char> format, IFormatProvider formatProvider, System.Globalization.TimeSpanStyles styles, out TimeSpan result);
static member TryParseExact : ReadOnlySpan<char> * ReadOnlySpan<char> * IFormatProvider * System.Globalization.TimeSpanStyles * TimeSpan -> bool
Public Shared Function TryParseExact (input As ReadOnlySpan(Of Char), format As ReadOnlySpan(Of Char), formatProvider As IFormatProvider, styles As TimeSpanStyles, ByRef result As TimeSpan) As Boolean

Paramètres

input
ReadOnlySpan<Char>

Étendue contenant les caractères qui représentent un intervalle de temps à convertir.

format
ReadOnlySpan<Char>

Étendue contenant les caractères qui représentent une chaîne de format standard ou personnalisée qui définit le format acceptable de input.

formatProvider
IFormatProvider

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

styles
TimeSpanStyles

Une ou plusieurs valeurs d’énumération qui indiquent le style de input.

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 a été convertie avec succès ; sinon, false.

S’applique à

TryParseExact(String, String[], IFormatProvider, TimeSpan)

Source:
TimeSpan.cs
Source:
TimeSpan.cs
Source:
TimeSpan.cs

Convertit la représentation sous forme de chaîne spécifiée d’un intervalle de temps en son équivalent TimeSpan à l’aide des formats spécifiés et des informations de format propres à la culture. Le format de la représentation sous forme de chaîne doit correspondre exactement à l’un des formats spécifiés.

public:
 static bool TryParseExact(System::String ^ input, cli::array <System::String ^> ^ formats, IFormatProvider ^ formatProvider, [Runtime::InteropServices::Out] TimeSpan % result);
public static bool TryParseExact (string input, string[] formats, IFormatProvider formatProvider, out TimeSpan result);
public static bool TryParseExact (string? input, string?[]? formats, IFormatProvider? formatProvider, out TimeSpan result);
public static bool TryParseExact (string? input, string[] formats, IFormatProvider? formatProvider, out TimeSpan result);
static member TryParseExact : string * string[] * IFormatProvider * TimeSpan -> bool
Public Shared Function TryParseExact (input As String, formats 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.

formats
String[]

Tableau de chaînes de format standard ou personnalisées qui définissent les formats acceptables de input.

formatProvider
IFormatProvider

Objet qui fournit des informations de mise en forme spécifiques à 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 a été convertie avec succès ; sinon, false.

Exemples

L’exemple suivant appelle la méthode TryParseExact(String, String[], IFormatProvider, TimeSpan) pour convertir chaque élément d’un tableau de chaînes en valeur TimeSpan. L’exemple interprète les chaînes à l’aide des conventions de mise en forme de la culture Français - France («fr-FR»). Les chaînes peuvent représenter un intervalle de temps au format court général ou au format long général.

En outre, l’exemple modifie la façon dont les méthodes d’analyse d’intervalle de temps interprètent un chiffre unique. En règle générale, un chiffre unique est interprété comme le nombre de jours dans un intervalle de temps. Au lieu de cela, la chaîne de format personnalisé %h est utilisée pour interpréter un chiffre unique comme le nombre d’heures. Pour que cette modification soit effective, notez que la chaîne de format personnalisée %h doit précéder les autres chaînes de format dans le tableau formats.

using System;
using System.Globalization;

public class Example
{
   public static void Main()
   {
      string[] inputs = { "3", "16:42", "1:6:52:35.0625", 
                          "1:6:52:35,0625" }; 
      string[] formats = { "g", "G", "%h"};
      TimeSpan interval;
      CultureInfo culture = new CultureInfo("fr-FR");
      
      // Parse each string in inputs using formats and the fr-FR culture.
      foreach (string input in inputs) {
         if(TimeSpan.TryParseExact(input, formats, culture, out interval))
            Console.WriteLine("{0} --> {1:c}", input, interval);
         else
            Console.WriteLine("Unable to parse {0}", input);   
      }
   }
}
// The example displays the following output:
//       3 --> 03:00:00
//       16:42 --> 16:42:00
//       Unable to parse 1:6:52:35.0625
//       1:6:52:35,0625 --> 1.06:52:35.0625000

open System
open System.Globalization

let inputs = 
    [| "3"; "16:42"; "1:6:52:35.0625" 
       "1:6:52:35,0625" |] 
let formats = [| "g"; "G"; "%h" |]
let culture = CultureInfo "fr-FR"

// Parse each string in inputs using formats and the fr-FR culture.
for input in inputs do
    match TimeSpan.TryParseExact(input, formats, culture) with
    | true, interval ->
        printfn $"{input} --> {interval:c}"
    | _ ->
        printfn $"Unable to parse {input}"
// The example displays the following output:
//       3 --> 03:00:00
//       16:42 --> 16:42:00
//       Unable to parse 1:6:52:35.0625
//       1:6:52:35,0625 --> 1.06:52:35.0625000

Imports System.Globalization

Module Example
   Public Sub Main()
      Dim inputs() As String = { "3", "16:42", "1:6:52:35.0625", 
                                 "1:6:52:35,0625" } 
      Dim formats() As String = { "%h", "g", "G" }
      Dim interval As TimeSpan
      Dim culture As New CultureInfo("fr-FR")
      
      ' Parse each string in inputs using formats and the fr-FR culture.
      For Each input As String In inputs
         If TimeSpan.TryParseExact(input, formats, culture, interval) Then
            Console.WriteLine("{0} --> {1:c}", input, interval)   
         Else
            Console.WriteLine("Unable to parse {0}", input)   
         End If            
      Next
   End Sub
End Module
' The example displays the following output:
'       3 --> 03:00:00
'       16:42 --> 16:42:00
'       Unable to parse 1:6:52:35.0625
'       1:6:52:35,0625 --> 1.06:52:35.0625000

Remarques

La méthode TryParseExact(String, String[], IFormatProvider, TimeSpan) analyse la représentation sous forme de chaîne d’un intervalle de temps, qui doit être au format défini par l’une des chaînes de format spécifiées par le paramètre formats, sauf que les caractères d’espace blanc de début et de fin sont ignorés. Cette méthode est similaire à la méthode ParseExact(String, String[], IFormatProvider), sauf qu’elle ne lève pas d’exception si la conversion échoue.

Le paramètre formats est un tableau de chaînes dont les éléments se composent d’un spécificateur de format standard unique ou d’un ou plusieurs spécificateurs de format personnalisés qui définissent le format requis de input. Pour plus d’informations sur les chaînes de format valides, consultez chaînes de format timeSpan standard et chaînes de format TimeSpan personnalisées. input doit correspondre exactement à un membre de formats pour que l’opération d’analyse réussisse. L’opération d’analyse tente de faire correspondre input à chaque élément de formats commençant par le premier élément du tableau.

Important

La méthode TryParseExact utilise les conventions de la culture spécifiées par le paramètre formatProvider uniquement si la chaîne de format utilisée pour analyser input est une chaîne de format TimeSpan standard dont la valeur est « g » ou « G ». Les chaînes de format standard « c », « t » et « T » utilisent les conventions de mise en forme de la culture invariante. Les chaînes de format personnalisées définissent le format précis de la chaîne d’entrée et utilisent des caractères littéraux pour séparer les composants d’un intervalle de temps.

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

Si formatProvider est null, l’objet DateTimeFormatInfo associé à la culture actuelle est utilisé.

Voir aussi

S’applique à

TryParseExact(String, String[], IFormatProvider, TimeSpanStyles, TimeSpan)

Source:
TimeSpan.cs
Source:
TimeSpan.cs
Source:
TimeSpan.cs

Convertit la représentation sous forme de chaîne spécifiée d’un intervalle de temps en son équivalent TimeSpan à l’aide des formats spécifiés, des informations et des styles de format spécifiques à la culture. Le format de la représentation sous forme de chaîne doit correspondre exactement à l’un des formats spécifiés.

public:
 static bool TryParseExact(System::String ^ input, cli::array <System::String ^> ^ formats, IFormatProvider ^ formatProvider, System::Globalization::TimeSpanStyles styles, [Runtime::InteropServices::Out] TimeSpan % result);
public static bool TryParseExact (string input, string[] formats, IFormatProvider formatProvider, System.Globalization.TimeSpanStyles styles, out TimeSpan result);
public static bool TryParseExact (string? input, string?[]? formats, IFormatProvider? formatProvider, System.Globalization.TimeSpanStyles styles, out TimeSpan result);
public static bool TryParseExact (string? input, string[] formats, IFormatProvider? formatProvider, System.Globalization.TimeSpanStyles styles, out TimeSpan result);
static member TryParseExact : string * string[] * IFormatProvider * System.Globalization.TimeSpanStyles * TimeSpan -> bool
Public Shared Function TryParseExact (input As String, formats As String(), formatProvider As IFormatProvider, styles As TimeSpanStyles, ByRef result As TimeSpan) As Boolean

Paramètres

input
String

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

formats
String[]

Tableau de chaînes de format standard ou personnalisées qui définissent les formats acceptables de input.

formatProvider
IFormatProvider

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

styles
TimeSpanStyles

Une ou plusieurs valeurs d’énumération qui indiquent le style de input.

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 a été convertie avec succès ; sinon, false.

Exemples

L’exemple suivant appelle la méthode TryParseExact(String, String[], IFormatProvider, TimeSpanStyles, TimeSpan) pour convertir chaque élément d’un tableau de chaînes en valeur TimeSpan. Les chaînes peuvent représenter un intervalle de temps au format court général ou au format long général.

En outre, l’exemple modifie la façon dont les méthodes d’analyse d’intervalle de temps interprètent un chiffre unique. En règle générale, un chiffre unique est interprété comme le nombre de jours dans un intervalle de temps. Au lieu de cela, la chaîne de format personnalisé %h est utilisée pour interpréter un chiffre unique comme le nombre d’heures. Pour que cette modification soit effective, notez que la chaîne de format personnalisée %h doit précéder les autres chaînes de format dans le tableau formats. Notez également à partir de la sortie que l’indicateur de TimeSpanStyles.AssumeNegative spécifié dans l’appel de méthode est utilisé uniquement lors de l’analyse d’une chaîne avec ce spécificateur de format.

using System;
using System.Globalization;

public class Example
{
   public static void Main()
   {
      string[] inputs = { "3", "16:42", "1:6:52:35.0625", 
                          "1:6:52:35,0625" }; 
      string[] formats = { "%h", "g", "G" };
      TimeSpan interval;
      CultureInfo culture = new CultureInfo("fr-FR");
      
      // Parse each string in inputs using formats and the fr-FR culture.
      foreach (string input in inputs) {
         if(TimeSpan.TryParseExact(input, formats, culture, 
                                   TimeSpanStyles.AssumeNegative, out interval))
            Console.WriteLine("{0} --> {1:c}", input, interval);
         else
            Console.WriteLine("Unable to parse {0}", input);   
      }
   }
}
// The example displays the following output:
//       3 --> -03:00:00
//       16:42 --> 16:42:00
//       Unable to parse 1:6:52:35.0625
//       1:6:52:35,0625 --> 1.06:52:35.0625000

open System
open System.Globalization

let inputs = 
    [| "3"; "16:42"; "1:6:52:35.0625" 
       "1:6:52:35,0625" |]
let formats = [| "%h"; "g"; "G" |]
let culture = CultureInfo "fr-FR"

// Parse each string in inputs using formats and the fr-FR culture.
for input in inputs do
    match TimeSpan.TryParseExact(input, formats, culture, TimeSpanStyles.AssumeNegative) with
    | true, interval ->
        printfn $"{input} --> {interval:c}"
    | _ ->
        printfn $"Unable to parse {input}"
// The example displays the following output:
//       3 --> -03:00:00
//       16:42 --> 16:42:00
//       Unable to parse 1:6:52:35.0625
//       1:6:52:35,0625 --> 1.06:52:35.0625000

Imports System.Globalization

Module Example
   Public Sub Main()
      Dim inputs() As String = { "3", "16:42", "1:6:52:35.0625", 
                                 "1:6:52:35,0625" } 
      Dim formats() As String = { "%h", "g", "G" }
      Dim interval As TimeSpan
      Dim culture As New CultureInfo("de-DE")
      
      ' Parse each string in inputs using formats and the fr-FR culture.
      For Each input As String In inputs
         If TimeSpan.TryParseExact(input, formats, culture, 
                                   TimeSpanStyles.AssumeNegative, interval) Then
            Console.WriteLine("{0} --> {1:c}", input, interval)   
         Else
            Console.WriteLine("Unable to parse {0}", input)   
         End If            
      Next
   End Sub
End Module
' The example displays the following output:
'       3 --> -03:00:00
'       16:42 --> 16:42:00
'       Unable to parse 1:6:52:35.0625
'       1:6:52:35,0625 --> 1.06:52:35.0625000

Remarques

La méthode TryParseExact(String, String[], IFormatProvider, TimeSpanStyles, TimeSpan) analyse la représentation sous forme de chaîne d’un intervalle de temps, qui doit être au format défini par l’une des chaînes de format spécifiées par le paramètre formats, sauf que les caractères d’espace blanc de début et de fin sont ignorés. Cette méthode est similaire à la méthode ParseExact(String, String[], IFormatProvider, TimeSpanStyles), sauf qu’elle ne lève pas d’exception si la conversion échoue.

Le paramètre formats est un tableau de chaînes dont les éléments se composent d’un spécificateur de format standard unique ou d’un ou plusieurs spécificateurs de format personnalisés qui définissent le format requis de input. Pour plus d’informations sur les chaînes de format valides, consultez chaînes de format timeSpan standard et chaînes de format TimeSpan personnalisées. input doit correspondre exactement à un membre de formats pour que l’opération d’analyse réussisse. L’opération d’analyse tente de faire correspondre input à chaque élément de formats commençant par le premier élément du tableau.

Important

La méthode ParseExact utilise les conventions de la culture spécifiées par le paramètre formatProvider uniquement si la chaîne de format utilisée pour analyser input est une chaîne de format TimeSpan standard dont la valeur est « g » ou « G ». Les chaînes de format standard « c », « t » et « T » utilisent les conventions de mise en forme de la culture invariante. Les chaînes de format personnalisées définissent le format précis de la chaîne d’entrée et utilisent des caractères littéraux pour séparer les composants d’un intervalle de temps.

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

Si formatProvider est null, l’objet DateTimeFormatInfo associé à la culture actuelle est utilisé.

Le paramètre styles affecte l’interprétation des chaînes analysées à l’aide de chaînes de format personnalisées. Elle détermine si input est interprétée comme un intervalle de temps négatif uniquement si un signe négatif est présent (TimeSpanStyles.None), ou s’il est toujours interprété comme un intervalle de temps négatif (TimeSpanStyles.AssumeNegative). Si TimeSpanStyles.AssumeNegative n’est pas utilisé, format doit inclure un symbole de signe négatif littéral (tel que « \- ») pour analyser correctement un intervalle de temps négatif.

Voir aussi

S’applique à

TryParseExact(ReadOnlySpan<Char>, String[], IFormatProvider, TimeSpan)

Source:
TimeSpan.cs
Source:
TimeSpan.cs
Source:
TimeSpan.cs

Convertit la représentation d’étendue spécifiée d’un intervalle de temps en son TimeSpan équivalent à l’aide des formats spécifiés et des informations de format propres à la culture. Le format de la représentation sous forme de chaîne doit correspondre exactement à l’un des formats spécifiés.

public:
 static bool TryParseExact(ReadOnlySpan<char> input, cli::array <System::String ^> ^ formats, IFormatProvider ^ formatProvider, [Runtime::InteropServices::Out] TimeSpan % result);
public static bool TryParseExact (ReadOnlySpan<char> input, string?[]? formats, IFormatProvider? formatProvider, out TimeSpan result);
public static bool TryParseExact (ReadOnlySpan<char> input, string[] formats, IFormatProvider formatProvider, out TimeSpan result);
public static bool TryParseExact (ReadOnlySpan<char> input, string[] formats, IFormatProvider? formatProvider, out TimeSpan result);
static member TryParseExact : ReadOnlySpan<char> * string[] * IFormatProvider * TimeSpan -> bool
Public Shared Function TryParseExact (input As ReadOnlySpan(Of Char), formats As String(), formatProvider As IFormatProvider, ByRef result As TimeSpan) As Boolean

Paramètres

input
ReadOnlySpan<Char>

Étendue contenant les caractères qui représentent un intervalle de temps à convertir.

formats
String[]

Tableau de chaînes de format standard ou personnalisées qui définissent les formats acceptables de input.

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 a été convertie avec succès ; sinon, false.

S’applique à

TryParseExact(ReadOnlySpan<Char>, ReadOnlySpan<Char>, IFormatProvider, TimeSpan)

Source:
TimeSpan.cs
Source:
TimeSpan.cs
Source:
TimeSpan.cs

Convertit la représentation d’étendue spécifiée d’un intervalle de temps en son équivalent TimeSpan à l’aide des informations de format spécifiques à la culture et au format spécifiés. Le format de la représentation sous forme de chaîne doit correspondre exactement au format spécifié.

public:
 static bool TryParseExact(ReadOnlySpan<char> input, ReadOnlySpan<char> format, IFormatProvider ^ formatProvider, [Runtime::InteropServices::Out] TimeSpan % result);
public static bool TryParseExact (ReadOnlySpan<char> input, ReadOnlySpan<char> format, IFormatProvider? formatProvider, out TimeSpan result);
public static bool TryParseExact (ReadOnlySpan<char> input, ReadOnlySpan<char> format, IFormatProvider formatProvider, out TimeSpan result);
static member TryParseExact : ReadOnlySpan<char> * ReadOnlySpan<char> * IFormatProvider * TimeSpan -> bool
Public Shared Function TryParseExact (input As ReadOnlySpan(Of Char), format As ReadOnlySpan(Of Char), formatProvider As IFormatProvider, ByRef result As TimeSpan) As Boolean

Paramètres

input
ReadOnlySpan<Char>

Étendue contenant les caractères qui représentent un intervalle de temps à convertir.

format
ReadOnlySpan<Char>

Étendue contenant les caractères qui représentent une chaîne de format standard ou personnalisée qui définit le format acceptable de input.

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 a été convertie avec succès ; sinon, false.

S’applique à

TryParseExact(String, String, IFormatProvider, TimeSpan)

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 format spécifiques à la culture et au format spécifiés. Le format de la représentation sous forme de chaîne doit correspondre exactement au format spécifié.

public:
 static bool TryParseExact(System::String ^ input, System::String ^ format, IFormatProvider ^ formatProvider, [Runtime::InteropServices::Out] TimeSpan % result);
public static bool TryParseExact (string input, string format, IFormatProvider formatProvider, out TimeSpan result);
public static bool TryParseExact (string? input, string? format, IFormatProvider? formatProvider, out TimeSpan result);
public static bool TryParseExact (string? input, string format, IFormatProvider? formatProvider, out TimeSpan result);
static member TryParseExact : string * string * IFormatProvider * TimeSpan -> bool
Public Shared Function TryParseExact (input As String, format 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.

format
String

Chaîne de format standard ou personnalisée qui définit le format requis de input.

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 a été convertie avec succès ; sinon, false.

Exemples

L’exemple suivant utilise la méthode TryParseExact(String, String, IFormatProvider, TimeSpanStyles, TimeSpan) pour analyser plusieurs représentations sous forme de chaînes d’intervalles de temps à l’aide de différentes chaînes de format et cultures.

using System;
using System.Globalization;

public class Example
{
   public static void Main()
   {
      string intervalString, format;
      TimeSpan interval;
      CultureInfo culture;
      
      // Parse hour:minute value with "g" specifier current culture.
      intervalString = "17:14";
      format = "g";
      culture = CultureInfo.CurrentCulture;
      if (TimeSpan.TryParseExact(intervalString, format, culture, out interval))
         Console.WriteLine("'{0}' --> {1}", intervalString, interval);
      else
         Console.WriteLine("Unable to parse {0}", intervalString);
      
      // Parse hour:minute:second value with "G" specifier.
      intervalString = "17:14:48";
      format = "G";
      culture = CultureInfo.InvariantCulture;
      if (TimeSpan.TryParseExact(intervalString, format, culture, out interval))
         Console.WriteLine("'{0}' --> {1}", intervalString, interval);
      else
         Console.WriteLine("Unable to parse {0}", intervalString);
      
      // Parse hours:minute.second value with "G" specifier 
      // and current (en-US) culture.     
      intervalString = "17:14:48.153";
      format = "G";
      culture = CultureInfo.CurrentCulture;
      if (TimeSpan.TryParseExact(intervalString, format, culture, out interval))
         Console.WriteLine("'{0}' --> {1}", intervalString, interval);
      else
         Console.WriteLine("Unable to parse {0}", intervalString);

      // Parse days:hours:minute.second value with "G" specifier 
      // and current (en-US) culture.     
      intervalString = "3:17:14:48.153";
      format = "G";
      culture = CultureInfo.CurrentCulture;
      if (TimeSpan.TryParseExact(intervalString, format, culture, out interval))
         Console.WriteLine("'{0}' --> {1}", intervalString, interval);
      else
         Console.WriteLine("Unable to parse {0}", intervalString);
            
      // Parse days:hours:minute.second value with "G" specifier 
      // and fr-FR culture.     
      intervalString = "3:17:14:48.153";
      format = "G";
      culture = new CultureInfo("fr-FR");
      if (TimeSpan.TryParseExact(intervalString, format, culture, out interval))
         Console.WriteLine("'{0}' --> {1}", intervalString, interval);
      else
         Console.WriteLine("Unable to parse {0}", intervalString);
      
      // Parse days:hours:minute.second value with "G" specifier 
      // and fr-FR culture.     
      intervalString = "3:17:14:48,153";
      format = "G";
      if (TimeSpan.TryParseExact(intervalString, format, culture, out interval))
         Console.WriteLine("'{0}' --> {1}", intervalString, interval);
      else
         Console.WriteLine("Unable to parse {0}", intervalString);

      // Parse a single number using the "c" standard format string. 
      intervalString = "12";
      format = "c";
      if (TimeSpan.TryParseExact(intervalString, format, null, out interval))
         Console.WriteLine("'{0}' --> {1}", intervalString, interval);
      else
         Console.WriteLine("Unable to parse {0}", intervalString);
      
      // Parse a single number using the "%h" custom format string. 
      format = "%h";
      if (TimeSpan.TryParseExact(intervalString, format, null, out interval))
         Console.WriteLine("'{0}' --> {1}", intervalString, interval);
      else
         Console.WriteLine("Unable to parse {0}", intervalString);
      
      // Parse a single number using the "%s" custom format string. 
      format = "%s";
      if (TimeSpan.TryParseExact(intervalString, format, null, out interval))
         Console.WriteLine("'{0}' --> {1}", intervalString, interval);
      else
         Console.WriteLine("Unable to parse {0}", intervalString);
   }
}
// The example displays the following output:
//       '17:14' --> 17:14:00
//       Unable to parse 17:14:48
//       Unable to parse 17:14:48.153
//       '3:17:14:48.153' --> 3.17:14:48.1530000
//       Unable to parse 3:17:14:48.153
//       '3:17:14:48,153' --> 3.17:14:48.1530000
//       '12' --> 12.00:00:00
//       '12' --> 12:00:00
//       '12' --> 00:00:12

open System
open System.Globalization

do
    // Parse hour:minute value with "g" specifier current culture.
    let intervalString = "17:14"
    let format = "g"
    let culture = CultureInfo.CurrentCulture
    match TimeSpan.TryParseExact(intervalString, format, culture) with
    | true, interval ->
        printfn $"'{intervalString}' --> {interval}"
    | _ ->
        printfn $"Unable to parse {intervalString}"
    
    // Parse hour:minute:second value with "G" specifier.
    let intervalString = "17:14:48"
    let format = "G"
    let culture = CultureInfo.InvariantCulture
    match TimeSpan.TryParseExact(intervalString, format, culture) with
    | true, interval ->
        printfn $"'{intervalString}' --> {interval}"
    | _ ->
        printfn $"Unable to parse {intervalString}"
    
    // Parse hours:minute.second value with "G" specifier 
    // and current (en-US) culture.     
    let intervalString = "17:14:48.153"
    let format = "G"
    let culture = CultureInfo.CurrentCulture
    match TimeSpan.TryParseExact(intervalString, format, culture) with
    | true, interval ->
        printfn $"'{intervalString}' --> {interval}"
    | _ ->
        printfn $"Unable to parse {intervalString}"

    // Parse days:hours:minute.second value with "G" specifier 
    // and current (en-US) culture.     
    let intervalString = "3:17:14:48.153"
    let format = "G"
    let culture = CultureInfo.CurrentCulture
    match TimeSpan.TryParseExact(intervalString, format, culture) with
    | true, interval ->
        printfn $"'{intervalString}' --> {interval}"
    | _ ->
        printfn $"Unable to parse {intervalString}"
        
    // Parse days:hours:minute.second value with "G" specifier 
    // and fr-FR culture.     
    let intervalString = "3:17:14:48.153"
    let format = "G"
    let culture = new CultureInfo("fr-FR")
    match TimeSpan.TryParseExact(intervalString, format, culture) with
    | true, interval ->
        printfn $"'{intervalString}' --> {interval}"
    | _ ->
        printfn $"Unable to parse {intervalString}"
    
    // Parse days:hours:minute.second value with "G" specifier 
    // and fr-FR culture.     
    let intervalString = "3:17:14:48,153"
    let format = "G"
    match TimeSpan.TryParseExact(intervalString, format, culture) with
    | true, interval ->
        printfn $"'{intervalString}' --> {interval}"
    | _ ->
        printfn $"Unable to parse {intervalString}"

    // Parse a single number using the "c" standard format string. 
    let intervalString = "12"
    let format = "c"
    match TimeSpan.TryParseExact(intervalString, format, null) with
    | true, interval ->
        printfn $"'{intervalString}' --> {interval}"
    | _ ->
        printfn $"Unable to parse {intervalString}"
    
    // Parse a single number using the "%h" custom format string. 
    let format = "%h"
    match TimeSpan.TryParseExact(intervalString, format, null) with
    | true, interval ->
        printfn $"'{intervalString}' --> {interval}"
    | _ ->
        printfn $"Unable to parse {intervalString}"
    
    // Parse a single number using the "%s" custom format string. 
    let format = "%s"
    match TimeSpan.TryParseExact(intervalString, format, null) with
    | true, interval ->
        printfn $"'{intervalString}' --> {interval}"
    | _ ->
        printfn $"Unable to parse {intervalString}"
// The example displays the following output:
//       '17:14' --> 17:14:00
//       Unable to parse 17:14:48
//       Unable to parse 17:14:48.153
//       '3:17:14:48.153' --> 3.17:14:48.1530000
//       Unable to parse 3:17:14:48.153
//       '3:17:14:48,153' --> 3.17:14:48.1530000
//       '12' --> 12.00:00:00
//       '12' --> 12:00:00
//       '12' --> 00:00:12

Imports System.Globalization

Module Example
   Public Sub Main()
      Dim intervalString, format As String
      Dim interval As TimeSpan
      Dim culture As CultureInfo
      
      ' Parse hour:minute value with "g" specifier current culture.
      intervalString = "17:14"
      format = "g"
      culture = CultureInfo.CurrentCulture
      If TimeSpan.TryParseExact(intervalString, format, culture, interval) Then
         Console.WriteLine("'{0}' --> {1}", intervalString, interval)
      Else
         Console.WriteLine("Unable to parse {0}", intervalString)
      End If
      
      ' Parse hour:minute:second value with "G" specifier.
      intervalString = "17:14:48"
      format = "G"
      culture = CultureInfo.InvariantCulture
      If TimeSpan.TryParseExact(intervalString, format, culture, interval) Then
         Console.WriteLine("'{0}' --> {1}", intervalString, interval)
      Else
         Console.WriteLine("Unable to parse {0}", intervalString)
      End If

      ' Parse hours:minute.second value with "G" specifier 
      ' and current (en-US) culture.     
      intervalString = "17:14:48.153"
      format = "G"
      culture = CultureInfo.CurrentCulture
      If TimeSpan.TryParseExact(intervalString, format, culture, interval) Then
         Console.WriteLine("'{0}' --> {1}", intervalString, interval)
      Else
         Console.WriteLine("Unable to parse {0}", intervalString)
      End If

      ' Parse days:hours:minute.second value with "G" specifier 
      ' and current (en-US) culture.     
      intervalString = "3:17:14:48.153"
      format = "G"
      culture = CultureInfo.CurrentCulture
      If TimeSpan.TryParseExact(intervalString, format, culture, interval) Then
         Console.WriteLine("'{0}' --> {1}", intervalString, interval)
      Else
         Console.WriteLine("Unable to parse {0}", intervalString)
      End If
            
      ' Parse days:hours:minute.second value with "G" specifier 
      ' and fr-FR culture.     
      intervalString = "3:17:14:48.153"
      format = "G"
      culture = New CultureInfo("fr-FR")
      If TimeSpan.TryParseExact(intervalString, format, culture, interval) Then
         Console.WriteLine("'{0}' --> {1}", intervalString, interval)
      Else
         Console.WriteLine("Unable to parse {0}", intervalString)
      End If
      
      ' Parse days:hours:minute.second value with "G" specifier 
      ' and fr-FR culture.     
      intervalString = "3:17:14:48,153"
      format = "G"
      culture = New CultureInfo("fr-FR")
      If TimeSpan.TryParseExact(intervalString, format, culture, interval) Then
         Console.WriteLine("'{0}' --> {1}", intervalString, interval)
      Else
         Console.WriteLine("Unable to parse {0}", intervalString)
      End If

      ' Parse a single number using the "c" standard format string. 
      intervalString = "12"
      format = "c"
      If TimeSpan.TryParseExact(intervalString, format, Nothing, interval)
         Console.WriteLine("'{0}' --> {1}", intervalString, interval)
      Else
         Console.WriteLine("Unable to parse {0}", intervalString)
      End If
      
      ' Parse a single number using the "%h" custom format string. 
      format = "%h"
      If TimeSpan.TryParseExact(intervalString, format, Nothing, interval)
         Console.WriteLine("'{0}' --> {1}", intervalString, interval)
      Else
         Console.WriteLine("Unable to parse {0}", intervalString)
      End If
      
      ' Parse a single number using the "%s" custom format string. 
      format = "%s"
      If TimeSpan.TryParseExact(intervalString, format, Nothing, interval) Then
         Console.WriteLine("'{0}' --> {1}", intervalString, interval)
      Else
         Console.WriteLine("Unable to parse {0}", intervalString)
      End If
   End Sub
End Module
' The example displays the following output:
'       '17:14' --> 17:14:00
'       Unable to parse 17:14:48
'       Unable to parse 17:14:48.153
'       '3:17:14:48.153' --> 3.17:14:48.1530000
'       Unable to parse 3:17:14:48.153
'       '3:17:14:48,153' --> 3.17:14:48.1530000
'       '12' --> 12.00:00:00
'       '12' --> 12:00:00
'       '12' --> 00:00:12

Remarques

La méthode TryParseExact(String, String, IFormatProvider, TimeSpan) analyse la représentation sous forme de chaîne d’un intervalle de temps, qui doit être au format défini par le paramètre format, sauf que les caractères d’espace blanc de début et de fin sont ignorés. Cette méthode est similaire à la méthode ParseExact(String, String, IFormatProvider), sauf qu’elle ne lève pas d’exception si la conversion échoue.

Le paramètre format est une chaîne qui contient un spécificateur de format standard unique, ou un ou plusieurs spécificateurs de format personnalisés qui définissent le format requis de input. Pour plus d’informations sur les chaînes de format valides, consultez chaînes de format timeSpan standard et chaînes de format TimeSpan personnalisées.

Important

La méthode TryParseExact(String, String, IFormatProvider, TimeSpan) utilise les conventions de la culture spécifiées par le paramètre formatProvider uniquement si format est une chaîne de format TimeSpan standard dont la valeur est « g » ou « G ». Les chaînes de format standard « c », « t » et « T » utilisent les conventions de mise en forme de la culture invariante. Les chaînes de format personnalisées définissent le format précis de la chaîne d’entrée et utilisent des caractères littéraux pour séparer les composants d’un intervalle de temps.

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

Si formatProvider est null, l’objet DateTimeFormatInfo associé à la culture actuelle est utilisé.

Voir aussi

S’applique à