Exporter (0) Imprimer
Développer tout
Cet article a fait l'objet d'une traduction manuelle. Déplacez votre pointeur sur les phrases de l'article pour voir la version originale de ce texte. Informations supplémentaires.
Traduction
Source

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 et d'un certain nombre de caractères littéraux. 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.

Remarque importante Important

Les spécificateurs de format TimeSpan personnalisés n'incluent pas de symboles de séparateur d'espaces réservés, tels que les symboles qui séparent les jours des heures, les heures des minutes ou les secondes des fractions de seconde. Ces symboles doivent cependant ê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 des jours et des heures et deux-points (:) comme séparateur des heures et des minutes.

Les spécificateurs de format personnalisés TimeSpan n'incluent pas de symbole qui vous permet de distinguer les intervalles de temps négatifs des positifs. Pour inclure un symbole, vous devez construire une chaîne de caractères en utilisant une logique conditionnelle. La section Autres caractères comprend 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, 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 dans .NET Framework et Mise en forme composite. L'exemple suivant illustre l'utilisation de chaînes de format personnalisées pour la mise en forme d'opérations.


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: {0:%d} day(s)", duration);
      Console.WriteLine("Time of Travel: {0:dd\\.hh\\:mm\\:ss} days", duration);
   }
}
// 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 pour 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("{0} --> {1}", value, interval.ToString("c"));
      else
         Console.WriteLine("Unable to parse '{0}'", value);

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

      value= "12.035";
      if (TimeSpan.TryParseExact(value, "ss\\.fff", null, out interval))
         Console.WriteLine("{0} --> {1}", value, interval.ToString("c"));
      else
         Console.WriteLine("Unable to parse '{0}'", 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


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 complets dans l'intervalle.

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"-"dddddddd"

Nombre de jours entiers de l'intervalle, rempli à l'aide de zéros non significatifs comme requis.

Informations supplémentaires : Spécificateur de format personnalisé "dd"-"dddddddd".

new TimeSpan(6, 14, 32, 17, 685):

   ddd --> "006"

   dd\.hh\:mm --> "06.14:32"

"h", "%h"

Nombre d'heures complètes de l'intervalle qui ne sont pas comptées comme faisant partie de jours. Les heures à un seul chiffre ne sont pas précédées d'un 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 complètes de l'intervalle qui ne sont pas comptées comme faisant partie de jours. Les heures à un seul chiffre sont précédées d'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 complètes de l'intervalle ne faisant pas partie d'heures ou de jours. Un zéro non significatif n'est pas ajouté aux minutes à un chiffre.

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 complètes de l'intervalle ne faisant pas partie d'heures ou de jours. Les minutes à un seul chiffre sont précédées d'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 complètes de l'intervalle ne faisant pas partie d'heures, de jours ou de minutes. Un zéro non significatif n'est pas ajouté devant les secondes à un chiffre.

Informations supplémentaires : Spécificateur de format personnalisé "s".

TimeSpan.FromSeconds(12.965):

    %s --> 12

    s\.fff --> 12.965

"ss"

Nombre de secondes complètes de l'intervalle ne faisant pas partie d'heures, de jours ou de minutes. Les secondes à un seul chiffre sont précédées d'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 de seconde d'un intervalle.

Informations supplémentaires : Spécificateur de format personnalisé "f".

TimeSpan.FromSeconds(6.895):

    f --> 8

    ss\.f --> 06.8

"ff"

Centièmes de seconde d'un intervalle.

Informations supplémentaires : Spécificateur de format personnalisé "ff".

TimeSpan.FromSeconds(6.895):

    ff --> 89

    ss\.ff --> 06.89

"fff"

Millisecondes d'un intervalle.

Informations supplémentaires : Spécificateur de format personnalisé "fff".

TimeSpan.FromSeconds(6.895):

    fff --> 895

    ss\.fff --> 06.895

"ffff"

Dix-millièmes de seconde d'un intervalle.

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 de seconde d'un intervalle.

Informations supplémentaires : Spécificateur de format personnalisé "fffff".

TimeSpan.Parse("0:0:6.8954321"):

    fffff --> 89543

    ss\.fffff --> 06.89543

"ffffff"

Millionièmes de seconde d'un intervalle.

Informations supplémentaires : Spécificateur de format personnalisé "ffffff".

TimeSpan.Parse("0:0:6.8954321"):

    ffffff --> 895432

    ss\.ffffff --> 06.895432

"fffffff"

Dix-millionièmes de seconde (ou battements fractionnaires) d'un intervalle.

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 de seconde d'un intervalle. Rien ne s'affiche si le chiffre est 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 de seconde d'un intervalle. Les zéros non significatifs fractionnaires et les 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 d'un intervalle. Les zéros non significatifs fractionnaires ne sont pas inclus.

Informations supplémentaires :

TimeSpan.Parse("00:00:06.3291"):

    FFF: 329

TimeSpan.Parse("0:0:3.1009"):

    ss\.FFF: 03.1

"FFFF"

Dix-millièmes de seconde d'un intervalle. Les zéros non significatifs 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 de seconde d'un intervalle. Les zéros non significatifs 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"

Millionièmes de seconde d'un intervalle. Les zéros non significatifs 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"

Dix-millionièmes de seconde d'un intervalle. Les zéros non significatifs et sept chiffres zéro 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

'string'

Délimiteur de chaîne littérale.

Informations supplémentaires : Autres caractères.

new TimeSpan(14, 32, 17):

   hh':'mm':'ss --> "14:32:17"

\

Caractère d'échappement.

Informations supplémentaires : Autres caractères.

new TimeSpan(14, 32, 17):

   hh\:mm\:ss --> "14:32:17"

N'importe quel autre caractère

Les autres caractères sans séquence d'échappement sont interprétés comme des spécificateurs de format personnalisés.

Informations supplémentaires : Autres caractères.

new TimeSpan(14, 32, 17):

   hh\:mm\:ss --> "14:32:17"

La sortie du spécificateur de format personnalisé "d" a la valeur de la propriété TimeSpan.Days, qui représente le nombre de jours entiers de l'intervalle. Elle affiche le nombre total de jours d'une valeur TimeSpan, même si la valeur a plusieurs chiffres. Si la valeur de la propriété TimeSpan.Days est nulle, la sortie du spécificateur est "0".

Si le spécificateur de format personnalisé "d" est utilisé seul, spécifiez "%d" afin qu'il ne soit pas interprété à tort 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   


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      


Retour au tableau

Les spécificateurs de format personnalisés "dd", "ddd", "dddd", "ddddd", "dddddd", "ddddddd" et "dddddddd" affichent la valeur de la propriété TimeSpan.Days, qui représente le nombre de jours entiers de l'intervalle.

La chaîne de sortie comprend un nombre minimal de chiffres spécifié par le nombre de caractères "d" dans le spécificateur de format, et est remplie à l'aide de zéros non significatifs comme requis. 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 affiché 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 est zéro ; la valeur du composant « jours » du deuxième 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("{0} --> {1:" + fmt + "}", fmt, ts1);  
   Console.WriteLine("{0} --> {1:" + fmt + "}", fmt, ts2);
   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      


Retour au tableau

Le spécificateur de format personnalisé "h" affiche la valeur de la propriété TimeSpan.Hours, qui représente le nombre d'heures entières de l'intervalle qui ne sont pas comptées comme faisant partie du composant « jour ». Il retourne une valeur de chaîne à un seul 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 interprété à tort comme une chaîne de format standard. L'exemple suivant illustre cette situation.


TimeSpan ts = 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 général, lors d'une opération d'analyse, une chaîne d'entrée comprenant un nombre unique est interprétée comme un nombre de jours. Vous pouvez utiliser le spécificateur de format personnalisé "%h" à la place pour interpréter la chaîne numérique comme un 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 '{0}' to a time interval", 
                     value);   
// 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


Retour au tableau

Le spécificateur de format personnalisé "hh" affiche la valeur de la propriété TimeSpan.Hours, qui représente le nombre d'heures entières de l'intervalle qui ne sont pas comptées comme faisant partie du composant « jour ». Pour les valeurs comprises entre 0 et 9, la chaîne de sortie inclut un zéro non significatif.

En général, lors d'une opération d'analyse, une chaîne d'entrée comprenant un nombre unique est interprétée comme un nombre de jours. Vous pouvez utiliser le spécificateur de format personnalisé "hh" à la place pour interpréter la chaîne numérique comme un 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 '{0}' to a time interval", 
                     value);   
// 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


Retour au tableau

Le spécificateur de format personnalisé "m" affiche la valeur de la propriété TimeSpan.Minutes, qui représente le nombre de minutes entières de l'intervalle qui ne sont pas comptées comme faisant partie du composant « jour ». Il retourne une valeur de chaîne à un seul 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 interprété à tort comme une chaîne de format standard. L'exemple suivant illustre cette situation.


TimeSpan ts = 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 général, lors d'une opération d'analyse, une chaîne d'entrée comprenant un nombre unique est interprétée comme un nombre de jours. Vous pouvez utiliser le spécificateur de format personnalisé "%m" à la place pour interpréter la chaîne numérique comme un nombre d'heures. 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 '{0}' to a time interval", 
                     value);   
// 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("{0:m\\:ss} minutes", ts1);

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


Retour au tableau

Le spécificateur de format personnalisé "mm" affiche la valeur de la propriété TimeSpan.Minutes, qui représente le nombre de minutes entières de l'intervalle qui ne sont pas comptées comme faisant partie du composant « heures » ou « jours ». Pour les valeurs comprises entre 0 et 9, la chaîne de sortie inclut un zéro non significatif.

En général, lors d'une opération d'analyse, une chaîne d'entrée comprenant un nombre unique est interprétée comme un nombre de jours. Vous pouvez utiliser le spécificateur de format personnalisé "mm" à la place pour interpréter la chaîne numérique comme un nombre d'heures. 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 '{0}' to a time interval", 
                     value);   
// The example displays the following output:
//       00:07: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: {0:hh\\:mm}", 
                  arriveTime - departTime);
// The example displays the following output:
//       Travel time: 05:16      


Retour au tableau

Le spécificateur de format personnalisé "s" affiche la valeur de la propriété TimeSpan.Seconds, qui représente le nombre de secondes entières de l'intervalle qui ne sont pas comptées comme faisant partie du composant « minutes », « heures » ou « jours ». Il retourne une valeur de chaîne à un seul 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 interprété à tort 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


En général, lors d'une opération d'analyse, une chaîne d'entrée comprenant un nombre unique est interprétée comme un nombre de jours. Vous pouvez utiliser le spécificateur de format personnalisé "%s" à la place pour interpréter la chaîne numérique comme un 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 '{0}' to a time interval", 
                     value);   
// 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      


Retour au tableau

Le spécificateur de format personnalisé "ss" affiche la valeur de la propriété TimeSpan.Seconds, qui représente le nombre de secondes entières de l'intervalle qui ne sont pas comptées comme faisant partie du composant « minutes », « heures » ou « jours ». Pour les valeurs comprises entre 0 et 9, la chaîne de sortie inclut un zéro non significatif.

En général, lors d'une opération d'analyse, une chaîne d'entrée comprenant un nombre unique est interprétée comme un nombre de jours. Vous pouvez utiliser le spécificateur de format personnalisé "ss" à la place pour interpréter la chaîne numérique comme un 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 '{0}' to a time interval", 
                        value);   
}
// 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


Retour au tableau

Le spécificateur de format personnalisé "f" affiche les dixièmes de seconde d'un intervalle. 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 interprété à tort comme une chaîne de format standard.

L'exemple suivant utilise le spécificateur de format personnalisé "f" pour afficher les dixièmes de seconde dans une valeur TimeSpan. "f" est d'abord utilisé comme seul spécificateur de format, puis est 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("{0,10}: {1:" + fmt + "}", fmt, ts);
} 
Console.WriteLine();

for (int ctr = 1; ctr <= 7; ctr++) {
   fmt = new String('f', ctr);
   Console.WriteLine("{0,10}: {1:s\\." + fmt + "}", "s\\." + fmt, ts);
}
// 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

Le spécificateur de format personnalisé "ff" affiche les centièmes de seconde d'un intervalle. 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 de seconde dans une valeur TimeSpan. "ff" est d'abord utilisé comme seul spécificateur de format, puis est 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("{0,10}: {1:" + fmt + "}", fmt, ts);
} 
Console.WriteLine();

for (int ctr = 1; ctr <= 7; ctr++) {
   fmt = new String('f', ctr);
   Console.WriteLine("{0,10}: {1:s\\." + fmt + "}", "s\\." + fmt, ts);
}
// 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

Le spécificateur de format personnalisé "fff" (avec trois "f") affiche les millisecondes d'un intervalle. 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 d'abord utilisé comme seul spécificateur de format, puis est 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("{0,10}: {1:" + fmt + "}", fmt, ts);
} 
Console.WriteLine();

for (int ctr = 1; ctr <= 7; ctr++) {
   fmt = new String('f', ctr);
   Console.WriteLine("{0,10}: {1:s\\." + fmt + "}", "s\\." + fmt, ts);
}
// 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

Le spécificateur de format personnalisé "ffff" (avec quatre "f") affiche les dix-millièmes de seconde d'un intervalle. 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 de seconde dans une valeur TimeSpan. "ffff" est d'abord utilisé comme seul spécificateur de format, puis est 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("{0,10}: {1:" + fmt + "}", fmt, ts);
} 
Console.WriteLine();

for (int ctr = 1; ctr <= 7; ctr++) {
   fmt = new String('f', ctr);
   Console.WriteLine("{0,10}: {1:s\\." + fmt + "}", "s\\." + fmt, ts);
}
// 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

Le spécificateur de format personnalisé "fffff" (avec cinq "f") affiche les cent-millièmes de seconde d'un intervalle. 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 de seconde dans une valeur TimeSpan. "fffff" est d'abord utilisé comme seul spécificateur de format, puis est 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("{0,10}: {1:" + fmt + "}", fmt, ts);
} 
Console.WriteLine();

for (int ctr = 1; ctr <= 7; ctr++) {
   fmt = new String('f', ctr);
   Console.WriteLine("{0,10}: {1:s\\." + fmt + "}", "s\\." + fmt, ts);
}
// 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

Le spécificateur de format personnalisé "ffffff" (avec six "f") affiche les millionièmes de seconde d'un intervalle. 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 fractionnaires.

L'exemple suivant utilise le spécificateur de format personnalisé "ffffff" pour afficher les millionièmes de seconde dans une valeur TimeSpan. Il est d'abord utilisé comme seul spécificateur de format, puis est 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("{0,10}: {1:" + fmt + "}", fmt, ts);
} 
Console.WriteLine();

for (int ctr = 1; ctr <= 7; ctr++) {
   fmt = new String('f', ctr);
   Console.WriteLine("{0,10}: {1:s\\." + fmt + "}", "s\\." + fmt, ts);
}
// 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

Le spécificateur de format personnalisé "fffffff" (avec sept "f") affiche les dix-millionièmes de seconde (ou le nombre fractionnaire de battements) d'un intervalle. 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 battements dans une valeur TimeSpan. Il est d'abord utilisé comme seul spécificateur de format, puis est 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("{0,10}: {1:" + fmt + "}", fmt, ts);
} 
Console.WriteLine();

for (int ctr = 1; ctr <= 7; ctr++) {
   fmt = new String('f', ctr);
   Console.WriteLine("{0,10}: {1:s\\." + fmt + "}", "s\\." + fmt, ts);
}
// 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

Le spécificateur de format personnalisé "F" affiche les dixièmes de seconde d'un intervalle. Dans une opération de mise en forme, tous les chiffres fractionnaires restants sont tronqués. Si la valeur du dixième de seconde de l'intervalle est zéro, il n'est 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 du chiffre des dixièmes de seconde est facultative.

Si le spécificateur de format personnalisé "F" est utilisé seul, spécifiez "%F" afin qu'il ne soit pas interprété à tort comme une chaîne de format standard.

L'exemple suivant utilise le spécificateur de format personnalisé "F" pour afficher les dixièmes de 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("{0} ('%F') --> {0:%F}", ts1);

TimeSpan ts2 = TimeSpan.Parse("0:0:3.091");
Console.WriteLine("{0} ('ss\\.F') --> {0:ss\\.F}", ts2);
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("{0} ('{1}') --> {2}", input, fmt, ts3);
   else
      Console.WriteLine("Cannot parse {0} with '{1}'.", 
                        input, 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'.      


Retour au tableau

Le spécificateur de format personnalisé "FF" affiche les centièmes de seconde d'un intervalle. Dans une opération de mise en forme, tous les chiffres fractionnaires restants sont tronqués. Si des zéros non significatifs fractionnaires sont présents, 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 du chiffre des dixièmes et des centièmes de seconde est facultative.

L'exemple suivant utilise le spécificateur de format personnalisé "FF" pour afficher les centièmes de 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("{0} ('FF') --> {0:FF}", ts1);

TimeSpan ts2 = TimeSpan.Parse("0:0:3.809");
Console.WriteLine("{0} ('ss\\.FF') --> {0:ss\\.FF}", ts2);
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("{0} ('{1}') --> {2}", input, fmt, ts3);
   else
      Console.WriteLine("Cannot parse {0} with '{1}'.", 
                        input, 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'.      


Retour au tableau

Le spécificateur de format personnalisé "FFF" (avec trois "F") affiche les millisecondes d'un intervalle. Dans une opération de mise en forme, tous les chiffres fractionnaires restants sont tronqués. Si des zéros non significatifs fractionnaires sont présents, 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 du chiffre des dixièmes, des centièmes et des millièmes de seconde est facultative.

L'exemple suivant utilise le spécificateur de format personnalisé "FFF" pour afficher les millièmes de 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("{0} ('FFF') --> {0:FFF}", ts1);

TimeSpan ts2 = TimeSpan.Parse("0:0:3.8009");
Console.WriteLine("{0} ('ss\\.FFF') --> {0:ss\\.FFF}", ts2);
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("{0} ('{1}') --> {2}", input, fmt, ts3);
   else
      Console.WriteLine("Cannot parse {0} with '{1}'.", 
                        input, 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'.      


Retour au tableau

Le spécificateur de format personnalisé "FFFF" (avec quatre "F") affiche les dix-millièmes de seconde d'un intervalle. Dans une opération de mise en forme, tous les chiffres fractionnaires restants sont tronqués. Si des zéros non significatifs fractionnaires sont présents, 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 du chiffre des dixièmes, des centièmes, des millièmes et des dix-millièmes de seconde est facultative.

L'exemple suivant utilise le spécificateur de format personnalisé "FFFF" pour afficher les dix-millièmes de seconde dans une valeur TimeSpan. Il utilise également ce 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("{0} ('FFFF') --> {0:FFFF}", ts1);

TimeSpan ts2 = TimeSpan.Parse("0:0:3.80009");
Console.WriteLine("{0} ('ss\\.FFFF') --> {0:ss\\.FFFF}", ts2);
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("{0} ('{1}') --> {2}", input, fmt, ts3);
   else
      Console.WriteLine("Cannot parse {0} with '{1}'.", 
                        input, 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'.


Retour au tableau

Le spécificateur de format personnalisé "FFFFF" (avec cinq "F") affiche les cent-millièmes de seconde d'un intervalle. Dans une opération de mise en forme, tous les chiffres fractionnaires restants sont tronqués. Si des zéros non significatifs fractionnaires sont présents, 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 du chiffre des dixièmes, des centièmes, des millièmes, des dix-millièmes et des cent-millièmes de seconde est facultative.

L'exemple suivant utilise le spécificateur de format personnalisé "FFFFF" pour afficher les cent-millièmes de seconde dans une valeur TimeSpan. Il utilise également ce 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("{0} ('FFFFF') --> {0:FFFFF}", ts1);

TimeSpan ts2 = TimeSpan.Parse("0:0:3.800009");
Console.WriteLine("{0} ('ss\\.FFFFF') --> {0:ss\\.FFFFF}", ts2);
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("{0} ('{1}') --> {2}", input, fmt, ts3);
   else
      Console.WriteLine("Cannot parse {0} with '{1}'.", 
                        input, 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'.      


Retour au tableau

Le spécificateur de format personnalisé "FFFFFF" (avec six "F") affiche les millionièmes de seconde d'un intervalle. Dans une opération de mise en forme, tous les chiffres fractionnaires restants sont tronqués. Si des zéros non significatifs fractionnaires sont présents, 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 du chiffre des dixièmes, centièmes, millièmes, dix-millièmes, cent-millièmes et des millionièmes de seconde est facultative.

L'exemple suivant utilise le spécificateur de format personnalisé "FFFFFF" pour afficher les millionièmes de 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("{0} ('FFFFFF') --> {0:FFFFFF}", ts1);

TimeSpan ts2 = TimeSpan.Parse("0:0:3.8000009");
Console.WriteLine("{0} ('ss\\.FFFFFF') --> {0:ss\\.FFFFFF}", ts2);
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("{0} ('{1}') --> {2}", input, fmt, ts3);
   else
      Console.WriteLine("Cannot parse {0} with '{1}'.", 
                        input, 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'.      


Retour au tableau

Le spécificateur de format personnalisé "FFFFFFF" (avec sept "F") affiche les dix-millionièmes de seconde (ou le nombre fractionnaire de battements) d'un intervalle. Si des zéros non significatifs fractionnaires sont présents, 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("{0} ('FFFFFFF') --> {0:FFFFFFF}", ts1);

TimeSpan ts2 = TimeSpan.Parse("0:0:3.9500000");
Console.WriteLine("{0} ('ss\\.FFFFFFF') --> {0:ss\\.FFFFFFF}", ts2);
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("{0} ('{1}') --> {2}", input, fmt, ts3);
   else
      Console.WriteLine("Cannot parse {0} with '{1}'.", 
                        input, 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      


Retour au tableau

Tout autre caractère sans séquence d'échappement d'une chaîne de format, notamment un caractère d'espace blanc, est interprété comme un spécificateur de format personnalisé. Dans la plupart des cas, la présence de tout autre caractère sans séquence d'échappement lève une FormatException.

Il existe deux moyens d'inclure un caractère littéral dans une chaîne de format :

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

  • Précédez-le d'une barre oblique inverse ("\"), interprétée comme un caractère d'échappement. Cela signifie qu'en C#, la chaîne de format doit être comprise entre deux caractères @ 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 une logique conditionnelle pour inclure un symbole pour les intervalles de temps négatif.

    
    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: {0:" + fmt + "}", result);
       }
    }
    // The example displays output like the following:
    //       -1291.10:54
    //       Interval: -1291.10:54
    
    
    

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

L'exemple suivant utilise à la fois le caractère d'échappement et le guillemet simple pour définir une chaîne de format personnalisée comprenant 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      


Retour au tableau

Ajouts de la communauté

AJOUTER
Afficher:
© 2015 Microsoft