Chaînes de format TimeSpan personnalisées

Une chaîne de format TimeSpan définit la représentation sous forme de chaîne d’une valeur TimeSpan qui résulte d’une opération de mise en forme. Une chaîne de format personnalisée se compose d’un ou plusieurs spécificateurs de format TimeSpan personnalisés, ainsi que d’un nombre quelconque de caractères littérals. Toute chaîne qui n’est pas une chaîne de format TimeSpan standard est interprétée comme une chaîne de format TimeSpan personnalisée.

Important

Les spécificateurs de format de TimeSpan personnalisés n’incluent pas de symboles de séparateur d’espace réservé, tels que les symboles qui séparent les jours des heures, les heures de minutes ou les secondes par rapport aux fractions de secondes. Au lieu de cela, ces symboles doivent être inclus dans la chaîne de format personnalisée en tant que littéraux de chaîne. Par exemple, "dd\.hh\:mm" définit un point (.) comme séparateur entre les jours et les heures, et un signe deux-points (:) comme séparateur entre les heures et les minutes.

Les spécificateurs de format de TimeSpan personnalisés n’incluent pas non plus de symbole de signe qui vous permet de différencier les intervalles de temps négatifs et positifs. Pour inclure un symbole de signe, vous devez construire une chaîne de format à l’aide de la logique conditionnelle. La section Autres caractères inclut un exemple.

Les représentations sous forme de chaîne de valeurs TimeSpan sont produites par des appels aux surcharges de la méthode TimeSpan.ToString et par des méthodes qui prennent en charge la mise en forme composite, comme String.Format. Pour plus d’informations, consultez types de mise en forme et de mise en forme composite. L’exemple suivant illustre l’utilisation de chaînes de format personnalisées dans les opérations de mise en forme.

using System;

public class Example
{
   public static void Main()
   {
      TimeSpan duration = new TimeSpan(1, 12, 23, 62);

      string output = null;
      output = "Time of Travel: " + duration.ToString("%d") + " days";
      Console.WriteLine(output);
      output = "Time of Travel: " + duration.ToString(@"dd\.hh\:mm\:ss");
      Console.WriteLine(output);

      Console.WriteLine($"Time of Travel: {duration:%d} day(s)");
      Console.WriteLine($"Time of Travel: {duration:dd\\.hh\\:mm\\:ss} days");
   }
}
// The example displays the following output:
//       Time of Travel: 1 days
//       Time of Travel: 01.12:24:02
//       Time of Travel: 1 day(s)
//       Time of Travel: 01.12:24:02 days

Module Example
    Public Sub Main()
        Dim duration As New TimeSpan(1, 12, 23, 62)

        Dim output As String = Nothing
        output = "Time of Travel: " + duration.ToString("%d") + " days"
        Console.WriteLine(output)
        output = "Time of Travel: " + duration.ToString("dd\.hh\:mm\:ss")
        Console.WriteLine(output)

        Console.WriteLine("Time of Travel: {0:%d} day(s)", duration)
        Console.WriteLine("Time of Travel: {0:dd\.hh\:mm\:ss} days", duration)
    End Sub
End Module
' The example displays the following output:
'       Time of Travel: 1 days
'       Time of Travel: 01.12:24:02
'       Time of Travel: 1 day(s)
'       Time of Travel: 01.12:24:02 days

Les chaînes de format TimeSpan personnalisées sont également utilisées par les méthodes TimeSpan.ParseExact et TimeSpan.TryParseExact pour définir le format requis des chaînes d’entrée pour les opérations d’analyse. (L’analyse convertit la représentation sous forme de chaîne d’une valeur en cette valeur.) L’exemple suivant illustre l’utilisation de chaînes de format standard dans les opérations d’analyse.

using System;

public class Example
{
   public static void Main()
   {
      string value = null;
      TimeSpan interval;

      value = "6";
      if (TimeSpan.TryParseExact(value, "%d", null, out interval))
         Console.WriteLine($"{value} --> {interval.ToString("c")}");
      else
         Console.WriteLine($"Unable to parse '{value}'");

      value = "16:32.05";
      if (TimeSpan.TryParseExact(value, @"mm\:ss\.ff", null, out interval))
         Console.WriteLine($"{value} --> {interval.ToString("c")}");
      else
         Console.WriteLine($"Unable to parse '{value}'");

      value= "12.035";
      if (TimeSpan.TryParseExact(value, "ss\\.fff", null, out interval))
         Console.WriteLine($"{value} --> {interval.ToString("c")}");
      else
         Console.WriteLine($"Unable to parse '{value}'");
   }
}
// The example displays the following output:
//       6 --> 6.00:00:00
//       16:32.05 --> 00:16:32.0500000
//       12.035 --> 00:00:12.0350000

Module Example
    Public Sub Main()
        Dim value As String = Nothing
        Dim interval As TimeSpan

        value = "6"
        If TimeSpan.TryParseExact(value, "%d", Nothing, interval) Then
            Console.WriteLine("{0} --> {1}", value, interval.ToString("c"))
        Else
            Console.WriteLine("Unable to parse '{0}'", value)
        End If

        value = "16:32.05"
        If TimeSpan.TryParseExact(value, "mm\:ss\.ff", Nothing, interval) Then
            Console.WriteLine("{0} --> {1}", value, interval.ToString("c"))
        Else
            Console.WriteLine("Unable to parse '{0}'", value)
        End If

        value = "12.035"
        If TimeSpan.TryParseExact(value, "ss\.fff", Nothing, interval) Then
            Console.WriteLine("{0} --> {1}", value, interval.ToString("c"))
        Else
            Console.WriteLine("Unable to parse '{0}'", value)
        End If
    End Sub
End Module
' The example displays the following output:
'       6 --> 6.00:00:00
'       16:32.05 --> 00:16:32.0500000
'       12.035 --> 00:00:12.0350000

Le tableau suivant décrit les spécificateurs de format de date et d’heure personnalisés.

Spécificateur de format	Description	Exemple :
« d », "%d»	Nombre de jours entiers dans l’intervalle de temps. Informations supplémentaires : Spécificateur de format personnalisé "d".	new TimeSpan(6, 14, 32, 17, 685): %d --> « 6 » d\.hh\:mm --> « 6.14:32 »
« dd »-« ddddddd »	Nombre de jours entiers dans l’intervalle de temps, rempli de zéros non significatifs selon les besoins. Plus d’informations : spécificateurs de format personnalisé « ddd ».	new TimeSpan(6, 14, 32, 17, 685): ddd --> « 006 » dd\.hh\:mm --> « 06.14:32 »
« h », "%h»	Nombre d’heures entières dans l’intervalle de temps qui ne sont pas comptabilisées dans le cadre des jours. Les heures à un chiffre n’ont pas de zéro non significatif. Informations supplémentaires : Spécificateur de format personnalisé "h".	new TimeSpan(6, 14, 32, 17, 685): %h --> « 14 » hh\:mm --> « 14:32 »
"hh"	Nombre d’heures entières dans l’intervalle de temps qui ne sont pas comptabilisées dans le cadre des jours. Les heures à un chiffre ont un zéro non significatif. Informations supplémentaires : Spécificateur de format personnalisé "hh".	new TimeSpan(6, 14, 32, 17, 685): hh --> « 14 » new TimeSpan(6, 8, 32, 17, 685): hh --> 08
« m », "%m»	Nombre de minutes entières dans l’intervalle de temps qui ne sont pas inclus dans les heures ou les jours. Les minutes à un chiffre n’ont pas de zéro non significatif. Informations supplémentaires : Spécificateur de format personnalisé "m".	new TimeSpan(6, 14, 8, 17, 685): %m --> « 8 » h\:m --> « 14:8 »
"mm"	Nombre de minutes entières dans l’intervalle de temps qui ne sont pas inclus dans les heures ou les jours. Les minutes à un chiffre ont un zéro non significatif. Informations supplémentaires : Spécificateur de format personnalisé "mm".	new TimeSpan(6, 14, 8, 17, 685): mm --> « 08 » new TimeSpan(6, 8, 5, 17, 685): d\.hh\:mm\:ss --> 6.08:05:17
« s », "%s»	Nombre de secondes entières dans l’intervalle de temps qui ne sont pas inclus dans les heures, les jours ou les minutes. Les secondes à un chiffre n’ont pas de zéro non significatif. Informations supplémentaires : Spécificateur de format personnalisé "s".	TimeSpan.FromSeconds(12.965) : %s --> 12 s\.fff --> 12.965
"ss"	Nombre de secondes entières dans l’intervalle de temps qui ne sont pas inclus dans les heures, les jours ou les minutes. Les secondes à un chiffre ont un zéro non significatif. Informations supplémentaires : Spécificateur de format personnalisé "ss".	TimeSpan.FromSeconds(6.965) : ss --> 06 ss\.fff --> 06.965
« f », "%f»	Dixièmes d’une seconde dans un intervalle de temps. Informations supplémentaires : Spécificateur de format personnalisé "f".	TimeSpan.FromSeconds(6.895) : f --> 8 ss\.f --> 06.8
"ff"	Centièmes d’une seconde dans un intervalle de temps. Informations supplémentaires : Spécificateur de format personnalisé "ff".	TimeSpan.FromSeconds(6.895) : ff --> 89 ss\.ff --> 06.89
"fff"	Millisecondes dans un intervalle de temps. Informations supplémentaires : Spécificateur de format personnalisé "fff".	TimeSpan.FromSeconds(6.895) : fff --> 895 ss\.fff --> 06.895
"ffff"	Les dix millièmes d’une seconde dans un intervalle de temps. Informations supplémentaires : Spécificateur de format personnalisé "ffff".	TimeSpan.Parse("0:0:6.8954321") : ffff --> 8954 ss\.ffff --> 06.8954
"fffff"	Cent millièmes d’une seconde dans un intervalle de temps. Informations supplémentaires : Spécificateur de format personnalisé "fffff".	TimeSpan.Parse("0:0:6.8954321") : fffff --> 89543 ss\.fffff --> 06.89543
"ffffff"	Les millionièmes d’une seconde dans un intervalle de temps. Informations supplémentaires : Spécificateur de format personnalisé "ffffff".	TimeSpan.Parse("0:0:6.8954321") : ffffff --> 895432 ss\.ffffff --> 06.895432
"fffffff"	Les dix millionièmes d’une seconde (ou les cycles fractionnaires) dans un intervalle de temps. Informations supplémentaires : Spécificateur de format personnalisé "fffffff".	TimeSpan.Parse("0:0:6.8954321") : fffffff --> 8954321 ss\.fffffff --> 06.8954321
« F », "%F»	Dixièmes d’une seconde dans un intervalle de temps. Rien n’est affiché si le chiffre est égal à zéro. Informations supplémentaires : Spécificateur de format personnalisé "F".	TimeSpan.Parse("00:00:06.32") : %F : 3 TimeSpan.Parse("0:0:3.091") : ss\.F: 03.
"FF"	Centièmes d’une seconde dans un intervalle de temps. Les zéros de fin fractionnaires ou deux chiffres zéro ne sont pas inclus. Informations supplémentaires : Spécificateur de format personnalisé "FF".	TimeSpan.Parse("00:00:06.329") : FF: 32 TimeSpan.Parse("0:0:3.101") : ss\.FF: 03.1
"FFF"	Millisecondes dans un intervalle de temps. Les zéros de fin fractionnaires ne sont pas inclus. Pour plus d’informations :	TimeSpan.Parse("00:00:06.3291") : FFF: 329 TimeSpan.Parse("0:0:3.1009") : ss\.FFF: 03.1
"FFFF"	Les dix millièmes d’une seconde dans un intervalle de temps. Les zéros de fin fractionnaires ne sont pas inclus. Informations supplémentaires : Spécificateur de format personnalisé "FFFF".	TimeSpan.Parse("00:00:06.32917") : FFFFF: 3291 TimeSpan.Parse("0:0:3.10009") : ss\.FFFF: 03.1
"FFFFF"	Cent millièmes d’une seconde dans un intervalle de temps. Les zéros de fin fractionnaires ne sont pas inclus. Informations supplémentaires : Spécificateur de format personnalisé "FFFFF".	TimeSpan.Parse("00:00:06.329179") : FFFFF: 32917 TimeSpan.Parse("0:0:3.100009") : ss\.FFFFF: 03.1
"FFFFFF"	Les millionièmes d’une seconde dans un intervalle de temps. Les zéros de fin fractionnaires ne sont pas affichés. Informations supplémentaires : Spécificateur de format personnalisé "FFFFFF".	TimeSpan.Parse("00:00:06.3291791") : FFFFFF: 329179 TimeSpan.Parse("0:0:3.1000009") : ss\.FFFFFF: 03.1
"FFFFFFF"	Les dix millions d’une seconde dans un intervalle de temps. Les zéros de fin fractionnaires ou sept zéros ne sont pas affichés. Informations supplémentaires : Spécificateur de format personnalisé "FFFFFFF".	TimeSpan.Parse("00:00:06.3291791") : FFFFFF: 3291791 TimeSpan.Parse("0:0:3.1900000") : ss\.FFFFFF: 03.19
'chaîne'	Délimiteur de chaîne littérale. Plus d’informations : Autres caractères.	new TimeSpan(14, 32, 17): hh':'mm':'ss --> « 14:32:17 »
\	Caractère d’échappement. Plus d’informations : Autres caractères.	new TimeSpan(14, 32, 17): hh\:mm\:ss --> « 14:32:17 »
N'importe quel autre caractère	Tout autre caractère non boucté est interprété comme spécificateur de format personnalisé. Plus d’informations : autres caractères.	new TimeSpan(14, 32, 17): hh\:mm\:ss --> « 14:32:17 »

Spécificateur de format personnalisé "d"

Le spécificateur de format personnalisé « d » génère la valeur de la propriété TimeSpan.Days, qui représente le nombre de jours entiers dans l’intervalle de temps. Il génère le nombre total de jours dans une valeur TimeSpan, même si la valeur a plusieurs chiffres. Si la valeur de la propriété TimeSpan.Days est égale à zéro, le spécificateur génère « 0 ».

Si le spécificateur de format personnalisé « d » est utilisé seul, spécifiez «%d» afin qu’il ne soit pas mal interprété comme une chaîne de format standard. L'exemple suivant illustre cette situation.

TimeSpan ts1 = new TimeSpan(16, 4, 3, 17, 250);
Console.WriteLine(ts1.ToString("%d"));
// Displays 16

Dim ts As New TimeSpan(16, 4, 3, 17, 250)
Console.WriteLine(ts.ToString("%d"))
' Displays 16   

L’exemple suivant illustre l’utilisation du spécificateur de format personnalisé « d ».

TimeSpan ts2 = new TimeSpan(4, 3, 17);
Console.WriteLine(ts2.ToString(@"d\.hh\:mm\:ss"));

TimeSpan ts3 = new TimeSpan(3, 4, 3, 17);
Console.WriteLine(ts3.ToString(@"d\.hh\:mm\:ss"));
// The example displays the following output:
//       0.04:03:17
//       3.04:03:17

Dim ts2 As New TimeSpan(4, 3, 17)
Console.WriteLine(ts2.ToString("d\.hh\:mm\:ss"))

Dim ts3 As New TimeSpan(3, 4, 3, 17)
Console.WriteLine(ts3.ToString("d\.hh\:mm\:ss"))
' The example displays the following output:
'       0.04:03:17
'       3.04:03:17      

Retour au tableau

Spécificateurs de format personnalisé « ddd »

Les spécificateurs de format personnalisés « d », « d », « d », « ddddd », « ddd », « d » et « d » génèrent la valeur de la propriété TimeSpan.Days, qui représente le nombre de jours entiers dans l’intervalle de temps.

La chaîne de sortie inclut un nombre minimal de chiffres spécifié par le nombre de caractères « d » dans le spécificateur de format, et il est rempli de zéros non significatifs selon les besoins. Si les chiffres du nombre de jours dépassent le nombre de caractères « d » dans le spécificateur de format, le nombre total de jours est généré dans la chaîne de résultat.

L’exemple suivant utilise ces spécificateurs de format pour afficher la représentation sous forme de chaîne de deux valeurs TimeSpan. La valeur du composant jours du premier intervalle de temps est égale à zéro ; la valeur du composant jours de la seconde est 365.

TimeSpan ts1 = new TimeSpan(0, 23, 17, 47);
TimeSpan ts2 = new TimeSpan(365, 21, 19, 45);

for (int ctr = 2; ctr <= 8; ctr++)
{
   string fmt = new String('d', ctr) + @"\.hh\:mm\:ss";
   Console.WriteLine($"{fmt} --> {ts1.ToString(fmt)}");
   Console.WriteLine($"{fmt} --> {ts2.ToString(fmt)}");
   Console.WriteLine();
}
// The example displays the following output:
//       dd\.hh\:mm\:ss --> 00.23:17:47
//       dd\.hh\:mm\:ss --> 365.21:19:45
//
//       ddd\.hh\:mm\:ss --> 000.23:17:47
//       ddd\.hh\:mm\:ss --> 365.21:19:45
//
//       dddd\.hh\:mm\:ss --> 0000.23:17:47
//       dddd\.hh\:mm\:ss --> 0365.21:19:45
//
//       ddddd\.hh\:mm\:ss --> 00000.23:17:47
//       ddddd\.hh\:mm\:ss --> 00365.21:19:45
//
//       dddddd\.hh\:mm\:ss --> 000000.23:17:47
//       dddddd\.hh\:mm\:ss --> 000365.21:19:45
//
//       ddddddd\.hh\:mm\:ss --> 0000000.23:17:47
//       ddddddd\.hh\:mm\:ss --> 0000365.21:19:45
//
//       dddddddd\.hh\:mm\:ss --> 00000000.23:17:47
//       dddddddd\.hh\:mm\:ss --> 00000365.21:19:45

Dim ts1 As New TimeSpan(0, 23, 17, 47)
Dim ts2 As New TimeSpan(365, 21, 19, 45)

For ctr As Integer = 2 To 8
    Dim fmt As String = New String("d"c, ctr) + "\.hh\:mm\:ss"
    Console.WriteLine("{0} --> {1:" + fmt + "}", fmt, ts1)
    Console.WriteLine("{0} --> {1:" + fmt + "}", fmt, ts2)
    Console.WriteLine()
Next
' The example displays the following output:
'       dd\.hh\:mm\:ss --> 00.23:17:47
'       dd\.hh\:mm\:ss --> 365.21:19:45
'       
'       ddd\.hh\:mm\:ss --> 000.23:17:47
'       ddd\.hh\:mm\:ss --> 365.21:19:45
'       
'       dddd\.hh\:mm\:ss --> 0000.23:17:47
'       dddd\.hh\:mm\:ss --> 0365.21:19:45
'       
'       ddddd\.hh\:mm\:ss --> 00000.23:17:47
'       ddddd\.hh\:mm\:ss --> 00365.21:19:45
'       
'       dddddd\.hh\:mm\:ss --> 000000.23:17:47
'       dddddd\.hh\:mm\:ss --> 000365.21:19:45
'       
'       ddddddd\.hh\:mm\:ss --> 0000000.23:17:47
'       ddddddd\.hh\:mm\:ss --> 0000365.21:19:45
'       
'       dddddddd\.hh\:mm\:ss --> 00000000.23:17:47
'       dddddddd\.hh\:mm\:ss --> 00000365.21:19:45      

Retour au tableau

Spécificateur de format personnalisé "h"

Le spécificateur de format personnalisé « h » génère la valeur de la propriété TimeSpan.Hours, qui représente le nombre d’heures entières dans l’intervalle de temps qui n’est pas comptabilisé dans le composant jour. Elle retourne une valeur de chaîne à un chiffre si la valeur de la propriété TimeSpan.Hours est comprise entre 0 et 9, et retourne une valeur de chaîne à deux chiffres si la valeur de la propriété TimeSpan.Hours est comprise entre 10 et 23.

Si le spécificateur de format personnalisé « h » est utilisé seul, spécifiez «%h» afin qu’il ne soit pas mal interprété comme une chaîne de format standard. L'exemple suivant illustre cette situation.

TimeSpan ts = new TimeSpan(3, 42, 0);
Console.WriteLine($"{ts:%h} hours {ts:%m} minutes");
// The example displays the following output:
//       3 hours 42 minutes

Dim ts As New TimeSpan(3, 42, 0)
Console.WriteLine("{0:%h} hours {0:%m} minutes", ts)
' The example displays the following output:
'       3 hours 42 minutes

En règle générale, dans une opération d’analyse, une chaîne d’entrée qui inclut un seul nombre est interprétée comme le nombre de jours. Vous pouvez utiliser le spécificateur de format personnalisé «%h» pour interpréter la chaîne numérique comme le nombre d’heures. L'exemple suivant illustre cette situation.

string value = "8";
TimeSpan interval;
if (TimeSpan.TryParseExact(value, "%h", null, out interval))
   Console.WriteLine(interval.ToString("c"));
else
   Console.WriteLine($"Unable to convert '{value}' to a time interval");
// The example displays the following output:
//       08:00:00

Dim value As String = "8"
Dim interval As TimeSpan
If TimeSpan.TryParseExact(value, "%h", Nothing, interval) Then
    Console.WriteLine(interval.ToString("c"))
Else
    Console.WriteLine("Unable to convert '{0}' to a time interval",
                      value)
End If
' The example displays the following output:
'       08:00:00                              

L’exemple suivant illustre l’utilisation du spécificateur de format personnalisé « h ».

TimeSpan ts1 = new TimeSpan(14, 3, 17);
Console.WriteLine(ts1.ToString(@"d\.h\:mm\:ss"));

TimeSpan ts2 = new TimeSpan(3, 4, 3, 17);
Console.WriteLine(ts2.ToString(@"d\.h\:mm\:ss"));
// The example displays the following output:
//       0.14:03:17
//       3.4:03:17

Dim ts1 As New TimeSpan(14, 3, 17)
Console.WriteLine(ts1.ToString("d\.h\:mm\:ss"))

Dim ts2 As New TimeSpan(3, 4, 3, 17)
Console.WriteLine(ts2.ToString("d\.h\:mm\:ss"))
' The example displays the following output:
'       0.14:03:17
'       3.4:03:17

Retour au tableau

Spécificateur de format personnalisé "hh"

Le spécificateur de format personnalisé « hh » génère la valeur de la propriété TimeSpan.Hours, qui représente le nombre d’heures entières dans l’intervalle de temps qui n’est pas compté dans le cadre de son composant jour. Pour les valeurs comprises entre 0 et 9, la chaîne de sortie inclut un zéro non significatif.

En règle générale, dans une opération d’analyse, une chaîne d’entrée qui inclut un seul nombre est interprétée comme le nombre de jours. Vous pouvez utiliser le spécificateur de format personnalisé « hh » à la place pour interpréter la chaîne numérique comme nombre d’heures. L'exemple suivant illustre cette situation.

string value = "08";
TimeSpan interval;
if (TimeSpan.TryParseExact(value, "hh", null, out interval))
   Console.WriteLine(interval.ToString("c"));
else
   Console.WriteLine($"Unable to convert '{value}' to a time interval");
// The example displays the following output:
//       08:00:00

Dim value As String = "08"
Dim interval As TimeSpan
If TimeSpan.TryParseExact(value, "hh", Nothing, interval) Then
    Console.WriteLine(interval.ToString("c"))
Else
    Console.WriteLine("Unable to convert '{0}' to a time interval",
                      value)
End If
' The example displays the following output:
'       08:00:00                              

L’exemple suivant illustre l’utilisation du spécificateur de format personnalisé « hh ».

TimeSpan ts1 = new TimeSpan(14, 3, 17);
Console.WriteLine(ts1.ToString(@"d\.hh\:mm\:ss"));

TimeSpan ts2 = new TimeSpan(3, 4, 3, 17);
Console.WriteLine(ts2.ToString(@"d\.hh\:mm\:ss"));
// The example displays the following output:
//       0.14:03:17
//       3.04:03:17

Dim ts1 As New TimeSpan(14, 3, 17)
Console.WriteLine(ts1.ToString("d\.hh\:mm\:ss"))

Dim ts2 As New TimeSpan(3, 4, 3, 17)
Console.WriteLine(ts2.ToString("d\.hh\:mm\:ss"))
' The example displays the following output:
'       0.14:03:17
'       3.04:03:17

Retour au tableau

Spécificateur de format personnalisé "m"

Le spécificateur de format personnalisé « m » génère la valeur de la propriété TimeSpan.Minutes, qui représente le nombre de minutes entières dans l’intervalle de temps qui n’est pas comptabilisé dans le composant jour. Elle retourne une valeur de chaîne à un chiffre si la valeur de la propriété TimeSpan.Minutes est comprise entre 0 et 9, et retourne une valeur de chaîne à deux chiffres si la valeur de la propriété TimeSpan.Minutes est comprise entre 10 et 59.

Si le spécificateur de format personnalisé « m » est utilisé seul, spécifiez «%m» afin qu’il ne soit pas mal interprété comme une chaîne de format standard. L'exemple suivant illustre cette situation.

TimeSpan ts = new TimeSpan(3, 42, 0);
Console.WriteLine($"{ts:%h} hours {ts:%m} minutes");
// The example displays the following output:
//       3 hours 42 minutes

Dim ts As New TimeSpan(3, 42, 0)
Console.WriteLine("{0:%h} hours {0:%m} minutes", ts)
' The example displays the following output:
'       3 hours 42 minutes

En règle générale, dans une opération d’analyse, une chaîne d’entrée qui inclut un seul nombre est interprétée comme le nombre de jours. Vous pouvez utiliser le spécificateur de format personnalisé «%m» pour interpréter la chaîne numérique comme le nombre de minutes. L'exemple suivant illustre cette situation.

string value = "3";
TimeSpan interval;
if (TimeSpan.TryParseExact(value, "%m", null, out interval))
   Console.WriteLine(interval.ToString("c"));
else
   Console.WriteLine($"Unable to convert '{value}' to a time interval");
// The example displays the following output:
//       00:03:00

Dim value As String = "3"
Dim interval As TimeSpan
If TimeSpan.TryParseExact(value, "%m", Nothing, interval) Then
    Console.WriteLine(interval.ToString("c"))
Else
    Console.WriteLine("Unable to convert '{0}' to a time interval",
                      value)
End If
' The example displays the following output:
'       00:03:00                              

L’exemple suivant illustre l’utilisation du spécificateur de format personnalisé « m ».

TimeSpan ts1 = new TimeSpan(0, 6, 32);
Console.WriteLine($"{ts1:m\\:ss} minutes");

TimeSpan ts2 = new TimeSpan(3, 4, 3, 17);
Console.WriteLine($"Elapsed time: {ts2:m\\:ss}");
// The example displays the following output:
//       6:32 minutes
//       Elapsed time: 18:44

Dim ts1 As New TimeSpan(0, 6, 32)
Console.WriteLine("{0:m\:ss} minutes", ts1)

Dim ts2 As New TimeSpan(0, 18, 44)
Console.WriteLine("Elapsed time: {0:m\:ss}", ts2)
' The example displays the following output:
'       6:32 minutes
'       Elapsed time: 18:44

Retour au tableau

Spécificateur de format personnalisé "mm"

Le spécificateur de format personnalisé « mm » génère la valeur de la propriété TimeSpan.Minutes, qui représente le nombre de minutes entières dans l’intervalle de temps qui n’est pas inclus dans le composant heures ou jours. Pour les valeurs comprises entre 0 et 9, la chaîne de sortie inclut un zéro non significatif.

En règle générale, dans une opération d’analyse, une chaîne d’entrée qui inclut un seul nombre est interprétée comme le nombre de jours. Vous pouvez utiliser le spécificateur de format personnalisé « mm » à la place pour interpréter la chaîne numérique comme le nombre de minutes. L'exemple suivant illustre cette situation.

string value = "07";
TimeSpan interval;
if (TimeSpan.TryParseExact(value, "mm", null, out interval))
   Console.WriteLine(interval.ToString("c"));
else
   Console.WriteLine($"Unable to convert '{value}' to a time interval");
// The example displays the following output:
//       00:07:00

Dim value As String = "05"
Dim interval As TimeSpan
If TimeSpan.TryParseExact(value, "mm", Nothing, interval) Then
    Console.WriteLine(interval.ToString("c"))
Else
    Console.WriteLine("Unable to convert '{0}' to a time interval",
                      value)
End If
' The example displays the following output:
'       00:05:00           

L’exemple suivant illustre l’utilisation du spécificateur de format personnalisé « mm ».

TimeSpan departTime = new TimeSpan(11, 12, 00);
TimeSpan arriveTime = new TimeSpan(16, 28, 00);
Console.WriteLine($"Travel time: {arriveTime - departTime:hh\\:mm}");
// The example displays the following output:
//       Travel time: 05:16

Dim departTime As New TimeSpan(11, 12, 00)
Dim arriveTime As New TimeSpan(16, 28, 00)
Console.WriteLine("Travel time: {0:hh\:mm}",
                  arriveTime - departTime)
' The example displays the following output:
'       Travel time: 05:16      

Retour au tableau

Spécificateur de format personnalisé "s"

Le spécificateur de format personnalisé « s » génère la valeur de la propriété TimeSpan.Seconds, qui représente le nombre de secondes entières dans l’intervalle de temps qui n’est pas inclus dans le composant heures, jours ou minutes. Elle retourne une valeur de chaîne à un chiffre si la valeur de la propriété TimeSpan.Seconds est comprise entre 0 et 9, et retourne une valeur de chaîne à deux chiffres si la valeur de la propriété TimeSpan.Seconds est comprise entre 10 et 59.

Si le spécificateur de format personnalisé « s » est utilisé seul, spécifiez «%s» afin qu’il ne soit pas mal interprété comme une chaîne de format standard. L'exemple suivant illustre cette situation.

TimeSpan ts = TimeSpan.FromSeconds(12.465);
Console.WriteLine(ts.ToString("%s"));
// The example displays the following output:
//       12

Dim ts As TimeSpan = TimeSpan.FromSeconds(12.465)
Console.WriteLine(ts.ToString("%s"))
' The example displays the following output:
'       12

En règle générale, dans une opération d’analyse, une chaîne d’entrée qui inclut un seul nombre est interprétée comme le nombre de jours. Vous pouvez utiliser le spécificateur de format personnalisé «%s» pour interpréter la chaîne numérique comme le nombre de secondes. L'exemple suivant illustre cette situation.

string value = "9";
TimeSpan interval;
if (TimeSpan.TryParseExact(value, "%s", null, out interval))
   Console.WriteLine(interval.ToString("c"));
else
   Console.WriteLine($"Unable to convert '{value}' to a time interval");
// The example displays the following output:
//       00:00:09

Dim value As String = "9"
Dim interval As TimeSpan
If TimeSpan.TryParseExact(value, "%s", Nothing, interval) Then
    Console.WriteLine(interval.ToString("c"))
Else
    Console.WriteLine("Unable to convert '{0}' to a time interval",
                      value)
End If
' The example displays the following output:
'       00:00:09

L’exemple suivant illustre l’utilisation du spécificateur de format personnalisé « s ».

TimeSpan startTime = new TimeSpan(0, 12, 30, 15, 0);
TimeSpan endTime = new TimeSpan(0, 12, 30, 21, 3);
Console.WriteLine(@"Elapsed Time: {0:s\:fff} seconds",
                  endTime - startTime);
// The example displays the following output:
//       Elapsed Time: 6:003 seconds

Dim startTime As New TimeSpan(0, 12, 30, 15, 0)
Dim endTime As New TimeSpan(0, 12, 30, 21, 3)
Console.WriteLine("Elapsed Time: {0:s\:fff} seconds",
                  endTime - startTime)
' The example displays the following output:
'       Elapsed Time: 6:003 seconds      

Retour au tableau

Spécificateur de format personnalisé "ss"

Le spécificateur de format personnalisé « ss » génère la valeur de la propriété TimeSpan.Seconds, qui représente le nombre de secondes entières dans l’intervalle de temps qui n’est pas inclus dans le composant heures, jours ou minutes. Pour les valeurs comprises entre 0 et 9, la chaîne de sortie inclut un zéro non significatif.

En règle générale, dans une opération d’analyse, une chaîne d’entrée qui inclut un seul nombre est interprétée comme le nombre de jours. Vous pouvez utiliser le spécificateur de format personnalisé « ss » à la place pour interpréter la chaîne numérique comme le nombre de secondes. L'exemple suivant illustre cette situation.

string[] values = { "49", "9", "06" };
TimeSpan interval;
foreach (string value in values)
{
   if (TimeSpan.TryParseExact(value, "ss", null, out interval))
      Console.WriteLine(interval.ToString("c"));
   else
      Console.WriteLine($"Unable to convert '{value}' to a time interval");
}
// The example displays the following output:
//       00:00:49
//       Unable to convert '9' to a time interval
//       00:00:06

Dim values() As String = {"49", "9", "06"}
Dim interval As TimeSpan
For Each value As String In values
    If TimeSpan.TryParseExact(value, "ss", Nothing, interval) Then
        Console.WriteLine(interval.ToString("c"))
    Else
        Console.WriteLine("Unable to convert '{0}' to a time interval",
                          value)
    End If
Next
' The example displays the following output:
'       00:00:49
'       Unable to convert '9' to a time interval
'       00:00:06

L’exemple suivant illustre l’utilisation du spécificateur de format personnalisé « ss ».

TimeSpan interval1 = TimeSpan.FromSeconds(12.60);
Console.WriteLine(interval1.ToString(@"ss\.fff"));

TimeSpan interval2 = TimeSpan.FromSeconds(6.485);
Console.WriteLine(interval2.ToString(@"ss\.fff"));
// The example displays the following output:
//       12.600
//       06.485

Dim interval1 As TimeSpan = TimeSpan.FromSeconds(12.60)
Console.WriteLine(interval1.ToString("ss\.fff"))
Dim interval2 As TimeSpan = TimeSpan.FromSeconds(6.485)
Console.WriteLine(interval2.ToString("ss\.fff"))
' The example displays the following output:
'       12.600
'       06.485

Retour au tableau

Spécificateur de format personnalisé "f"

Le spécificateur de format personnalisé « f » génère les dixièmes d’une seconde dans un intervalle de temps. Dans une opération de mise en forme, tous les chiffres fractionnaires restants sont tronqués. Dans une opération d’analyse qui appelle la méthode TimeSpan.ParseExact ou TimeSpan.TryParseExact, la chaîne d’entrée doit contenir exactement un chiffre fractionnaire.

Si le spécificateur de format personnalisé « f » est utilisé seul, spécifiez «%f» afin qu’il ne soit pas mal interprété comme une chaîne de format standard.

L’exemple suivant utilise le spécificateur de format personnalisé « f » pour afficher les dixièmes d’une seconde dans une valeur TimeSpan. « f » est utilisé en premier comme seul spécificateur de format, puis combiné avec le spécificateur « s » dans une chaîne de format personnalisée.

TimeSpan ts = new TimeSpan(1003498765432);
string fmt;
Console.WriteLine(ts.ToString("c"));
Console.WriteLine();

for (int ctr = 1; ctr <= 7; ctr++) {
   fmt = new string('f', ctr);
   if (fmt.Length == 1) fmt = "%" + fmt;
   Console.WriteLine($"{fmt,10}: {ts.ToString(fmt)}");
}
Console.WriteLine();

for (int ctr = 1; ctr <= 7; ctr++) {
   fmt = $"s\\.{new string('f', ctr)}";
   Console.WriteLine($"{fmt,10}: {ts.ToString(fmt)}");
}
// The example displays the following output:
//               %f: 8
//               ff: 87
//              fff: 876
//             ffff: 8765
//            fffff: 87654
//           ffffff: 876543
//          fffffff: 8765432
//
//              s\.f: 29.8
//             s\.ff: 29.87
//            s\.fff: 29.876
//           s\.ffff: 29.8765
//          s\.fffff: 29.87654
//         s\.ffffff: 29.876543
//        s\.fffffff: 29.8765432

Dim ts As New TimeSpan(1003498765432)
Dim fmt As String
Console.WriteLine(ts.ToString("c"))
Console.WriteLine()

For ctr = 1 To 7
    fmt = New String("f"c, ctr)
    If fmt.Length = 1 Then fmt = "%" + fmt
    Console.WriteLine("{0,10}: {1:" + fmt + "}", fmt, ts)
Next
Console.WriteLine()

For ctr = 1 To 7
    fmt = New String("f"c, ctr)
    Console.WriteLine("{0,10}: {1:s\." + fmt + "}", "s\." + fmt, ts)
Next
' The example displays the following output:
'            %f: 8
'            ff: 87
'           fff: 876
'          ffff: 8765
'         fffff: 87654
'        ffffff: 876543
'       fffffff: 8765432
'    
'           s\.f: 29.8
'          s\.ff: 29.87
'         s\.fff: 29.876
'        s\.ffff: 29.8765
'       s\.fffff: 29.87654
'      s\.ffffff: 29.876543
'     s\.fffffff: 29.8765432

Retour au tableau

Spécificateur de format personnalisé "ff"

Le spécificateur de format personnalisé « ff » génère les centièmes d’une seconde dans un intervalle de temps. Dans une opération de mise en forme, tous les chiffres fractionnaires restants sont tronqués. Dans une opération d’analyse qui appelle la méthode TimeSpan.ParseExact ou TimeSpan.TryParseExact, la chaîne d’entrée doit contenir exactement deux chiffres fractionnaires.

L’exemple suivant utilise le spécificateur de format personnalisé « ff » pour afficher les centièmes d’une seconde dans une valeur TimeSpan. « ff » est utilisé en premier comme seul spécificateur de format, puis combiné avec le spécificateur « s » dans une chaîne de format personnalisée.

TimeSpan ts = new TimeSpan(1003498765432);
string fmt;
Console.WriteLine(ts.ToString("c"));
Console.WriteLine();

for (int ctr = 1; ctr <= 7; ctr++) {
   fmt = new string('f', ctr);
   if (fmt.Length == 1) fmt = "%" + fmt;
   Console.WriteLine($"{fmt,10}: {ts.ToString(fmt)}");
}
Console.WriteLine();

for (int ctr = 1; ctr <= 7; ctr++) {
   fmt = $"s\\.{new string('f', ctr)}";
   Console.WriteLine($"{fmt,10}: {ts.ToString(fmt)}");
}
// The example displays the following output:
//               %f: 8
//               ff: 87
//              fff: 876
//             ffff: 8765
//            fffff: 87654
//           ffffff: 876543
//          fffffff: 8765432
//
//              s\.f: 29.8
//             s\.ff: 29.87
//            s\.fff: 29.876
//           s\.ffff: 29.8765
//          s\.fffff: 29.87654
//         s\.ffffff: 29.876543
//        s\.fffffff: 29.8765432

Dim ts As New TimeSpan(1003498765432)
Dim fmt As String
Console.WriteLine(ts.ToString("c"))
Console.WriteLine()

For ctr = 1 To 7
    fmt = New String("f"c, ctr)
    If fmt.Length = 1 Then fmt = "%" + fmt
    Console.WriteLine("{0,10}: {1:" + fmt + "}", fmt, ts)
Next
Console.WriteLine()

For ctr = 1 To 7
    fmt = New String("f"c, ctr)
    Console.WriteLine("{0,10}: {1:s\." + fmt + "}", "s\." + fmt, ts)
Next
' The example displays the following output:
'            %f: 8
'            ff: 87
'           fff: 876
'          ffff: 8765
'         fffff: 87654
'        ffffff: 876543
'       fffffff: 8765432
'    
'           s\.f: 29.8
'          s\.ff: 29.87
'         s\.fff: 29.876
'        s\.ffff: 29.8765
'       s\.fffff: 29.87654
'      s\.ffffff: 29.876543
'     s\.fffffff: 29.8765432

Retour au tableau

Spécificateur de format personnalisé "fff"

Le spécificateur de format personnalisé « fff » (avec trois caractères « f ») génère les millisecondes dans un intervalle de temps. Dans une opération de mise en forme, tous les chiffres fractionnaires restants sont tronqués. Dans une opération d’analyse qui appelle la méthode TimeSpan.ParseExact ou TimeSpan.TryParseExact, la chaîne d’entrée doit contenir exactement trois chiffres fractionnaires.

L’exemple suivant utilise le spécificateur de format personnalisé « fff » pour afficher les millisecondes dans une valeur TimeSpan. « fff » est utilisé en premier comme seul spécificateur de format, puis combiné avec le spécificateur « s » dans une chaîne de format personnalisée.

TimeSpan ts = new TimeSpan(1003498765432);
string fmt;
Console.WriteLine(ts.ToString("c"));
Console.WriteLine();

for (int ctr = 1; ctr <= 7; ctr++) {
   fmt = new string('f', ctr);
   if (fmt.Length == 1) fmt = "%" + fmt;
   Console.WriteLine($"{fmt,10}: {ts.ToString(fmt)}");
}
Console.WriteLine();

for (int ctr = 1; ctr <= 7; ctr++) {
   fmt = $"s\\.{new string('f', ctr)}";
   Console.WriteLine($"{fmt,10}: {ts.ToString(fmt)}");
}
// The example displays the following output:
//               %f: 8
//               ff: 87
//              fff: 876
//             ffff: 8765
//            fffff: 87654
//           ffffff: 876543
//          fffffff: 8765432
//
//              s\.f: 29.8
//             s\.ff: 29.87
//            s\.fff: 29.876
//           s\.ffff: 29.8765
//          s\.fffff: 29.87654
//         s\.ffffff: 29.876543
//        s\.fffffff: 29.8765432

Dim ts As New TimeSpan(1003498765432)
Dim fmt As String
Console.WriteLine(ts.ToString("c"))
Console.WriteLine()

For ctr = 1 To 7
    fmt = New String("f"c, ctr)
    If fmt.Length = 1 Then fmt = "%" + fmt
    Console.WriteLine("{0,10}: {1:" + fmt + "}", fmt, ts)
Next
Console.WriteLine()

For ctr = 1 To 7
    fmt = New String("f"c, ctr)
    Console.WriteLine("{0,10}: {1:s\." + fmt + "}", "s\." + fmt, ts)
Next
' The example displays the following output:
'            %f: 8
'            ff: 87
'           fff: 876
'          ffff: 8765
'         fffff: 87654
'        ffffff: 876543
'       fffffff: 8765432
'    
'           s\.f: 29.8
'          s\.ff: 29.87
'         s\.fff: 29.876
'        s\.ffff: 29.8765
'       s\.fffff: 29.87654
'      s\.ffffff: 29.876543
'     s\.fffffff: 29.8765432

Retour au tableau

Spécificateur de format personnalisé "ffff"

Le spécificateur de format personnalisé « ffff » (avec quatre caractères « f ») génère les dix millièmes d’une seconde dans un intervalle de temps. Dans une opération de mise en forme, tous les chiffres fractionnaires restants sont tronqués. Dans une opération d’analyse qui appelle la méthode TimeSpan.ParseExact ou TimeSpan.TryParseExact, la chaîne d’entrée doit contenir exactement quatre chiffres fractionnaires.

L’exemple suivant utilise le spécificateur de format personnalisé « ffff » pour afficher les dix millièmes d’une seconde dans une valeur TimeSpan. « ffff » est utilisé en premier comme spécificateur de format, puis combiné avec le spécificateur « s » dans une chaîne de format personnalisée.

TimeSpan ts = new TimeSpan(1003498765432);
string fmt;
Console.WriteLine(ts.ToString("c"));
Console.WriteLine();

for (int ctr = 1; ctr <= 7; ctr++) {
   fmt = new string('f', ctr);
   if (fmt.Length == 1) fmt = "%" + fmt;
   Console.WriteLine($"{fmt,10}: {ts.ToString(fmt)}");
}
Console.WriteLine();

for (int ctr = 1; ctr <= 7; ctr++) {
   fmt = $"s\\.{new string('f', ctr)}";
   Console.WriteLine($"{fmt,10}: {ts.ToString(fmt)}");
}
// The example displays the following output:
//               %f: 8
//               ff: 87
//              fff: 876
//             ffff: 8765
//            fffff: 87654
//           ffffff: 876543
//          fffffff: 8765432
//
//              s\.f: 29.8
//             s\.ff: 29.87
//            s\.fff: 29.876
//           s\.ffff: 29.8765
//          s\.fffff: 29.87654
//         s\.ffffff: 29.876543
//        s\.fffffff: 29.8765432

Dim ts As New TimeSpan(1003498765432)
Dim fmt As String
Console.WriteLine(ts.ToString("c"))
Console.WriteLine()

For ctr = 1 To 7
    fmt = New String("f"c, ctr)
    If fmt.Length = 1 Then fmt = "%" + fmt
    Console.WriteLine("{0,10}: {1:" + fmt + "}", fmt, ts)
Next
Console.WriteLine()

For ctr = 1 To 7
    fmt = New String("f"c, ctr)
    Console.WriteLine("{0,10}: {1:s\." + fmt + "}", "s\." + fmt, ts)
Next
' The example displays the following output:
'            %f: 8
'            ff: 87
'           fff: 876
'          ffff: 8765
'         fffff: 87654
'        ffffff: 876543
'       fffffff: 8765432
'    
'           s\.f: 29.8
'          s\.ff: 29.87
'         s\.fff: 29.876
'        s\.ffff: 29.8765
'       s\.fffff: 29.87654
'      s\.ffffff: 29.876543
'     s\.fffffff: 29.8765432

Retour au tableau

Spécificateur de format personnalisé "fffff"

Le spécificateur de format personnalisé « fffff » (avec cinq caractères « f ») génère les cent milleièmes d’une seconde dans un intervalle de temps. Dans une opération de mise en forme, tous les chiffres fractionnaires restants sont tronqués. Dans une opération d’analyse qui appelle la méthode TimeSpan.ParseExact ou TimeSpan.TryParseExact, la chaîne d’entrée doit contenir exactement cinq chiffres fractionnaires.

L’exemple suivant utilise le spécificateur de format personnalisé « fffff » pour afficher les cent millièmes d’une seconde dans une valeur TimeSpan. « fffff » est utilisé en premier comme seul spécificateur de format, puis combiné avec le spécificateur « s » dans une chaîne de format personnalisée.

TimeSpan ts = new TimeSpan(1003498765432);
string fmt;
Console.WriteLine(ts.ToString("c"));
Console.WriteLine();

for (int ctr = 1; ctr <= 7; ctr++) {
   fmt = new string('f', ctr);
   if (fmt.Length == 1) fmt = "%" + fmt;
   Console.WriteLine($"{fmt,10}: {ts.ToString(fmt)}");
}
Console.WriteLine();

for (int ctr = 1; ctr <= 7; ctr++) {
   fmt = $"s\\.{new string('f', ctr)}";
   Console.WriteLine($"{fmt,10}: {ts.ToString(fmt)}");
}
// The example displays the following output:
//               %f: 8
//               ff: 87
//              fff: 876
//             ffff: 8765
//            fffff: 87654
//           ffffff: 876543
//          fffffff: 8765432
//
//              s\.f: 29.8
//             s\.ff: 29.87
//            s\.fff: 29.876
//           s\.ffff: 29.8765
//          s\.fffff: 29.87654
//         s\.ffffff: 29.876543
//        s\.fffffff: 29.8765432

Dim ts As New TimeSpan(1003498765432)
Dim fmt As String
Console.WriteLine(ts.ToString("c"))
Console.WriteLine()

For ctr = 1 To 7
    fmt = New String("f"c, ctr)
    If fmt.Length = 1 Then fmt = "%" + fmt
    Console.WriteLine("{0,10}: {1:" + fmt + "}", fmt, ts)
Next
Console.WriteLine()

For ctr = 1 To 7
    fmt = New String("f"c, ctr)
    Console.WriteLine("{0,10}: {1:s\." + fmt + "}", "s\." + fmt, ts)
Next
' The example displays the following output:
'            %f: 8
'            ff: 87
'           fff: 876
'          ffff: 8765
'         fffff: 87654
'        ffffff: 876543
'       fffffff: 8765432
'    
'           s\.f: 29.8
'          s\.ff: 29.87
'         s\.fff: 29.876
'        s\.ffff: 29.8765
'       s\.fffff: 29.87654
'      s\.ffffff: 29.876543
'     s\.fffffff: 29.8765432

Retour au tableau

Spécificateur de format personnalisé "ffffff"

Le spécificateur de format personnalisé « ffffff » (avec six caractères « f ») génère les millionièmes d’une seconde dans un intervalle de temps. Dans une opération de mise en forme, tous les chiffres fractionnaires restants sont tronqués. Dans une opération d’analyse qui appelle la méthode TimeSpan.ParseExact ou TimeSpan.TryParseExact, la chaîne d’entrée doit contenir exactement six chiffres fractionnels.

L’exemple suivant utilise le spécificateur de format personnalisé « ffffff » pour afficher les millionièmes d’une seconde dans une valeur TimeSpan. Il est utilisé en premier comme spécificateur de format unique, puis combiné avec le spécificateur « s » dans une chaîne de format personnalisée.

TimeSpan ts = new TimeSpan(1003498765432);
string fmt;
Console.WriteLine(ts.ToString("c"));
Console.WriteLine();

for (int ctr = 1; ctr <= 7; ctr++) {
   fmt = new string('f', ctr);
   if (fmt.Length == 1) fmt = "%" + fmt;
   Console.WriteLine($"{fmt,10}: {ts.ToString(fmt)}");
}
Console.WriteLine();

for (int ctr = 1; ctr <= 7; ctr++) {
   fmt = $"s\\.{new string('f', ctr)}";
   Console.WriteLine($"{fmt,10}: {ts.ToString(fmt)}");
}
// The example displays the following output:
//               %f: 8
//               ff: 87
//              fff: 876
//             ffff: 8765
//            fffff: 87654
//           ffffff: 876543
//          fffffff: 8765432
//
//              s\.f: 29.8
//             s\.ff: 29.87
//            s\.fff: 29.876
//           s\.ffff: 29.8765
//          s\.fffff: 29.87654
//         s\.ffffff: 29.876543
//        s\.fffffff: 29.8765432

Dim ts As New TimeSpan(1003498765432)
Dim fmt As String
Console.WriteLine(ts.ToString("c"))
Console.WriteLine()

For ctr = 1 To 7
    fmt = New String("f"c, ctr)
    If fmt.Length = 1 Then fmt = "%" + fmt
    Console.WriteLine("{0,10}: {1:" + fmt + "}", fmt, ts)
Next
Console.WriteLine()

For ctr = 1 To 7
    fmt = New String("f"c, ctr)
    Console.WriteLine("{0,10}: {1:s\." + fmt + "}", "s\." + fmt, ts)
Next
' The example displays the following output:
'            %f: 8
'            ff: 87
'           fff: 876
'          ffff: 8765
'         fffff: 87654
'        ffffff: 876543
'       fffffff: 8765432
'    
'           s\.f: 29.8
'          s\.ff: 29.87
'         s\.fff: 29.876
'        s\.ffff: 29.8765
'       s\.fffff: 29.87654
'      s\.ffffff: 29.876543
'     s\.fffffff: 29.8765432

Retour au tableau

Spécificateur de format personnalisé "fffffff"

Le spécificateur de format personnalisé « fffffff » (avec sept caractères « f ») génère les dix millionièmes d’une seconde (ou le nombre fractionnaire de graduations) dans un intervalle de temps. Dans une opération d’analyse qui appelle la méthode TimeSpan.ParseExact ou TimeSpan.TryParseExact, la chaîne d’entrée doit contenir exactement sept chiffres fractionnaires.

L’exemple suivant utilise le spécificateur de format personnalisé « fffffff » pour afficher le nombre fractionnaire de graduations dans une valeur TimeSpan. Il est utilisé en premier comme spécificateur de format unique, puis combiné avec le spécificateur « s » dans une chaîne de format personnalisée.

TimeSpan ts = new TimeSpan(1003498765432);
string fmt;
Console.WriteLine(ts.ToString("c"));
Console.WriteLine();

for (int ctr = 1; ctr <= 7; ctr++) {
   fmt = new string('f', ctr);
   if (fmt.Length == 1) fmt = "%" + fmt;
   Console.WriteLine($"{fmt,10}: {ts.ToString(fmt)}");
}
Console.WriteLine();

for (int ctr = 1; ctr <= 7; ctr++) {
   fmt = $"s\\.{new string('f', ctr)}";
   Console.WriteLine($"{fmt,10}: {ts.ToString(fmt)}");
}
// The example displays the following output:
//               %f: 8
//               ff: 87
//              fff: 876
//             ffff: 8765
//            fffff: 87654
//           ffffff: 876543
//          fffffff: 8765432
//
//              s\.f: 29.8
//             s\.ff: 29.87
//            s\.fff: 29.876
//           s\.ffff: 29.8765
//          s\.fffff: 29.87654
//         s\.ffffff: 29.876543
//        s\.fffffff: 29.8765432

Dim ts As New TimeSpan(1003498765432)
Dim fmt As String
Console.WriteLine(ts.ToString("c"))
Console.WriteLine()

For ctr = 1 To 7
    fmt = New String("f"c, ctr)
    If fmt.Length = 1 Then fmt = "%" + fmt
    Console.WriteLine("{0,10}: {1:" + fmt + "}", fmt, ts)
Next
Console.WriteLine()

For ctr = 1 To 7
    fmt = New String("f"c, ctr)
    Console.WriteLine("{0,10}: {1:s\." + fmt + "}", "s\." + fmt, ts)
Next
' The example displays the following output:
'            %f: 8
'            ff: 87
'           fff: 876
'          ffff: 8765
'         fffff: 87654
'        ffffff: 876543
'       fffffff: 8765432
'    
'           s\.f: 29.8
'          s\.ff: 29.87
'         s\.fff: 29.876
'        s\.ffff: 29.8765
'       s\.fffff: 29.87654
'      s\.ffffff: 29.876543
'     s\.fffffff: 29.8765432

Retour au tableau

Spécificateur de format personnalisé "F"

Le spécificateur de format personnalisé « F » génère les dixièmes d’une seconde dans un intervalle de temps. Dans une opération de mise en forme, tous les chiffres fractionnaires restants sont tronqués. Si la valeur des dixièmes d’intervalle de temps d’une seconde est égale à zéro, elle n’est pas incluse dans la chaîne de résultat. Dans une opération d’analyse qui appelle la méthode TimeSpan.ParseExact ou TimeSpan.TryParseExact, la présence des dixièmes d’un deuxième chiffre est facultative.

Si le spécificateur de format personnalisé « F » est utilisé seul, spécifiez «%F» afin qu’il ne soit pas mal interprété comme une chaîne de format standard.

L’exemple suivant utilise le spécificateur de format personnalisé « F » pour afficher les dixièmes d’une seconde dans une valeur TimeSpan. Il utilise également ce spécificateur de format personnalisé dans une opération d’analyse.

Console.WriteLine("Formatting:");
TimeSpan ts1 = TimeSpan.Parse("0:0:3.669");
Console.WriteLine($"{ts1} ('%F') --> {ts1:%F}");

TimeSpan ts2 = TimeSpan.Parse("0:0:3.091");
Console.WriteLine($"{ts2} ('ss\\.F') --> {ts2:ss\\.F}");
Console.WriteLine();

Console.WriteLine("Parsing:");
string[] inputs = { "0:0:03.", "0:0:03.1", "0:0:03.12" };
string fmt = @"h\:m\:ss\.F";
TimeSpan ts3;

foreach (string input in inputs) {
   if (TimeSpan.TryParseExact(input, fmt, null, out ts3))
      Console.WriteLine($"{input} ('{fmt}') --> {ts3}");
   else
      Console.WriteLine($"Cannot parse {input} with '{fmt}'.");
}
// The example displays the following output:
//       Formatting:
//       00:00:03.6690000 ('%F') --> 6
//       00:00:03.0910000 ('ss\.F') --> 03.
//
//       Parsing:
//       0:0:03. ('h\:m\:ss\.F') --> 00:00:03
//       0:0:03.1 ('h\:m\:ss\.F') --> 00:00:03.1000000
//       Cannot parse 0:0:03.12 with 'h\:m\:ss\.F'.

Console.WriteLine("Formatting:")
Dim ts1 As TimeSpan = TimeSpan.Parse("0:0:3.669")
Console.WriteLine("{0} ('%F') --> {0:%F}", ts1)

Dim ts2 As TimeSpan = TimeSpan.Parse("0:0:3.091")
Console.WriteLine("{0} ('ss\.F') --> {0:ss\.F}", ts2)
Console.WriteLine()

Console.WriteLine("Parsing:")
Dim inputs() As String = {"0:0:03.", "0:0:03.1", "0:0:03.12"}
Dim fmt As String = "h\:m\:ss\.F"
Dim ts3 As TimeSpan

For Each input As String In inputs
    If TimeSpan.TryParseExact(input, fmt, Nothing, ts3)
        Console.WriteLine("{0} ('{1}') --> {2}", input, fmt, ts3)
    Else
        Console.WriteLine("Cannot parse {0} with '{1}'.",
                          input, fmt)
    End If
Next
' The example displays the following output:
'       Formatting:
'       00:00:03.6690000 ('%F') --> 6
'       00:00:03.0910000 ('ss\.F') --> 03.
'       
'       Parsing:
'       0:0:03. ('h\:m\:ss\.F') --> 00:00:03
'       0:0:03.1 ('h\:m\:ss\.F') --> 00:00:03.1000000
'       Cannot parse 0:0:03.12 with 'h\:m\:ss\.F'.      

Retour au tableau

Spécificateur de format personnalisé "FF"

Le spécificateur de format personnalisé « FF » génère les centièmes d’une seconde dans un intervalle de temps. Dans une opération de mise en forme, tous les chiffres fractionnaires restants sont tronqués. S’il existe des zéros fractionnaires de fin, ils ne sont pas inclus dans la chaîne de résultat. Dans une opération d’analyse qui appelle la méthode TimeSpan.ParseExact ou TimeSpan.TryParseExact, la présence des dixièmes et des centièmes d’un deuxième chiffre est facultative.

L’exemple suivant utilise le spécificateur de format personnalisé « FF » pour afficher les centièmes d’une seconde dans une valeur TimeSpan. Il utilise également ce spécificateur de format personnalisé dans une opération d’analyse.

Console.WriteLine("Formatting:");
TimeSpan ts1 = TimeSpan.Parse("0:0:3.697");
Console.WriteLine($"{ts1} ('FF') --> {ts1:FF}");

TimeSpan ts2 = TimeSpan.Parse("0:0:3.809");
Console.WriteLine($"{ts2} ('ss\\.FF') --> {ts2:ss\\.FF}");
Console.WriteLine();

Console.WriteLine("Parsing:");
string[] inputs = { "0:0:03.", "0:0:03.1", "0:0:03.127" };
string fmt = @"h\:m\:ss\.FF";
TimeSpan ts3;

foreach (string input in inputs) {
   if (TimeSpan.TryParseExact(input, fmt, null, out ts3))
      Console.WriteLine($"{input} ('{fmt}') --> {ts3}");
   else
      Console.WriteLine($"Cannot parse {input} with '{fmt}'.");
}
// The example displays the following output:
//       Formatting:
//       00:00:03.6970000 ('FF') --> 69
//       00:00:03.8090000 ('ss\.FF') --> 03.8
//
//       Parsing:
//       0:0:03. ('h\:m\:ss\.FF') --> 00:00:03
//       0:0:03.1 ('h\:m\:ss\.FF') --> 00:00:03.1000000
//       Cannot parse 0:0:03.127 with 'h\:m\:ss\.FF'.

Console.WriteLine("Formatting:")
Dim ts1 As TimeSpan = TimeSpan.Parse("0:0:3.697")
Console.WriteLine("{0} ('FF') --> {0:FF}", ts1)

Dim ts2 As TimeSpan = TimeSpan.Parse("0:0:3.809")
Console.WriteLine("{0} ('ss\.FF') --> {0:ss\.FF}", ts2)
Console.WriteLine()

Console.WriteLine("Parsing:")
Dim inputs() As String = {"0:0:03.", "0:0:03.1", "0:0:03.127"}
Dim fmt As String = "h\:m\:ss\.FF"
Dim ts3 As TimeSpan

For Each input As String In inputs
    If TimeSpan.TryParseExact(input, fmt, Nothing, ts3)
        Console.WriteLine("{0} ('{1}') --> {2}", input, fmt, ts3)
    Else
        Console.WriteLine("Cannot parse {0} with '{1}'.",
                          input, fmt)
    End If
Next
' The example displays the following output:
'       Formatting:
'       00:00:03.6970000 ('FF') --> 69
'       00:00:03.8090000 ('ss\.FF') --> 03.8
'       
'       Parsing:
'       0:0:03. ('h\:m\:ss\.FF') --> 00:00:03
'       0:0:03.1 ('h\:m\:ss\.FF') --> 00:00:03.1000000
'       Cannot parse 0:0:03.127 with 'h\:m\:ss\.FF'.

Retour au tableau

Spécificateur de format personnalisé "FFF"

Le spécificateur de format personnalisé « FFF » (avec trois caractères « F ») génère les millisecondes dans un intervalle de temps. Dans une opération de mise en forme, tous les chiffres fractionnaires restants sont tronqués. S’il existe des zéros fractionnaires de fin, ils ne sont pas inclus dans la chaîne de résultat. Dans une opération d’analyse qui appelle la méthode TimeSpan.ParseExact ou TimeSpan.TryParseExact, la présence des dixièmes, des centièmes et des millièmes d’un deuxième chiffre est facultative.

L’exemple suivant utilise le spécificateur de format personnalisé « FFF » pour afficher les millièmes d’une seconde dans une valeur TimeSpan. Il utilise également ce spécificateur de format personnalisé dans une opération d’analyse.

Console.WriteLine("Formatting:");
TimeSpan ts1 = TimeSpan.Parse("0:0:3.6974");
Console.WriteLine($"{ts1} ('FFF') --> {ts1:FFF}");

TimeSpan ts2 = TimeSpan.Parse("0:0:3.8009");
Console.WriteLine($"{ts2} ('ss\\.FFF') --> {ts2:ss\\.FFF}");
Console.WriteLine();

Console.WriteLine("Parsing:");
string[] inputs = { "0:0:03.", "0:0:03.12", "0:0:03.1279" };
string fmt = @"h\:m\:ss\.FFF";
TimeSpan ts3;

foreach (string input in inputs) {
   if (TimeSpan.TryParseExact(input, fmt, null, out ts3))
      Console.WriteLine($"{input} ('{fmt}') --> {ts3}");
   else
      Console.WriteLine($"Cannot parse {input} with '{fmt}'.");
}
// The example displays the following output:
//       Formatting:
//       00:00:03.6974000 ('FFF') --> 697
//       00:00:03.8009000 ('ss\.FFF') --> 03.8
//
//       Parsing:
//       0:0:03. ('h\:m\:ss\.FFF') --> 00:00:03
//       0:0:03.12 ('h\:m\:ss\.FFF') --> 00:00:03.1200000
//       Cannot parse 0:0:03.1279 with 'h\:m\:ss\.FFF'.

Console.WriteLine("Formatting:")
Dim ts1 As TimeSpan = TimeSpan.Parse("0:0:3.6974")
Console.WriteLine("{0} ('FFF') --> {0:FFF}", ts1)

Dim ts2 As TimeSpan = TimeSpan.Parse("0:0:3.8009")
Console.WriteLine("{0} ('ss\.FFF') --> {0:ss\.FFF}", ts2)
Console.WriteLine()

Console.WriteLine("Parsing:")
Dim inputs() As String = {"0:0:03.", "0:0:03.12", "0:0:03.1279"}
Dim fmt As String = "h\:m\:ss\.FFF"
Dim ts3 As TimeSpan

For Each input As String In inputs
    If TimeSpan.TryParseExact(input, fmt, Nothing, ts3)
        Console.WriteLine("{0} ('{1}') --> {2}", input, fmt, ts3)
    Else
        Console.WriteLine("Cannot parse {0} with '{1}'.",
                          input, fmt)
    End If
Next
' The example displays the following output:
'       Formatting:
'       00:00:03.6974000 ('FFF') --> 697
'       00:00:03.8009000 ('ss\.FFF') --> 03.8
'       
'       Parsing:
'       0:0:03. ('h\:m\:ss\.FFF') --> 00:00:03
'       0:0:03.12 ('h\:m\:ss\.FFF') --> 00:00:03.1200000
'       Cannot parse 0:0:03.1279 with 'h\:m\:ss\.FFF'.

Retour au tableau

Spécificateur de format personnalisé "FFFF"

Le spécificateur de format personnalisé « FFFF » (avec quatre caractères « F ») génère les dix millièmes d’une seconde dans un intervalle de temps. Dans une opération de mise en forme, tous les chiffres fractionnaires restants sont tronqués. S’il existe des zéros fractionnaires de fin, ils ne sont pas inclus dans la chaîne de résultat. Dans une opération d’analyse qui appelle la méthode TimeSpan.ParseExact ou TimeSpan.TryParseExact, la présence des dixièmes, des centièmes, des millièmes et des dix millièmes d’un deuxième chiffre est facultative.

L’exemple suivant utilise le spécificateur de format personnalisé « FFFF » pour afficher les dix millièmes d’une seconde dans une valeur TimeSpan. Il utilise également le spécificateur de format personnalisé « FFFF » dans une opération d’analyse.

Console.WriteLine("Formatting:");
TimeSpan ts1 = TimeSpan.Parse("0:0:3.69749");
Console.WriteLine($"{ts1} ('FFFF') --> {ts1:FFFF}");

TimeSpan ts2 = TimeSpan.Parse("0:0:3.80009");
Console.WriteLine($"{ts2} ('ss\\.FFFF') --> {ts2:ss\\.FFFF}");
Console.WriteLine();

Console.WriteLine("Parsing:");
string[] inputs = { "0:0:03.", "0:0:03.12", "0:0:03.12795" };
string fmt = @"h\:m\:ss\.FFFF";
TimeSpan ts3;

foreach (string input in inputs) {
   if (TimeSpan.TryParseExact(input, fmt, null, out ts3))
      Console.WriteLine($"{input} ('{fmt}') --> {ts3}");
   else
      Console.WriteLine($"Cannot parse {input} with '{fmt}'.");
}
// The example displays the following output:
//       Formatting:
//       00:00:03.6974900 ('FFFF') --> 6974
//       00:00:03.8000900 ('ss\.FFFF') --> 03.8
//
//       Parsing:
//       0:0:03. ('h\:m\:ss\.FFFF') --> 00:00:03
//       0:0:03.12 ('h\:m\:ss\.FFFF') --> 00:00:03.1200000
//       Cannot parse 0:0:03.12795 with 'h\:m\:ss\.FFFF'.

Console.WriteLine("Formatting:")
Dim ts1 As TimeSpan = TimeSpan.Parse("0:0:3.69749")
Console.WriteLine("{0} ('FFFF') --> {0:FFFF}", ts1)

Dim ts2 As TimeSpan = TimeSpan.Parse("0:0:3.80009")
Console.WriteLine("{0} ('ss\.FFFF') --> {0:ss\.FFFF}", ts2)
Console.WriteLine()

Console.WriteLine("Parsing:")
Dim inputs() As String = {"0:0:03.", "0:0:03.12", "0:0:03.12795"}
Dim fmt As String = "h\:m\:ss\.FFFF"
Dim ts3 As TimeSpan

For Each input As String In inputs
    If TimeSpan.TryParseExact(input, fmt, Nothing, ts3)
        Console.WriteLine("{0} ('{1}') --> {2}", input, fmt, ts3)
    Else
        Console.WriteLine("Cannot parse {0} with '{1}'.",
                          input, fmt)
    End If
Next
' The example displays the following output:
'       Formatting:
'       00:00:03.6974900 ('FFFF') --> 6974
'       00:00:03.8000900 ('ss\.FFFF') --> 03.8
'       
'       Parsing:
'       0:0:03. ('h\:m\:ss\.FFFF') --> 00:00:03
'       0:0:03.12 ('h\:m\:ss\.FFFF') --> 00:00:03.1200000
'       Cannot parse 0:0:03.12795 with 'h\:m\:ss\.FFFF'.

Retour au tableau

Spécificateur de format personnalisé "FFFFF"

Le spécificateur de format personnalisé « FFFFF » (avec cinq caractères « F ») génère les cent milleièmes d’une seconde dans un intervalle de temps. Dans une opération de mise en forme, tous les chiffres fractionnaires restants sont tronqués. S’il existe des zéros fractionnaires de fin, ils ne sont pas inclus dans la chaîne de résultat. Dans une opération d’analyse qui appelle la méthode TimeSpan.ParseExact ou TimeSpan.TryParseExact, la présence des dixièmes, des centièmes, des millièmes, des dix millièmes et des cent milleièmes d’un deuxième chiffre est facultative.

L’exemple suivant utilise le spécificateur de format personnalisé « FFFFF » pour afficher les cent millièmes d’une seconde dans une valeur TimeSpan. Il utilise également le spécificateur de format personnalisé « FFFFF » dans une opération d’analyse.

Console.WriteLine("Formatting:");
TimeSpan ts1 = TimeSpan.Parse("0:0:3.697497");
Console.WriteLine($"{ts1} ('FFFFF') --> {ts1:FFFFF}");

TimeSpan ts2 = TimeSpan.Parse("0:0:3.800009");
Console.WriteLine($"{ts2} ('ss\\.FFFFF') --> {ts2:ss\\.FFFFF}");
Console.WriteLine();

Console.WriteLine("Parsing:");
string[] inputs = { "0:0:03.", "0:0:03.12", "0:0:03.127956" };
string fmt = @"h\:m\:ss\.FFFFF";
TimeSpan ts3;

foreach (string input in inputs) {
   if (TimeSpan.TryParseExact(input, fmt, null, out ts3))
      Console.WriteLine($"{input} ('{fmt}') --> {ts3}");
   else
      Console.WriteLine($"Cannot parse {input} with '{fmt}'.");
}
// The example displays the following output:
//       Formatting:
//       00:00:03.6974970 ('FFFFF') --> 69749
//       00:00:03.8000090 ('ss\.FFFFF') --> 03.8
//
//       Parsing:
//       0:0:03. ('h\:m\:ss\.FFFF') --> 00:00:03
//       0:0:03.12 ('h\:m\:ss\.FFFF') --> 00:00:03.1200000
//       Cannot parse 0:0:03.127956 with 'h\:m\:ss\.FFFF'.

Console.WriteLine("Formatting:")
Dim ts1 As TimeSpan = TimeSpan.Parse("0:0:3.697497")
Console.WriteLine("{0} ('FFFFF') --> {0:FFFFF}", ts1)

Dim ts2 As TimeSpan = TimeSpan.Parse("0:0:3.800009")
Console.WriteLine("{0} ('ss\.FFFFF') --> {0:ss\.FFFFF}", ts2)
Console.WriteLine()

Console.WriteLine("Parsing:")
Dim inputs() As String = {"0:0:03.", "0:0:03.12", "0:0:03.127956"}
Dim fmt As String = "h\:m\:ss\.FFFFF"
Dim ts3 As TimeSpan

For Each input As String In inputs
    If TimeSpan.TryParseExact(input, fmt, Nothing, ts3)
        Console.WriteLine("{0} ('{1}') --> {2}", input, fmt, ts3)
    Else
        Console.WriteLine("Cannot parse {0} with '{1}'.",
                          input, fmt)
    End If
Next
' The example displays the following output:
'       Formatting:
'       00:00:03.6974970 ('FFFFF') --> 69749
'       00:00:03.8000090 ('ss\.FFFFF') --> 03.8
'       
'       Parsing:
'       0:0:03. ('h\:m\:ss\.FFFF') --> 00:00:03
'       0:0:03.12 ('h\:m\:ss\.FFFF') --> 00:00:03.1200000
'       Cannot parse 0:0:03.127956 with 'h\:m\:ss\.FFFF'.

Retour au tableau

Spécificateur de format personnalisé "FFFFFF"

Le spécificateur de format personnalisé « FFFFFF » (avec six caractères « F ») génère les millionièmes d’une seconde dans un intervalle de temps. Dans une opération de mise en forme, tous les chiffres fractionnaires restants sont tronqués. S’il existe des zéros fractionnaires de fin, ils ne sont pas inclus dans la chaîne de résultat. Dans une opération d’analyse qui appelle la méthode TimeSpan.ParseExact ou TimeSpan.TryParseExact, la présence des dixièmes, des centièmes, des millièmes, des dix millièmes, des centièmes et des millionièmes d’un deuxième chiffre est facultative.

L’exemple suivant utilise le spécificateur de format personnalisé « FFFFFF » pour afficher les millionièmes d’une seconde dans une valeur TimeSpan. Il utilise également ce spécificateur de format personnalisé dans une opération d’analyse.

Console.WriteLine("Formatting:");
TimeSpan ts1 = TimeSpan.Parse("0:0:3.6974974");
Console.WriteLine($"{ts1} ('FFFFFF') --> {ts1:FFFFFF}");

TimeSpan ts2 = TimeSpan.Parse("0:0:3.8000009");
Console.WriteLine($"{ts2} ('ss\\.FFFFFF') --> {ts2:ss\\.FFFFFF}");
Console.WriteLine();

Console.WriteLine("Parsing:");
string[] inputs = { "0:0:03.", "0:0:03.12", "0:0:03.1279569" };
string fmt = @"h\:m\:ss\.FFFFFF";
TimeSpan ts3;

foreach (string input in inputs) {
   if (TimeSpan.TryParseExact(input, fmt, null, out ts3))
      Console.WriteLine($"{input} ('{fmt}') --> {ts3}");
   else
      Console.WriteLine($"Cannot parse {input} with '{fmt}'.");
}
// The example displays the following output:
//       Formatting:
//       00:00:03.6974974 ('FFFFFF') --> 697497
//       00:00:03.8000009 ('ss\.FFFFFF') --> 03.8
//
//       Parsing:
//       0:0:03. ('h\:m\:ss\.FFFFFF') --> 00:00:03
//       0:0:03.12 ('h\:m\:ss\.FFFFFF') --> 00:00:03.1200000
//       Cannot parse 0:0:03.1279569 with 'h\:m\:ss\.FFFFFF'.

Console.WriteLine("Formatting:")
Dim ts1 As TimeSpan = TimeSpan.Parse("0:0:3.6974974")
Console.WriteLine("{0} ('FFFFFF') --> {0:FFFFFF}", ts1)

Dim ts2 As TimeSpan = TimeSpan.Parse("0:0:3.8000009")
Console.WriteLine("{0} ('ss\.FFFFFF') --> {0:ss\.FFFFFF}", ts2)
Console.WriteLine()

Console.WriteLine("Parsing:")
Dim inputs() As String = {"0:0:03.", "0:0:03.12", "0:0:03.1279569"}
Dim fmt As String = "h\:m\:ss\.FFFFFF"
Dim ts3 As TimeSpan

For Each input As String In inputs
    If TimeSpan.TryParseExact(input, fmt, Nothing, ts3)
        Console.WriteLine("{0} ('{1}') --> {2}", input, fmt, ts3)
    Else
        Console.WriteLine("Cannot parse {0} with '{1}'.",
                          input, fmt)
    End If
Next
' The example displays the following output:
'       Formatting:
'       00:00:03.6974974 ('FFFFFF') --> 697497
'       00:00:03.8000009 ('ss\.FFFFFF') --> 03.8
'       
'       Parsing:
'       0:0:03. ('h\:m\:ss\.FFFFFF') --> 00:00:03
'       0:0:03.12 ('h\:m\:ss\.FFFFFF') --> 00:00:03.1200000
'       Cannot parse 0:0:03.1279569 with 'h\:m\:ss\.FFFFFF'.

Retour au tableau

Spécificateur de format personnalisé "FFFFFFF"

Le spécificateur de format personnalisé « FFFFFFF » (avec sept caractères « F ») génère les dix millionièmes d’une seconde (ou le nombre fractionnaire de graduations) dans un intervalle de temps. S’il existe des zéros fractionnaires de fin, ils ne sont pas inclus dans la chaîne de résultat. Dans une opération d’analyse qui appelle la méthode TimeSpan.ParseExact ou TimeSpan.TryParseExact, la présence des sept chiffres fractionnaires dans la chaîne d’entrée est facultative.

L’exemple suivant utilise le spécificateur de format personnalisé « FFFFFFF » pour afficher les parties fractionnaires d’une seconde dans une valeur TimeSpan. Il utilise également ce spécificateur de format personnalisé dans une opération d’analyse.

Console.WriteLine("Formatting:");
TimeSpan ts1 = TimeSpan.Parse("0:0:3.6974974");
Console.WriteLine($"{ts1} ('FFFFFFF') --> {ts1:FFFFFFF}");

TimeSpan ts2 = TimeSpan.Parse("0:0:3.9500000");
Console.WriteLine($"{ts2} ('ss\\.FFFFFFF') --> {ts2:ss\\.FFFFFFF}");
Console.WriteLine();

Console.WriteLine("Parsing:");
string[] inputs = { "0:0:03.", "0:0:03.12", "0:0:03.1279569" };
string fmt = @"h\:m\:ss\.FFFFFFF";
TimeSpan ts3;

foreach (string input in inputs) {
   if (TimeSpan.TryParseExact(input, fmt, null, out ts3))
      Console.WriteLine($"{input} ('{fmt}') --> {ts3}");
   else
      Console.WriteLine($"Cannot parse {input} with '{fmt}'.");
}
// The example displays the following output:
//    Formatting:
//    00:00:03.6974974 ('FFFFFFF') --> 6974974
//    00:00:03.9500000 ('ss\.FFFFFFF') --> 03.95
//
//    Parsing:
//    0:0:03. ('h\:m\:ss\.FFFFFFF') --> 00:00:03
//    0:0:03.12 ('h\:m\:ss\.FFFFFFF') --> 00:00:03.1200000
//    0:0:03.1279569 ('h\:m\:ss\.FFFFFFF') --> 00:00:03.1279569

Console.WriteLine("Formatting:")
Dim ts1 As TimeSpan = TimeSpan.Parse("0:0:3.6974974")
Console.WriteLine("{0} ('FFFFFFF') --> {0:FFFFFFF}", ts1)

Dim ts2 As TimeSpan = TimeSpan.Parse("0:0:3.9500000")
Console.WriteLine("{0} ('ss\.FFFFFFF') --> {0:ss\.FFFFFFF}", ts2)
Console.WriteLine()

Console.WriteLine("Parsing:")
Dim inputs() As String = {"0:0:03.", "0:0:03.12", "0:0:03.1279569"}
Dim fmt As String = "h\:m\:ss\.FFFFFFF"
Dim ts3 As TimeSpan

For Each input As String In inputs
    If TimeSpan.TryParseExact(input, fmt, Nothing, ts3)
        Console.WriteLine("{0} ('{1}') --> {2}", input, fmt, ts3)
    Else
        Console.WriteLine("Cannot parse {0} with '{1}'.",
                          input, fmt)
    End If
Next
' The example displays the following output:
'    Formatting:
'    00:00:03.6974974 ('FFFFFFF') --> 6974974
'    00:00:03.9500000 ('ss\.FFFFFFF') --> 03.95
'    
'    Parsing:
'    0:0:03. ('h\:m\:ss\.FFFFFFF') --> 00:00:03
'    0:0:03.12 ('h\:m\:ss\.FFFFFFF') --> 00:00:03.1200000
'    0:0:03.1279569 ('h\:m\:ss\.FFFFFFF') --> 00:00:03.1279569     

Retour au tableau

Autres caractères

Tout autre caractère non boucté dans une chaîne de format, y compris un caractère d’espace blanc, est interprété comme un spécificateur de format personnalisé. Dans la plupart des cas, la présence d’un autre caractère non boucté entraîne une FormatException.

Il existe deux façons d’inclure un caractère littéral dans une chaîne de format :

• Placez-la entre guillemets simples (délimiteur de chaîne littérale).

• Précèdez-le avec une barre oblique inverse (« \ »), qui est interprétée comme un caractère d’échappement. Cela signifie que, en C#, la chaîne de format doit être @-quoted, ou le caractère littéral doit être précédé d’une barre oblique inverse supplémentaire.

  Dans certains cas, vous devrez peut-être utiliser la logique conditionnelle pour inclure un littéral d’échappement dans une chaîne de format. L’exemple suivant utilise la logique conditionnelle pour inclure un symbole de signe pour les intervalles de temps négatifs.

  using System;
  
  public class Example
  {
     public static void Main()
     {
        TimeSpan result = new DateTime(2010, 01, 01) - DateTime.Now;
        String fmt = (result < TimeSpan.Zero ?  "\\-" : "") + "dd\\.hh\\:mm";
  
        Console.WriteLine(result.ToString(fmt));
        Console.WriteLine($"Interval: {result.ToString(fmt)}");
     }
  }
  // The example displays output like the following:
  //       -5582.12:21
  //       Interval: -5582.12:21
  

  Module Example
      Public Sub Main()
          Dim result As TimeSpan = New DateTime(2010, 01, 01) - Date.Now
          Dim fmt As String = If(result < TimeSpan.Zero, "\-", "") + "dd\.hh\:mm"
  
          Console.WriteLine(result.ToString(fmt))
          Console.WriteLine("Interval: {0:" + fmt + "}", result)
      End Sub
  End Module
  ' The example displays output like the following:
  '       -1291.10:54
  '       Interval: -1291.10:54
  

.NET ne définit pas de grammaire pour les séparateurs dans les intervalles de temps. Cela signifie que les séparateurs entre les jours et les heures, les heures et les minutes, les minutes et les secondes, et les fractions d’une seconde doivent tous être traités comme des littéraux de caractères dans une chaîne de format.

L’exemple suivant utilise à la fois le caractère d’échappement et le guillemet unique pour définir une chaîne de format personnalisée qui inclut le mot « minutes » dans la chaîne de sortie.

TimeSpan interval = new TimeSpan(0, 32, 45);
// Escape literal characters in a format string.
string fmt = @"mm\:ss\ \m\i\n\u\t\e\s";
Console.WriteLine(interval.ToString(fmt));
// Delimit literal characters in a format string with the ' symbol.
fmt = "mm':'ss' minutes'";
Console.WriteLine(interval.ToString(fmt));
// The example displays the following output:
//       32:45 minutes
//       32:45 minutes

Dim interval As New TimeSpan(0, 32, 45)
' Escape literal characters in a format string.
Dim fmt As String = "mm\:ss\ \m\i\n\u\t\e\s"
Console.WriteLine(interval.ToString(fmt))
' Delimit literal characters in a format string with the ' symbol.
fmt = "mm':'ss' minutes'"
Console.WriteLine(interval.ToString(fmt))
' The example displays the following output: 
'       32:45 minutes      
'       32:45 minutes      

Retour au tableau

Voir aussi

• types de mise en forme
• chaînes de format timeSpan standard