Chaînes de format TimeSpan personnaliséesCustom TimeSpan Format Strings

A TimeSpan chaîne de format définit la représentation sous forme de chaîne d’un TimeSpan valeur qui résulte d’une opération de mise en forme.A TimeSpan format string defines the string representation of a TimeSpan value that results from a formatting operation. Une chaîne de format personnalisée se compose de personnaliser un ou plusieurs TimeSpan spécificateurs, ainsi que n’importe quel nombre de caractères littéraux de format.A custom format string consists of one or more custom TimeSpan format specifiers along with any number of literal characters. N’importe quelle chaîne qui n’est pas un chaîne de format TimeSpan standard est interprété comme un personnalisé TimeSpan chaîne de format.Any string that is not a standard TimeSpan format string is interpreted as a custom TimeSpan format string.

Important

Personnalisé TimeSpan spécificateurs de format n’incluent pas de symboles de séparateur, tels que les symboles qui séparent les jours des heures, minutes, ou les secondes des fractions de seconde.The custom TimeSpan format specifiers do not include placeholder separator symbols, such as the symbols that separate days from hours, hours from minutes, or seconds from fractional seconds. Au lieu de cela, ces symboles doivent figurer dans la chaîne de format personnalisée comme littéraux de chaîne.Instead, these symbols must be included in the custom format string as string literals. 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.For example, "dd\.hh\:mm" defines a period (.) as the separator between days and hours, and a colon (:) as the separator between hours and minutes.

Personnalisé TimeSpan spécificateurs de format également n’incluent pas d’un symbole qui vous permet de faire la distinction entre les intervalles de temps positifs et négatifs.Custom TimeSpan format specifiers also do not include a sign symbol that enables you to differentiate between negative and positive time intervals. Pour inclure un symbole de signe, vous devez construire une chaîne de format à l’aide d’une logique conditionnelle.To include a sign symbol, you have to construct a format string by using conditional logic. La section Autres caractères présente un exemple.The Other Characters section includes an example.

Les représentations sous forme de chaîne de TimeSpan valeurs produites par des appels aux surcharges de la TimeSpan.ToString (méthode) et par les méthodes qui prennent en charge la mise en forme composite, telles que String.Format.The string representations of TimeSpan values are produced by calls to the overloads of the TimeSpan.ToString method, and by methods that support composite formatting, such as String.Format. Pour plus d’informations, consultez Mise en forme des types et Mise en forme composite.For more information, see Formatting Types and Composite Formatting. L’exemple suivant illustre l’utilisation de chaînes de format personnalisées dans les opérations de mise en forme.The following example illustrates the use of custom format strings in formatting operations.

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

Personnalisé TimeSpan les chaînes de format sont également utilisés par le TimeSpan.ParseExact et TimeSpan.TryParseExact méthodes pour définir le format requis des chaînes d’entrée pour l’analyse des opérations.Custom TimeSpan format strings are also used by the TimeSpan.ParseExact and TimeSpan.TryParseExact methods to define the required format of input strings for parsing operations. (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 des opérations d'analyse.(Parsing converts the string representation of a value to that value.) The following example illustrates the use of standard format strings in parsing operations.

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
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 d’heure date personnalisé.The following table describes the custom date and time format specifiers.

Spécificateur de formatFormat specifier DescriptionDescription ExempleExample
"d", "%d""d", "%d" Nombre de jours entiers dans l’intervalle de temps.The number of whole days in the time interval.

Informations supplémentaires : Spécificateur de format personnalisé "d".More information: The "d" Custom Format Specifier.
new TimeSpan(6, 14, 32, 17, 685):

%d --> "6"%d --> "6"

d\.hh\:mm --> "6.14:32"d\.hh\:mm --> "6.14:32"
« dd »-« dddddddd »"dd"-"dddddddd" Nombre de jours entiers dans l’intervalle de temps, complété avec des zéros non significatifs en fonction des besoins.The number of whole days in the time interval, padded with leading zeros as needed.

Plus d’informations : « dd »-« dddddddd « spécificateurs de Format personnalisés.More information: The "dd"-"dddddddd" Custom Format Specifiers.
new TimeSpan(6, 14, 32, 17, 685):

ddd --> "006"ddd --> "006"

dd\.hh\:mm --> "06.14:32"dd\.hh\:mm --> "06.14:32"
"h", "%h""h", "%h" Nombre d’heures entières dans l’intervalle de temps qui ne sont pas comptabilisées dans des jours.The number of whole hours in the time interval that are not counted as part of days. Les heures à un chiffre n’ont pas de zéro non significatif.Single-digit hours do not have a leading zero.

Informations supplémentaires : Spécificateur de format personnalisé "h".More information: The "h" Custom Format Specifier.
new TimeSpan(6, 14, 32, 17, 685):

%h --> "14"%h --> "14"

hh\:mm --> "14:32"hh\:mm --> "14:32"
"hh""hh" Nombre d’heures entières dans l’intervalle de temps qui ne sont pas comptabilisées dans des jours.The number of whole hours in the time interval that are not counted as part of days. Les heures à un chiffre ont un zéro non significatif.Single-digit hours have a leading zero.

Informations supplémentaires : Spécificateur de format personnalisé "hh".More information: The "hh" Custom Format Specifier.
new TimeSpan(6, 14, 32, 17, 685):

hh --> "14"hh --> "14"

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

hh --> 08hh --> 08
"m", "%m""m", "%m" Nombre de minutes entières dans l’intervalle de temps qui ne sont pas incluses dans des jours ou des heures.The number of whole minutes in the time interval that are not included as part of hours or days. Les minutes à un chiffre n’ont pas de zéro non significatif.Single-digit minutes do not have a leading zero.

Informations supplémentaires : Spécificateur de format personnalisé "m".More information: The "m" Custom Format Specifier.
new TimeSpan(6, 14, 8, 17, 685):

%m --> "8"%m --> "8"

h\:m --> "14:8"h\:m --> "14:8"
"mm""mm" Nombre de minutes entières dans l’intervalle de temps qui ne sont pas incluses dans des jours ou des heures.The number of whole minutes in the time interval that are not included as part of hours or days. Les minutes à un chiffre ont un zéro non significatif.Single-digit minutes have a leading zero.

Informations supplémentaires : Spécificateur de format personnalisé "mm".More information: The "mm" Custom Format Specifier.
new TimeSpan(6, 14, 8, 17, 685):

mm --> "08"mm --> "08"

new TimeSpan(6, 8, 5, 17, 685):

d\.hh\:mm\:ss --> 6.08:05:17d\.hh\:mm\:ss --> 6.08:05:17
"s", "%s""s", "%s" Nombre de secondes entières dans l’intervalle de temps qui ne sont pas incluses dans des jours, heures ou minutes.The number of whole seconds in the time interval that are not included as part of hours, days, or minutes. Les secondes à un chiffre n’ont pas de zéro non significatif.Single-digit seconds do not have a leading zero.

Informations supplémentaires : Spécificateur de format personnalisé "s".More information: The "s" Custom Format Specifier.
TimeSpan.FromSeconds(12.965):TimeSpan.FromSeconds(12.965):

%s --> 12%s --> 12

s\.fff --> 12.965s\.fff --> 12.965
"ss""ss" Nombre de secondes entières dans l’intervalle de temps qui ne sont pas incluses dans des jours, heures ou minutes.The number of whole seconds in the time interval that are not included as part of hours, days, or minutes. Les secondes à un chiffre ont un zéro non significatif.Single-digit seconds have a leading zero.

Informations supplémentaires : Spécificateur de format personnalisé "ss".More information: The "ss" Custom Format Specifier.
TimeSpan.FromSeconds(6.965):TimeSpan.FromSeconds(6.965):

ss --> 06ss --> 06

ss\.fff --> 06.965ss\.fff --> 06.965
"f", "%f""f", "%f" Dixièmes de seconde dans un intervalle de temps.The tenths of a second in a time interval.

Informations supplémentaires : Spécificateur de format personnalisé "f".More information: The "f" Custom Format Specifier.
TimeSpan.FromSeconds(6.895):TimeSpan.FromSeconds(6.895):

f --> 8f --> 8

ss\.f --> 06.8ss\.f --> 06.8
"ff""ff" Centièmes de seconde dans un intervalle de temps.The hundredths of a second in a time interval.

Plus d’informations :le spécificateur de Format personnalisé « ff ».More information:The "ff" Custom Format Specifier.
TimeSpan.FromSeconds(6.895):TimeSpan.FromSeconds(6.895):

ff --> 89ff --> 89

ss\.ff --> 06.89ss\.ff --> 06.89
"fff""fff" Millisecondes dans un intervalle de temps.The milliseconds in a time interval.

Informations supplémentaires : Spécificateur de format personnalisé "fff".More information: The "fff" Custom Format Specifier.
TimeSpan.FromSeconds(6.895):TimeSpan.FromSeconds(6.895):

fff --> 895fff --> 895

ss\.fff --> 06.895ss\.fff --> 06.895
"ffff""ffff" Dix millièmes de seconde dans un intervalle de temps.The ten-thousandths of a second in a time interval.

Informations supplémentaires : Spécificateur de format personnalisé "ffff".More information: The "ffff" Custom Format Specifier.
TimeSpan.Parse("0:0:6.8954321"):TimeSpan.Parse("0:0:6.8954321"):

ffff --> 8954ffff --> 8954

ss\.ffff --> 06.8954ss\.ffff --> 06.8954
"fffff""fffff" Cent millièmes de seconde dans un intervalle de temps.The hundred-thousandths of a second in a time interval.

Informations supplémentaires : Spécificateur de format personnalisé "fffff".More information: The "fffff" Custom Format Specifier.
TimeSpan.Parse("0:0:6.8954321"):TimeSpan.Parse("0:0:6.8954321"):

fffff --> 89543fffff --> 89543

ss\.fffff --> 06.89543ss\.fffff --> 06.89543
"ffffff""ffffff" Millionièmes de seconde dans un intervalle de temps.The millionths of a second in a time interval.

Informations supplémentaires : Spécificateur de format personnalisé "ffffff".More information: The "ffffff" Custom Format Specifier.
TimeSpan.Parse("0:0:6.8954321"):TimeSpan.Parse("0:0:6.8954321"):

ffffff --> 895432ffffff --> 895432

ss\.ffffff --> 06.895432ss\.ffffff --> 06.895432
"fffffff""fffffff" Dix millionièmes de seconde (ou nombre fractionnaire de graduations) dans un intervalle de temps.The ten-millionths of a second (or the fractional ticks) in a time interval.

Informations supplémentaires : Spécificateur de format personnalisé "fffffff".More information: The "fffffff" Custom Format Specifier.
TimeSpan.Parse("0:0:6.8954321"):TimeSpan.Parse("0:0:6.8954321"):

fffffff --> 8954321fffffff --> 8954321

ss\.fffffff --> 06.8954321ss\.fffffff --> 06.8954321
"F", "%F""F", "%F" Dixièmes de seconde dans un intervalle de temps.The tenths of a second in a time interval. Rien ne s'affiche si le chiffre est zéro.Nothing is displayed if the digit is zero.

Informations supplémentaires : Spécificateur de format personnalisé "F".More information: The "F" Custom Format Specifier.
TimeSpan.Parse("00:00:06.32"):TimeSpan.Parse("00:00:06.32"):

%F: 3%F: 3

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

ss\.F: 03.ss\.F: 03.
"FF""FF" Centièmes de seconde dans un intervalle de temps.The hundredths of a second in a time interval. Tous les zéros de fin fractionnaires ou deux chiffres zéro ne sont pas affichés.Any fractional trailing zeros or two zero digits are not included.

Informations supplémentaires : Spécificateur de format personnalisé "FF".More information: The "FF" Custom Format Specifier.
TimeSpan.Parse("00:00:06.329"):TimeSpan.Parse("00:00:06.329"):

FF: 32FF: 32

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

ss\.FF: 03.1ss\.FF: 03.1
"FFF""FFF" Millisecondes dans un intervalle de temps.The milliseconds in a time interval. Tous les zéros de fin fractionnaires ne sont pas affichés.Any fractional trailing zeros are not included.

Plus d’informations :More information:
TimeSpan.Parse("00:00:06.3291"):TimeSpan.Parse("00:00:06.3291"):

FFF: 329FFF: 329

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

ss\.FFF: 03.1ss\.FFF: 03.1
"FFFF""FFFF" Dix millièmes de seconde dans un intervalle de temps.The ten-thousandths of a second in a time interval. Tous les zéros de fin fractionnaires ne sont pas affichés.Any fractional trailing zeros are not included.

Informations supplémentaires : Spécificateur de format personnalisé "FFFF".More information: The "FFFF" Custom Format Specifier.
TimeSpan.Parse("00:00:06.32917"):TimeSpan.Parse("00:00:06.32917"):

FFFFF: 3291FFFFF: 3291

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

ss\.FFFF: 03.1ss\.FFFF: 03.1
"FFFFF""FFFFF" Cent millièmes de seconde dans un intervalle de temps.The hundred-thousandths of a second in a time interval. Tous les zéros de fin fractionnaires ne sont pas affichés.Any fractional trailing zeros are not included.

Informations supplémentaires : Spécificateur de format personnalisé "FFFFF".More information: The "FFFFF" Custom Format Specifier.
TimeSpan.Parse("00:00:06.329179"):TimeSpan.Parse("00:00:06.329179"):

FFFFF: 32917FFFFF: 32917

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

ss\.FFFFF: 03.1ss\.FFFFF: 03.1
"FFFFFF""FFFFFF" Millionièmes de seconde dans un intervalle de temps.The millionths of a second in a time interval. Tous les zéros de fin fractionnaires ne sont pas affichés.Any fractional trailing zeros are not displayed.

Informations supplémentaires : Spécificateur de format personnalisé "FFFFFF".More information: The "FFFFFF" Custom Format Specifier.
TimeSpan.Parse("00:00:06.3291791"):TimeSpan.Parse("00:00:06.3291791"):

FFFFFF: 329179FFFFFF: 329179

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

ss\.FFFFFF: 03.1ss\.FFFFFF: 03.1
"FFFFFFF""FFFFFFF" Dix millionièmes de seconde dans un intervalle de temps.The ten-millions of a second in a time interval. Tous les zéros de fin fractionnaires ou sept zéros ne sont pas affichés.Any fractional trailing zeros or seven zeros are not displayed.

Informations supplémentaires : Spécificateur de format personnalisé "FFFFFFF".More information: The "FFFFFFF" Custom Format Specifier.
TimeSpan.Parse("00:00:06.3291791"):TimeSpan.Parse("00:00:06.3291791"):

FFFFFF: 3291791FFFFFF: 3291791

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

ss\.FFFFFF: 03.19ss\.FFFFFF: 03.19
' chaîne''string' Délimiteur de chaîne littérale.Literal string delimiter.

Plus d’informations : autres caractères.More information: Other Characters.
new TimeSpan(14, 32, 17):

hh':'mm':'ss --> "14:32:17"hh':'mm':'ss --> "14:32:17"
|Caractère d'échappement.The escape character.

Plus d’informations :autres caractères.More information:Other Characters.
new TimeSpan(14, 32, 17):

hh\:mm\:ss --> "14:32:17"hh\:mm\:ss --> "14:32:17"
N'importe quel autre caractèreAny other character Tout autre caractère sans séquence d’échappement est interprété comme un spécificateur de format personnalisé.Any other unescaped character is interpreted as a custom format specifier.

Plus d’informations : autres caractères.More Information: Other Characters.
new TimeSpan(14, 32, 17):

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

Spécificateur de format personnalisé "d"The "d" Custom Format Specifier

Le spécificateur de format personnalisé « d » affiche la valeur de la TimeSpan.Days propriété, qui représente le nombre de jours entiers de l’intervalle de temps.The "d" custom format specifier outputs the value of the TimeSpan.Days property, which represents the number of whole days in the time interval. Il affiche le nombre total de jours dans un TimeSpan valeur, même si la valeur a plusieurs chiffres.It outputs the full number of days in a TimeSpan value, even if the value has more than one digit. Si la valeur de la TimeSpan.Days propriété est zéro, le spécificateur retourne « 0 ».If the value of the TimeSpan.Days property is zero, the specifier outputs "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.If the "d" custom format specifier is used alone, specify "%d" so that it is not misinterpreted as a standard format string. L'exemple suivant illustre cette situation.The following example provides an illustration.

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".The following example illustrates the use of the "d" custom format specifier.

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 tableauBack to table

Spécificateurs de format personnalisé "dd" à "dddddddd"The "dd"-"dddddddd" Custom Format Specifiers

« Jj », « ddd », « dddd », « ddddd », « dddddd », « ddddddd » et spécificateur de format personnalisé « dddddddd » de la valeur de sortie du TimeSpan.Days propriété, qui représente le nombre de jours entiers de l’intervalle de temps.The "dd", "ddd", "dddd", "ddddd", "dddddd", "ddddddd", and "dddddddd" custom format specifiers output the value of the TimeSpan.Days property, which represents the number of whole days in the time interval.

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 elle est remplie avec des zéros non significatifs en fonction des besoins.The output string includes a minimum number of digits specified by the number of "d" characters in the format specifier, and it is padded with leading zeros as needed. Si les chiffres dans le 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.If the digits in the number of days exceed the number of "d" characters in the format specifier, the full number of days is output in the result string.

L’exemple suivant utilise ces spécificateurs de format pour afficher la représentation sous forme de chaîne de deux TimeSpan valeurs.The following example uses these format specifiers to display the string representation of two TimeSpan values. La valeur du composant « jours » du premier intervalle de temps est zéro ; la valeur du composant « jours » du deuxième est 365.The value of the days component of the first time interval is zero; the value of the days component of the second is 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      
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 tableauBack to table

Spécificateur de format personnalisé "h"The "h" Custom Format Specifier

Le spécificateur de format personnalisé « h » affiche la valeur de la TimeSpan.Hours propriété, qui représente le nombre d’heures entières de l’intervalle de temps qui n’est pas compté dans le cadre du composant « jour ».The "h" custom format specifier outputs the value of the TimeSpan.Hours property, which represents the number of whole hours in the time interval that is not counted as part of its day component. Elle retourne une valeur de chaîne d’un chiffre si la valeur de la TimeSpan.Hours propriété est 0 à 9, et retourne une valeur de chaîne à deux chiffres si la valeur de la TimeSpan.Hours propriété est comprise entre 10 et 23.It returns a one-digit string value if the value of the TimeSpan.Hours property is 0 through 9, and it returns a two-digit string value if the value of the TimeSpan.Hours property ranges from 10 to 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.If the "h" custom format specifier is used alone, specify "%h" so that it is not misinterpreted as a standard format string. L'exemple suivant illustre cette situation.The following example provides an illustration.

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
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 ne contient qu’un seul nombre est interprétée comme le nombre de jours.Ordinarily, in a parsing operation, an input string that includes only a single number is interpreted as the number of days. Vous pouvez utiliser le spécificateur de format personnalisé "%h" à la place pour interpréter la chaîne numérique comme nombre d’heures.You can use the "%h" custom format specifier instead to interpret the numeric string as the number of hours. L'exemple suivant illustre cette situation.The following example provides an illustration.

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                              
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".The following example illustrates the use of the "h" custom format specifier.

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 tableauBack to table

Spécificateur de format personnalisé "hh"The "hh" Custom Format Specifier

Le spécificateur de format personnalisé « hh » affiche la valeur de la TimeSpan.Hours propriété, qui représente le nombre d’heures entières de l’intervalle de temps qui n’est pas compté dans le cadre du composant « jour ».The "hh" custom format specifier outputs the value of the TimeSpan.Hours property, which represents the number of whole hours in the time interval that is not counted as part of its day component. Pour les valeurs 0 à 9, la chaîne de sortie inclut un zéro non significatif.For values from 0 through 9, the output string includes a leading zero.

En règle générale, dans une opération d’analyse, une chaîne d’entrée qui ne contient qu’un seul nombre est interprétée comme le nombre de jours.Ordinarily, in a parsing operation, an input string that includes only a single number is interpreted as the number of days. Vous pouvez utiliser le spécificateur de format personnalisé "hh" à la place pour interpréter la chaîne numérique comme nombre d’heures.You can use the "hh" custom format specifier instead to interpret the numeric string as the number of hours. L'exemple suivant illustre cette situation.The following example provides an illustration.

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                              
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".The following example illustrates the use of the "hh" custom format specifier.

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 tableauBack to table

Spécificateur de format personnalisé "m"The "m" Custom Format Specifier

Le spécificateur de format personnalisé « m » affiche la valeur de la TimeSpan.Minutes propriété, qui représente le nombre de minutes entières dans l’intervalle de temps qui n’est pas compté dans le cadre du composant « jour ».The "m" custom format specifier outputs the value of the TimeSpan.Minutes property, which represents the number of whole minutes in the time interval that is not counted as part of its day component. Elle retourne une valeur de chaîne d’un chiffre si la valeur de la TimeSpan.Minutes propriété est 0 à 9, et retourne une valeur de chaîne à deux chiffres si la valeur de la TimeSpan.Minutes propriété est comprise entre 10 et 59.It returns a one-digit string value if the value of the TimeSpan.Minutes property is 0 through 9, and it returns a two-digit string value if the value of the TimeSpan.Minutes property ranges from 10 to 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.If the "m" custom format specifier is used alone, specify "%m" so that it is not misinterpreted as a standard format string. L'exemple suivant illustre cette situation.The following example provides an illustration.

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
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 ne contient qu’un seul nombre est interprétée comme le nombre de jours.Ordinarily, in a parsing operation, an input string that includes only a single number is interpreted as the number of days. Vous pouvez utiliser le spécificateur de format personnalisé "%m" à la place pour interpréter la chaîne numérique comme nombre de minutes.You can use the "%m" custom format specifier instead to interpret the numeric string as the number of minutes. L'exemple suivant illustre cette situation.The following example provides an illustration.

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                              
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".The following example illustrates the use of the "m" custom format specifier.

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
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 tableauBack to table

Spécificateur de format personnalisé "mm"The "mm" Custom Format Specifier

Le spécificateur de format personnalisé « mm » affiche la valeur de la TimeSpan.Minutes propriété, qui représente le nombre de minutes entières dans l’intervalle de temps qui n’est pas inclus dans le cadre de son composant heures ou jours.The "mm" custom format specifier outputs the value of the TimeSpan.Minutes property, which represents the number of whole minutes in the time interval that is not included as part of its hours or days component. Pour les valeurs 0 à 9, la chaîne de sortie inclut un zéro non significatif.For values from 0 through 9, the output string includes a leading zero.

En règle générale, dans une opération d’analyse, une chaîne d’entrée qui ne contient qu’un seul nombre est interprétée comme le nombre de jours.Ordinarily, in a parsing operation, an input string that includes only a single number is interpreted as the number of days. Vous pouvez utiliser le spécificateur de format personnalisé "mm" à la place pour interpréter la chaîne numérique comme nombre de minutes.You can use the "mm" custom format specifier instead to interpret the numeric string as the number of minutes. L'exemple suivant illustre cette situation.The following example provides an illustration.

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                              
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".The following example illustrates the use of the "mm" custom format specifier.

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      
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 tableauBack to table

Spécificateur de format personnalisé "s"The "s" Custom Format Specifier

Le spécificateur de format personnalisé « s » affiche la valeur de la TimeSpan.Seconds propriété, qui représente le nombre de secondes entières de l’intervalle de temps qui n’est pas inclus dans le cadre de ses heures, jours ou composant des minutes.The "s" custom format specifier outputs the value of the TimeSpan.Seconds property, which represents the number of whole seconds in the time interval that is not included as part of its hours, days, or minutes component. Elle retourne une valeur de chaîne d’un chiffre si la valeur de la TimeSpan.Seconds propriété est 0 à 9, et retourne une valeur de chaîne à deux chiffres si la valeur de la TimeSpan.Seconds propriété est comprise entre 10 et 59.It returns a one-digit string value if the value of the TimeSpan.Seconds property is 0 through 9, and it returns a two-digit string value if the value of the TimeSpan.Seconds property ranges from 10 to 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.If the "s" custom format specifier is used alone, specify "%s" so that it is not misinterpreted as a standard format string. L'exemple suivant illustre cette situation.The following example provides an illustration.

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 ne contient qu’un seul nombre est interprétée comme le nombre de jours.Ordinarily, in a parsing operation, an input string that includes only a single number is interpreted as the number of days. Vous pouvez utiliser le spécificateur de format personnalisé "%s" à la place pour interpréter la chaîne numérique comme nombre de secondes.You can use the "%s" custom format specifier instead to interpret the numeric string as the number of seconds. L'exemple suivant illustre cette situation.The following example provides an illustration.

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
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".The following example illustrates the use of the "s" custom format specifier.

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 tableauBack to table

Spécificateur de format personnalisé "ss"The "ss" Custom Format Specifier

Le spécificateur de format personnalisé « ss » affiche la valeur de la TimeSpan.Seconds propriété, qui représente le nombre de secondes entières de l’intervalle de temps qui n’est pas inclus dans le cadre de ses heures, jours ou composant des minutes.The "ss" custom format specifier outputs the value of the TimeSpan.Seconds property, which represents the number of whole seconds in the time interval that is not included as part of its hours, days, or minutes component. Pour les valeurs 0 à 9, la chaîne de sortie inclut un zéro non significatif.For values from 0 through 9, the output string includes a leading zero.

En règle générale, dans une opération d’analyse, une chaîne d’entrée qui ne contient qu’un seul nombre est interprétée comme le nombre de jours.Ordinarily, in a parsing operation, an input string that includes only a single number is interpreted as the number of days. Vous pouvez utiliser le spécificateur de format personnalisé "ss" à la place pour interpréter la chaîne numérique comme nombre de secondes.You can use the "ss" custom format specifier instead to interpret the numeric string as the number of seconds. L'exemple suivant illustre cette situation.The following example provides an illustration.

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
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".The following example illustrates the use of the "ss" custom format specifier.

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 tableauBack to table

Le spécificateur de Format personnalisé « f »The"f" Custom Format Specifier

Le spécificateur de format personnalisé "f" affiche les dixièmes de seconde dans un intervalle de temps.The "f" custom format specifier outputs the tenths of a second in a time interval. Dans une opération de mise en forme, tous les chiffres fractionnaires restants sont tronqués.In a formatting operation, any remaining fractional digits are truncated. Dans une opération d’analyse qui appelle la TimeSpan.ParseExact ou TimeSpan.TryParseExact (méthode), la chaîne d’entrée doit contenir exactement un chiffre de fractions de seconde.In a parsing operation that calls the TimeSpan.ParseExact or TimeSpan.TryParseExact method, the input string must contain exactly one fractional digit.

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.If the "f" custom format specifier is used alone, specify "%f" so that it is not misinterpreted as a standard format string.

L’exemple suivant utilise le spécificateur de format personnalisé « f » pour afficher les dixièmes de seconde dans une TimeSpan valeur.The following example uses the "f" custom format specifier to display the tenths of a second in a TimeSpan value. "f" est d’abord utilisé seul comme spécificateur de format, puis est combiné avec le spécificateur "s" dans une chaîne de format personnalisée."f" is used first as the only format specifier, and then combined with the "s" specifier in a custom format string.

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      
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 tableauBack to table

Spécificateur de format personnalisé "ff"The "ff" Custom Format Specifier

Le spécificateur de format personnalisé "ff" affiche les centièmes de seconde dans un intervalle de temps.The "ff" custom format specifier outputs the hundredths of a second in a time interval. Dans une opération de mise en forme, tous les chiffres fractionnaires restants sont tronqués.In a formatting operation, any remaining fractional digits are truncated. Dans une opération d’analyse qui appelle la TimeSpan.ParseExact ou TimeSpan.TryParseExact (méthode), la chaîne d’entrée doit contenir exactement deux chiffres fractionnaires.In a parsing operation that calls the TimeSpan.ParseExact or TimeSpan.TryParseExact method, the input string must contain exactly two fractional digits.

L’exemple suivant utilise le spécificateur de format personnalisé « ff » pour afficher les centièmes de seconde dans une TimeSpan valeur.The following example uses the "ff" custom format specifier to display the hundredths of a second in a TimeSpan value. "ff" est d’abord utilisé seul comme spécificateur de format, puis est combiné avec le spécificateur "s" dans une chaîne de format personnalisée."ff" is used first as the only format specifier, and then combined with the "s" specifier in a custom format string.

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      
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 tableauBack to table

Spécificateur de format personnalisé "fff"The "fff" Custom Format Specifier

Le spécificateur de format personnalisé "fff" (trois caractères « f ») affiche les millisecondes dans un intervalle de temps.The "fff" custom format specifier (with three "f" characters) outputs the milliseconds in a time interval. Dans une opération de mise en forme, tous les chiffres fractionnaires restants sont tronqués.In a formatting operation, any remaining fractional digits are truncated. Dans une opération d’analyse qui appelle la TimeSpan.ParseExact ou TimeSpan.TryParseExact (méthode), la chaîne d’entrée doit contenir exactement trois chiffres fractionnaires.In a parsing operation that calls the TimeSpan.ParseExact or TimeSpan.TryParseExact method, the input string must contain exactly three fractional digits.

L’exemple suivant utilise le spécificateur de format personnalisé « fff » pour afficher les millisecondes dans une TimeSpan valeur.The following example uses the "fff" custom format specifier to display the milliseconds in a TimeSpan value. "fff" est d’abord utilisé seul comme spécificateur de format, puis est combiné avec le spécificateur "s" dans une chaîne de format personnalisée."fff" is used first as the only format specifier, and then combined with the "s" specifier in a custom format string.

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      
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 tableauBack to table

Spécificateur de format personnalisé "ffff"The "ffff" Custom Format Specifier

Le spécificateur de format personnalisé "ffff" (quatre caractères « f ») affiche les dix millièmes de seconde dans un intervalle de temps.The "ffff" custom format specifier (with four "f" characters) outputs the ten-thousandths of a second in a time interval. Dans une opération de mise en forme, tous les chiffres fractionnaires restants sont tronqués.In a formatting operation, any remaining fractional digits are truncated. Dans une opération d’analyse qui appelle la TimeSpan.ParseExact ou TimeSpan.TryParseExact (méthode), la chaîne d’entrée doit contenir exactement quatre chiffres fractionnaires.In a parsing operation that calls the TimeSpan.ParseExact or TimeSpan.TryParseExact method, the input string must contain exactly four fractional digits.

L’exemple suivant utilise le spécificateur de format personnalisé « ffff » pour afficher les dix-millièmes de seconde dans une TimeSpan valeur.The following example uses the "ffff" custom format specifier to display the ten-thousandths of a second in a TimeSpan value. "ffff" est d’abord utilisé seul comme spécificateur de format, puis est combiné avec le spécificateur "s" dans une chaîne de format personnalisée."ffff" is used first as the only format specifier, and then combined with the "s" specifier in a custom format string.

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      
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 tableauBack to table

Spécificateur de format personnalisé "fffff"The "fffff" Custom Format Specifier

Le spécificateur de format personnalisé "fffff" (cinq caractères « f ») affiche les cent millièmes de seconde dans un intervalle de temps.The "fffff" custom format specifier (with five "f" characters) outputs the hundred-thousandths of a second in a time interval. Dans une opération de mise en forme, tous les chiffres fractionnaires restants sont tronqués.In a formatting operation, any remaining fractional digits are truncated. Dans une opération d’analyse qui appelle la TimeSpan.ParseExact ou TimeSpan.TryParseExact (méthode), la chaîne d’entrée doit contenir exactement cinq chiffres fractionnaires.In a parsing operation that calls the TimeSpan.ParseExact or TimeSpan.TryParseExact method, the input string must contain exactly five fractional digits.

L’exemple suivant utilise le spécificateur de format personnalisé « fffff » pour afficher les cent millièmes de seconde dans une TimeSpan valeur.The following example uses the "fffff" custom format specifier to display the hundred-thousandths of a second in a TimeSpan value. "fffff" est d’abord utilisé seul comme spécificateur de format, puis est combiné avec le spécificateur "s" dans une chaîne de format personnalisée."fffff" is used first as the only format specifier, and then combined with the "s" specifier in a custom format string.

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      
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 tableauBack to table

Spécificateur de format personnalisé "ffffff"The "ffffff" Custom Format Specifier

Le spécificateur de format personnalisé "ffffff" (six caractères « f ») affiche les millionièmes de seconde dans un intervalle de temps.The "ffffff" custom format specifier (with six "f" characters) outputs the millionths of a second in a time interval. Dans une opération de mise en forme, tous les chiffres fractionnaires restants sont tronqués.In a formatting operation, any remaining fractional digits are truncated. Dans une opération d’analyse qui appelle la TimeSpan.ParseExact ou TimeSpan.TryParseExact (méthode), la chaîne d’entrée doit contenir exactement six chiffres fractionnaires.In a parsing operation that calls the TimeSpan.ParseExact or TimeSpan.TryParseExact method, the input string must contain exactly six fractional digits.

L’exemple suivant utilise le spécificateur de format personnalisé « ffffff » pour afficher les millionièmes de seconde dans une TimeSpan valeur.The following example uses the "ffffff" custom format specifier to display the millionths of a second in a TimeSpan value. Il est d’abord utilisé seul comme spécificateur de format, puis est combiné avec le spécificateur "s" dans une chaîne de format personnalisée.It is used first as the only format specifier, and then combined with the "s" specifier in a custom format string.

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      
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 tableauBack to table

Spécificateur de format personnalisé "fffffff"The "fffffff" Custom Format Specifier

Le spécificateur de format personnalisé "fffffff" (sept caractères « f ») affiche les dix millionièmes de seconde (ou le nombre fractionnaire de graduations) dans un intervalle de temps.The "fffffff" custom format specifier (with seven "f" characters) outputs the ten-millionths of a second (or the fractional number of ticks) in a time interval. Dans une opération d’analyse qui appelle la TimeSpan.ParseExact ou TimeSpan.TryParseExact (méthode), la chaîne d’entrée doit contenir exactement sept chiffres fractionnaires.In a parsing operation that calls the TimeSpan.ParseExact or TimeSpan.TryParseExact method, the input string must contain exactly seven fractional digits.

L’exemple suivant utilise le spécificateur de format personnalisé « fffffff » pour afficher le nombre de fractions de seconde de graduations dans un TimeSpan valeur.The following example uses the "fffffff" custom format specifier to display the fractional number of ticks in a TimeSpan value. Il est d’abord utilisé seul comme spécificateur de format, puis est combiné avec le spécificateur "s" dans une chaîne de format personnalisée.It is used first as the only format specifier, and then combined with the "s" specifier in a custom format string.

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      
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 tableauBack to table

Spécificateur de format personnalisé "F"The "F" Custom Format Specifier

Le spécificateur de format personnalisé "F" affiche les dixièmes de seconde dans un intervalle de temps.The "F" custom format specifier outputs the tenths of a second in a time interval. Dans une opération de mise en forme, tous les chiffres fractionnaires restants sont tronqués.In a formatting operation, any remaining fractional digits are truncated. Si la valeur des dixièmes de seconde de l’intervalle de temps est égale à zéro, elle n’est pas incluse dans la chaîne de résultat.If the value of the time interval's tenths of a second is zero, it is not included in the result string. Dans une opération d’analyse qui appelle la TimeSpan.ParseExact ou TimeSpan.TryParseExact (méthode), la présence de dixièmes de seconde est facultative.In a parsing operation that calls the TimeSpan.ParseExact or TimeSpan.TryParseExact method, the presence of the tenths of a second digit is optional.

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.If the "F" custom format specifier is used alone, specify "%F" so that it is not misinterpreted as a standard format string.

L’exemple suivant utilise le spécificateur de format personnalisé « F » pour afficher les dixièmes de seconde dans une TimeSpan valeur.The following example uses the "F" custom format specifier to display the tenths of a second in a TimeSpan value. Il utilise également ce spécificateur de format personnalisé dans une opération d’analyse.It also uses this custom format specifier in a parsing operation.

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'.      
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 tableauBack to table

Spécificateur de format personnalisé "FF"The "FF" Custom Format Specifier

Le spécificateur de format personnalisé "FF" affiche les centièmes de seconde dans un intervalle de temps.The "FF" custom format specifier outputs the hundredths of a second in a time interval. Dans une opération de mise en forme, tous les chiffres fractionnaires restants sont tronqués.In a formatting operation, any remaining fractional digits are truncated. Les zéros de fin fractionnaires éventuels ne sont pas inclus dans la chaîne de résultat.If there are any trailing fractional zeros, they are not included in the result string. Dans une opération d’analyse qui appelle la TimeSpan.ParseExact ou TimeSpan.TryParseExact (méthode), la présence de dixièmes et des centièmes de seconde sont facultatives.In a parsing operation that calls the TimeSpan.ParseExact or TimeSpan.TryParseExact method, the presence of the tenths and hundredths of a second digit is optional.

L’exemple suivant utilise le spécificateur de format personnalisé « FF » pour afficher les centièmes de seconde dans une TimeSpan valeur.The following example uses the "FF" custom format specifier to display the hundredths of a second in a TimeSpan value. Il utilise également ce spécificateur de format personnalisé dans une opération d’analyse.It also uses this custom format specifier in a parsing operation.

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'.      
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 tableauBack to table

Spécificateur de format personnalisé "FFF"The "FFF" Custom Format Specifier

Le spécificateur de format personnalisé "FFF" (trois caractères « F ») affiche les millisecondes dans un intervalle de temps.The "FFF" custom format specifier (with three "F" characters) outputs the milliseconds in a time interval. Dans une opération de mise en forme, tous les chiffres fractionnaires restants sont tronqués.In a formatting operation, any remaining fractional digits are truncated. Les zéros de fin fractionnaires éventuels ne sont pas inclus dans la chaîne de résultat.If there are any trailing fractional zeros, they are not included in the result string. Dans une opération d’analyse qui appelle la TimeSpan.ParseExact ou TimeSpan.TryParseExact (méthode), la présence des dixièmes, centièmes, millièmes de seconde est facultative.In a parsing operation that calls the TimeSpan.ParseExact or TimeSpan.TryParseExact method, the presence of the tenths, hundredths, and thousandths of a second digit is optional.

L’exemple suivant utilise le spécificateur de format personnalisé « FFF » pour afficher les millièmes de seconde dans une TimeSpan valeur.The following example uses the "FFF" custom format specifier to display the thousandths of a second in a TimeSpan value. Il utilise également ce spécificateur de format personnalisé dans une opération d’analyse.It also uses this custom format specifier in a parsing operation.

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'.      
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 tableauBack to table

Spécificateur de format personnalisé "FFFF"The "FFFF" Custom Format Specifier

Le spécificateur de format personnalisé "FFFF" (quatre caractères « F ») affiche les dix millièmes de seconde dans un intervalle de temps.The "FFFF" custom format specifier (with four "F" characters) outputs the ten-thousandths of a second in a time interval. Dans une opération de mise en forme, tous les chiffres fractionnaires restants sont tronqués.In a formatting operation, any remaining fractional digits are truncated. Les zéros de fin fractionnaires éventuels ne sont pas inclus dans la chaîne de résultat.If there are any trailing fractional zeros, they are not included in the result string. Dans une opération d’analyse qui appelle la TimeSpan.ParseExact ou TimeSpan.TryParseExact (méthode), la présence de dixièmes, centièmes, millièmes, les dix millièmes de seconde est facultative.In a parsing operation that calls the TimeSpan.ParseExact or TimeSpan.TryParseExact method, the presence of the tenths, hundredths, thousandths, and ten-thousandths of a second digit is optional.

L’exemple suivant utilise le spécificateur de format personnalisé « FFFF » pour afficher les dix-millièmes de seconde dans une TimeSpan valeur.The following example uses the "FFFF" custom format specifier to display the ten-thousandths of a second in a TimeSpan value. Il utilise également le spécificateur de format personnalisé "FFFF" dans une opération d’analyse.It also uses the "FFFF" custom format specifier in a parsing operation.

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'.
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 tableauBack to table

Spécificateur de format personnalisé "FFFFF"The "FFFFF" Custom Format Specifier

Le spécificateur de format personnalisé "FFFFF" (cinq caractères « F ») affiche les cent millièmes de seconde dans un intervalle de temps.The "FFFFF" custom format specifier (with five "F" characters) outputs the hundred-thousandths of a second in a time interval. Dans une opération de mise en forme, tous les chiffres fractionnaires restants sont tronqués.In a formatting operation, any remaining fractional digits are truncated. Les zéros de fin fractionnaires éventuels ne sont pas inclus dans la chaîne de résultat.If there are any trailing fractional zeros, they are not included in the result string. Dans une opération d’analyse qui appelle la TimeSpan.ParseExact ou TimeSpan.TryParseExact (méthode), la présence de dixièmes, centièmes, millièmes, dix-millièmes, les cent millièmes de seconde est facultative.In a parsing operation that calls the TimeSpan.ParseExact or TimeSpan.TryParseExact method, the presence of the tenths, hundredths, thousandths, ten-thousandths, and hundred-thousandths of a second digit is optional.

L’exemple suivant utilise le spécificateur de format personnalisé « FFFFF » pour afficher les cent millièmes de seconde dans une TimeSpan valeur.The following example uses the "FFFFF" custom format specifier to display the hundred-thousandths of a second in a TimeSpan value. Il utilise également le spécificateur de format personnalisé "FFFFF" dans une opération d’analyse.It also uses the "FFFFF" custom format specifier in a parsing operation.

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'.      
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 tableauBack to table

Spécificateur de format personnalisé "FFFFFF"The "FFFFFF" Custom Format Specifier

Le spécificateur de format personnalisé "FFFFFF" (six caractères « F ») affiche les millionièmes de seconde dans un intervalle de temps.The "FFFFFF" custom format specifier (with six "F" characters) outputs the millionths of a second in a time interval. Dans une opération de mise en forme, tous les chiffres fractionnaires restants sont tronqués.In a formatting operation, any remaining fractional digits are truncated. Les zéros de fin fractionnaires éventuels ne sont pas inclus dans la chaîne de résultat.If there are any trailing fractional zeros, they are not included in the result string. Dans une opération d’analyse qui appelle la TimeSpan.ParseExact ou TimeSpan.TryParseExact (méthode), la présence de dixièmes, centièmes, millièmes, dix-millièmes, cent millièmes et les millionièmes de seconde est facultative.In a parsing operation that calls the TimeSpan.ParseExact or TimeSpan.TryParseExact method, the presence of the tenths, hundredths, thousandths, ten-thousandths, hundred-thousandths, and millionths of a second digit is optional.

L’exemple suivant utilise le spécificateur de format personnalisé « FFFFFF » pour afficher les millionièmes de seconde dans une TimeSpan valeur.The following example uses the "FFFFFF" custom format specifier to display the millionths of a second in a TimeSpan value. Il utilise également ce spécificateur de format personnalisé dans une opération d’analyse.It also uses this custom format specifier in a parsing operation.

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'.      
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 tableauBack to table

Spécificateur de format personnalisé "FFFFFFF"The "FFFFFFF" Custom Format Specifier

Le spécificateur de format personnalisé "FFFFFFF" (sept caractères « F ») affiche les dix millionièmes de seconde (ou le nombre fractionnaire de graduations) dans un intervalle de temps.The "FFFFFFF" custom format specifier (with seven "F" characters) outputs the ten-millionths of a second (or the fractional number of ticks) in a time interval. Les zéros de fin fractionnaires éventuels ne sont pas inclus dans la chaîne de résultat.If there are any trailing fractional zeros, they are not included in the result string. Dans une opération d’analyse qui appelle la TimeSpan.ParseExact ou TimeSpan.TryParseExact (méthode), la présence des sept chiffres fractionnaires dans la chaîne d’entrée est facultative.In a parsing operation that calls the TimeSpan.ParseExact or TimeSpan.TryParseExact method, the presence of the seven fractional digits in the input string is optional.

L’exemple suivant utilise le spécificateur de format personnalisé « FFFFFFF » pour afficher les parties de fractions de seconde dans une TimeSpan valeur.The following example uses the "FFFFFFF" custom format specifier to display the fractional parts of a second in a TimeSpan value. Il utilise également ce spécificateur de format personnalisé dans une opération d’analyse.It also uses this custom format specifier in a parsing operation.

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      
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 tableauBack to table

Autres caractèresOther Characters

Tout autre caractère sans séquence d’échappement dans une chaîne de format, y compris un espace blanc, est interprété comme un spécificateur de format personnalisé.Any other unescaped character in a format string, including a white-space character, is interpreted as a custom format specifier. Dans la plupart des cas, la présence d’un autre sans séquence d’échappement les résultats de caractère dans un FormatException.In most cases, the presence of any other unescaped character results in a FormatException.

Vous pouvez inclure un caractère littéral dans une chaîne de format de deux façons :There are two ways to include a literal character in a format string:

  • Mettez-le entre guillemets simples (délimiteur de chaîne littérale).Enclose it in single quotation marks (the literal string delimiter).

  • Faire précéder d’une barre oblique inverse («\»), qui est interprété comme un caractère d’échappement.Precede it with a backslash ("\"), which is interpreted as an escape character. Cela signifie que, en C#, soit la chaîne de format doit être @-quoted, puis placée entre guillemets, soit le caractère littéral doit être précédé d’une barre oblique inverse supplémentaire.This means that, in C#, the format string must either be @-quoted, or the literal character must be preceded by an additional backslash.

    Dans certains cas, vous devrez peut-être utiliser une logique conditionnelle pour inclure un littéral avec séquence d’échappement dans une chaîne de format.In some cases, you may have to use conditional logic to include an escaped literal in a format string. L’exemple suivant utilise une logique conditionnelle pour inclure un symbole de signe pour les intervalles de temps négatifs.The following example uses conditional logic to include a sign symbol for negative time intervals.

    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
    
    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..NET does not define a grammar for separators in time intervals. Cela signifie que les séparateurs entre les jours et les heures, entre les heures et les minutes, entre les minutes et les secondes et entre les secondes et les fractions de seconde doivent tous être traités comme des littéraux de caractère dans une chaîne de format.This means that the separators between days and hours, hours and minutes, minutes and seconds, and seconds and fractions of a second must all be treated as character literals in a format string.

L’exemple suivant utilise le caractère d’échappement et le guillemet simple pour définir une chaîne de format personnalisée qui inclut le mot « minutes » dans la chaîne de sortie.The following example uses both the escape character and the single quote to define a custom format string that includes the word "minutes" in the output string.

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 tableauBack to table

Voir aussiSee Also

Mise en forme des typesFormatting Types
Chaînes de format TimeSpan standardStandard TimeSpan Format Strings