Chaînes de format TimeSpan standard

  • Article
  • 10 minutes de lecture

Une chaîne de format TimeSpan standard utilise un spécificateur de format pour définir la représentation textuelle d'une valeur TimeSpan qui résulte d'une opération de mise en forme. Toute chaîne de format contenant plusieurs caractères alphabétiques, y compris un espace blanc, est interprétée comme une chaîne de format TimeSpan personnalisée. Pour plus d’informations, consultez chaînes de format TimeSpan personnalisées .

Les représentations sous forme de chaîne de valeurs TimeSpan sont produites par des appels aux surcharges de la méthode TimeSpan.ToString, ainsi que par les méthodes qui prennent en charge la mise en forme composite, telles que String.Format. Pour plus d’informations, consultez Mise en forme des types et Mise en forme composite. L'exemple suivant illustre l'utilisation de chaînes de format standard dans des 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 = "Time of Travel: " + duration.ToString("c");
      Console.WriteLine(output);

      Console.WriteLine("Time of Travel: {0:c}", duration);
   }
}
// The example displays the following output:
//       Time of Travel: 1.12:24:02
//       Time of Travel: 1.12:24:02

Module Example
    Public Sub Main()
        Dim duration As New TimeSpan(1, 12, 23, 62)
        Dim output As String = "Time of Travel: " + duration.ToString("c")
        Console.WriteLine(output)

        Console.WriteLine("Time of Travel: {0:c}", duration)
    End Sub
End Module
' The example displays the following output:
'       Time of Travel: 1.12:24:02
'       Time of Travel: 1.12:24:02

Les chaînes de format TimeSpan standard 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 = "1.03:14:56.1667";
      TimeSpan interval;
      try {
         interval = TimeSpan.ParseExact(value, "c", null);
         Console.WriteLine("Converted '{0}' to {1}", value, interval);
      }
      catch (FormatException) {
         Console.WriteLine("{0}: Bad Format", value);
      }
      catch (OverflowException) {
         Console.WriteLine("{0}: Out of Range", value);
      }

      if (TimeSpan.TryParseExact(value, "c", null, out interval))
         Console.WriteLine("Converted '{0}' to {1}", value, interval);
      else
         Console.WriteLine("Unable to convert {0} to a time interval.",
                           value);
   }
}
// The example displays the following output:
//       Converted '1.03:14:56.1667' to 1.03:14:56.1667000
//       Converted '1.03:14:56.1667' to 1.03:14:56.1667000

Module Example
    Public Sub Main()
        Dim value As String = "1.03:14:56.1667"
        Dim interval As TimeSpan
        Try
            interval = TimeSpan.ParseExact(value, "c", Nothing)
            Console.WriteLine("Converted '{0}' to {1}", value, interval)
        Catch e As FormatException
            Console.WriteLine("{0}: Bad Format", value)
        Catch e As OverflowException
            Console.WriteLine("{0}: Out of Range", value)
        End Try

        If TimeSpan.TryParseExact(value, "c", Nothing, interval) Then
            Console.WriteLine("Converted '{0}' to {1}", value, interval)
        Else
            Console.WriteLine("Unable to convert {0} to a time interval.",
                              value)
        End If
    End Sub
End Module
' The example displays the following output:
'       Converted '1.03:14:56.1667' to 1.03:14:56.1667000
'       Converted '1.03:14:56.1667' to 1.03:14:56.1667000

Le tableau suivant répertorie les spécificateurs de format d'intervalle de temps standard.

Spécificateur de format Nom Description Exemples
"c" Format constant (invariant) Ce spécificateur ne dépend pas de la culture. Son format est le suivant : [-][d'.']hh':'mm':'ss['.'fffffff].

(les chaînes de format "t" et "T" produisent les mêmes résultats)

Pour plus d’informations, consultez Spécificateur de format constant ("c").		 TimeSpan.Zero -> 00:00:00

New TimeSpan(0, 0, 30, 0) -> 00:30:00

New TimeSpan(3, 17, 25, 30, 500) -> 3.17:25:30.50000000
"g" Format court général Ce spécificateur retourne uniquement ce qui est nécessaire. Il dépend de la culture et prend la forme suivante : [-][d':']h':'mm':'ss[.FFFFFFF].

Pour plus d’informations, consultez Spécificateur de format court général ("g").		 New TimeSpan(1, 3, 16, 50, 500) -> 1:3:16:50.5 (en-US)

New TimeSpan(1, 3, 16, 50, 500) -> 1:3:16:50,5 (fr-FR)

New TimeSpan(1, 3, 16, 50, 599) -> 1:3:16:50.599 (en-US)

New TimeSpan(1, 3, 16, 50, 599) -> 1:3:16:50,599 (fr-FR)
"G" Format long général Ce spécificateur retourne toujours les jours et sept chiffres fractionnaires. Il dépend de la culture et prend la forme suivante : [-]d':'hh':'mm':'ss.fffffff.

Pour plus d’informations, consultez Spécificateur de format long général ("G").		 New TimeSpan(18, 30, 0) -> 0:18:30:00.0000000 (en-US)

New TimeSpan(18, 30, 0) -> 0:18:30:00,0000000 (fr-FR)

Spécificateur de format constant ("c")

Le spécificateur de format "c" retourne la représentation sous forme de chaîne d'une valeur TimeSpan au format suivant :

[-][d.]hh:mm:ss[.fffffff]

Les éléments entre crochets ([ et ]) sont facultatifs. Le point (.) et les deux-points (:) sont des symboles littéraux. Le tableau suivant décrit les éléments restants.

Élément Description
- Signe négatif facultatif, qui indique un intervalle de temps négatif.
d Nombre facultatif de jours, sans zéros non significatifs.
hh Nombre d'heures, allant de "00" à "23".
mm Nombre de minutes, allant de "00" à "59".
ss Nombre de secondes, allant de "0" à "59".
fffffffff Partie fractionnaire facultative d'une seconde. Sa valeur peut varier de « 0000001 » (une graduation ou un dix-millionième de seconde) à « 9999999 » (9 999 999 dix-millionièmes de seconde ou une seconde moins une graduation).

Contrairement aux spécificateurs de format "g" et "G", le spécificateur de format "c" ne dépend pas de la culture. Elle produit la représentation sous forme de chaîne d’une TimeSpan valeur invariante et commune aux versions antérieures à .NET Framework 4. "c" est la chaîne de format TimeSpan par défaut. La méthode TimeSpan.ToString() met en forme une valeur d'intervalle de temps à l'aide de la chaîne de format "c".

Notes

TimeSpan prend également en charge les chaînes de format standard "t" et "T", dont le comportement est identique à celui de la chaîne de format standard "c".

L'exemple suivant instancie deux objets TimeSpan, les utilise pour effectuer des opérations arithmétiques, puis affiche le résultat. Dans chaque cas, il utilise la mise en forme composite pour afficher la valeur TimeSpan à l'aide du spécificateur de format "c".

using System;

public class Example
{
   public static void Main()
   {
      TimeSpan interval1, interval2;
      interval1 = new TimeSpan(7, 45, 16);
      interval2 = new TimeSpan(18, 12, 38);

      Console.WriteLine("{0:c} - {1:c} = {2:c}", interval1,
                        interval2, interval1 - interval2);
      Console.WriteLine("{0:c} + {1:c} = {2:c}", interval1,
                        interval2, interval1 + interval2);

      interval1 = new TimeSpan(0, 0, 1, 14, 365);
      interval2 = TimeSpan.FromTicks(2143756);
      Console.WriteLine("{0:c} + {1:c} = {2:c}", interval1,
                        interval2, interval1 + interval2);
   }
}
// The example displays the following output:
//       07:45:16 - 18:12:38 = -10:27:22
//       07:45:16 + 18:12:38 = 1.01:57:54
//       00:01:14.3650000 + 00:00:00.2143756 = 00:01:14.5793756

Module Example
    Public Sub Main()
        Dim interval1, interval2 As TimeSpan
        interval1 = New TimeSpan(7, 45, 16)
        interval2 = New TimeSpan(18, 12, 38)

        Console.WriteLine("{0:c} - {1:c} = {2:c}", interval1,
                          interval2, interval1 - interval2)
        Console.WriteLine("{0:c} + {1:c} = {2:c}", interval1,
                          interval2, interval1 + interval2)

        interval1 = New TimeSpan(0, 0, 1, 14, 365)
        interval2 = TimeSpan.FromTicks(2143756)
        Console.WriteLine("{0:c} + {1:c} = {2:c}", interval1,
                          interval2, interval1 + interval2)
    End Sub
End Module
' The example displays the following output:
'       07:45:16 - 18:12:38 = -10:27:22
'       07:45:16 + 18:12:38 = 1.01:57:54
'       00:01:14.3650000 + 00:00:00.2143756 = 00:01:14.5793756

Spécificateur de format court général ("g")

Le spécificateur de format "g" TimeSpan retourne la représentation sous forme de chaîne d'une valeur TimeSpan dans un format compact, en incluant uniquement les éléments qui sont nécessaires. Elle a la forme suivante :

[-][d:]h:mm:ss[.FFFFFFF]

Les éléments entre crochets ([ et ]) sont facultatifs. Le signe deux-points (:) est un symbole littéral. Le tableau suivant décrit les éléments restants.

Élément Description
- Signe négatif facultatif, qui indique un intervalle de temps négatif.
d Nombre facultatif de jours, sans zéros non significatifs.
h Nombre d'heures, allant de "0" à "23", sans zéros non significatifs.
mm Nombre de minutes, allant de "00" à "59".
ss Nombre de secondes, allant de "00" à "59".
. Séparateur des fractions de seconde. Il équivaut à la propriété NumberDecimalSeparator de la culture spécifiée, sans substitutions par l'utilisateur.
FFFFFFF Fractions de seconde. Le moins de chiffres possible sont affichés.

Tout comme le spécificateur de format "G", le spécificateur de format "g" est localisé. Son séparateur de fraction de seconde est basé sur la propriété NumberDecimalSeparator de la culture actuelle ou de la culture spécifiée.

L'exemple suivant instancie deux objets TimeSpan, les utilise pour effectuer des opérations arithmétiques, puis affiche le résultat. Dans chaque cas, il utilise la mise en forme composite pour afficher la valeur TimeSpan à l'aide du spécificateur de format "g". De plus, il met en forme la valeur TimeSpan à l'aide des conventions de format de la culture système actuelle (dans le cas présent, Anglais - États-Unis ou en-US) et de la culture Français - France (fr-FR).

using System;
using System.Globalization;

public class Example
{
   public static void Main()
   {
      TimeSpan interval1, interval2;
      interval1 = new TimeSpan(7, 45, 16);
      interval2 = new TimeSpan(18, 12, 38);

      Console.WriteLine("{0:g} - {1:g} = {2:g}", interval1,
                        interval2, interval1 - interval2);
      Console.WriteLine(String.Format(new CultureInfo("fr-FR"),
                        "{0:g} + {1:g} = {2:g}", interval1,
                        interval2, interval1 + interval2));

      interval1 = new TimeSpan(0, 0, 1, 14, 36);
      interval2 = TimeSpan.FromTicks(2143756);
      Console.WriteLine("{0:g} + {1:g} = {2:g}", interval1,
                        interval2, interval1 + interval2);
   }
}
// The example displays the following output:
//       7:45:16 - 18:12:38 = -10:27:22
//       7:45:16 + 18:12:38 = 1:1:57:54
//       0:01:14.036 + 0:00:00.2143756 = 0:01:14.2503756

Imports System.Globalization

Module Example
    Public Sub Main()
        Dim interval1, interval2 As TimeSpan
        interval1 = New TimeSpan(7, 45, 16)
        interval2 = New TimeSpan(18, 12, 38)

        Console.WriteLine("{0:g} - {1:g} = {2:g}", interval1,
                          interval2, interval1 - interval2)
        Console.WriteLine(String.Format(New CultureInfo("fr-FR"),
                          "{0:g} + {1:g} = {2:g}", interval1,
                          interval2, interval1 + interval2))

        interval1 = New TimeSpan(0, 0, 1, 14, 36)
        interval2 = TimeSpan.FromTicks(2143756)
        Console.WriteLine("{0:g} + {1:g} = {2:g}", interval1,
                          interval2, interval1 + interval2)
    End Sub
End Module
' The example displays the following output:
'       7:45:16 - 18:12:38 = -10:27:22
'       7:45:16 + 18:12:38 = 1:1:57:54
'       0:01:14.036 + 0:00:00.2143756 = 0:01:14.2503756

Spécificateur de format long général ("G")

Le spécificateur de format "G" TimeSpan retourne la représentation sous forme de chaîne d'une valeur TimeSpan sous une forme longue comprenant toujours les jours et les fractions de secondes. La chaîne qui résulte du spécificateur de format standard "G" est au format suivant :

[-]d:hh:mm:ss.fffffff

Les éléments entre crochets ([ et ]) sont facultatifs. Le signe deux-points (:) est un symbole littéral. Le tableau suivant décrit les éléments restants.

Élément Description
- Signe négatif facultatif, qui indique un intervalle de temps négatif.
d Nombre de jours, sans zéros non significatifs.
hh Nombre d'heures, allant de "00" à "23".
mm Nombre de minutes, allant de "00" à "59".
ss Nombre de secondes, allant de "00" à "59".
. Séparateur des fractions de seconde. Il équivaut à la propriété NumberDecimalSeparator de la culture spécifiée, sans substitutions par l'utilisateur.
fffffff Fractions de seconde.

Tout comme le spécificateur de format "G", le spécificateur de format "g" est localisé. Son séparateur de fraction de seconde est basé sur la propriété NumberDecimalSeparator de la culture actuelle ou de la culture spécifiée.

L'exemple suivant instancie deux objets TimeSpan, les utilise pour effectuer des opérations arithmétiques, puis affiche le résultat. Dans chaque cas, il utilise la mise en forme composite pour afficher la valeur TimeSpan à l'aide du spécificateur de format "G". De plus, il met en forme la valeur TimeSpan à l'aide des conventions de format de la culture système actuelle (dans le cas présent, Anglais - États-Unis ou en-US) et de la culture Français - France (fr-FR).

using System;
using System.Globalization;

public class Example
{
   public static void Main()
   {
      TimeSpan interval1, interval2;
      interval1 = new TimeSpan(7, 45, 16);
      interval2 = new TimeSpan(18, 12, 38);

      Console.WriteLine("{0:G} - {1:G} = {2:G}", interval1,
                        interval2, interval1 - interval2);
      Console.WriteLine(String.Format(new CultureInfo("fr-FR"),
                        "{0:G} + {1:G} = {2:G}", interval1,
                        interval2, interval1 + interval2));

      interval1 = new TimeSpan(0, 0, 1, 14, 36);
      interval2 = TimeSpan.FromTicks(2143756);
      Console.WriteLine("{0:G} + {1:G} = {2:G}", interval1,
                        interval2, interval1 + interval2);
   }
}
// The example displays the following output:
//       0:07:45:16.0000000 - 0:18:12:38.0000000 = -0:10:27:22.0000000
//       0:07:45:16,0000000 + 0:18:12:38,0000000 = 1:01:57:54,0000000
//       0:00:01:14.0360000 + 0:00:00:00.2143756 = 0:00:01:14.2503756

Imports System.Globalization

Module Example
    Public Sub Main()
        Dim interval1, interval2 As TimeSpan
        interval1 = New TimeSpan(7, 45, 16)
        interval2 = New TimeSpan(18, 12, 38)

        Console.WriteLine("{0:G} - {1:G} = {2:G}", interval1,
                          interval2, interval1 - interval2)
        Console.WriteLine(String.Format(New CultureInfo("fr-FR"),
                          "{0:G} + {1:G} = {2:G}", interval1,
                          interval2, interval1 + interval2))

        interval1 = New TimeSpan(0, 0, 1, 14, 36)
        interval2 = TimeSpan.FromTicks(2143756)
        Console.WriteLine("{0:G} + {1:G} = {2:G}", interval1,
                          interval2, interval1 + interval2)
    End Sub
End Module
' The example displays the following output:
'       0:07:45:16.0000000 - 0:18:12:38.0000000 = -0:10:27:22.0000000
'       0:07:45:16,0000000 + 0:18:12:38,0000000 = 1:01:57:54,0000000
'       0:00:01:14.0360000 + 0:00:00:00.2143756 = 0:00:01:14.2503756

Voir aussi