Stringhe in formato TimeSpan personalizzatoCustom TimeSpan format strings

Una stringa in formato TimeSpan definisce la rappresentazione di stringa di un valore TimeSpan risultante da un'operazione di formattazione.A TimeSpan format string defines the string representation of a TimeSpan value that results from a formatting operation. Una stringa in formato personalizzato è costituita da uno o più identificatori in formato TimeSpan personalizzato con un numero qualsiasi di caratteri di tipo letterale.A custom format string consists of one or more custom TimeSpan format specifiers along with any number of literal characters. Qualsiasi stringa in un formato diverso da TimeSpan standard viene interpretata come stringa in formato TimeSpan personalizzato.Any string that isn't a standard TimeSpan format string is interpreted as a custom TimeSpan format string.

Importante

Gli identificatori di formato TimeSpan personalizzati non includono i simboli separatori dei segnaposto, ad esempio i simboli che separano i giorni dalle ore, le ore dai minuti o i secondi dalle frazioni di secondo.The custom TimeSpan format specifiers don't include placeholder separator symbols, such as the symbols that separate days from hours, hours from minutes, or seconds from fractional seconds. Questi simboli devono essere inclusi nella stringa di formato personalizzato come valori letterali stringa.Instead, these symbols must be included in the custom format string as string literals. Ad esempio, in "dd\.hh\:mm" il punto (.) è definito come separatore tra giorni e ore e i due punti (:) come separatore tra ore e minuti.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.

Inoltre, negli identificatori di formato TimeSpan personalizzati non è incluso un segno che consente di distinguere tra intervalli di tempo negativi e positivi.Custom TimeSpan format specifiers also don't include a sign symbol that enables you to differentiate between negative and positive time intervals. Per includere un simbolo di segno, è necessario creare una stringa di formato tramite la logica condizionale.To include a sign symbol, you have to construct a format string by using conditional logic. Nella sezione Altri caratteri è incluso un esempio.The Other characters section includes an example.

Le rappresentazione di stringa dei valori TimeSpan vengono prodotte da chiamate agli overload del metodo TimeSpan.ToString e dai metodi che supportano la formattazione composita, come 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. Per altre informazioni, vedere Formattazione di tipi e Formattazione composita.For more information, see Formatting Types and Composite Formatting. Nell'esempio seguente viene illustrato l'uso di stringhe in formato personalizzato nelle operazioni di formattazione.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

Le stringhe in formato TimeSpan personalizzato sono usate anche dai metodi TimeSpan.ParseExact e TimeSpan.TryParseExact per definire il formato richiesto delle stringhe di input per le operazioni di analisiCustom 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'analisi converte la rappresentazione di stringa di un valore in tale valore). Nell'esempio seguente viene illustrato l'utilizzo di stringhe di formato standard nelle operazioni di analisi.(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

La tabella seguente descrive gli identificatori di formato di data e ora personalizzati.The following table describes the custom date and time format specifiers.

Identificatore di formatoFormat specifier DescrizioneDescription EsempioExample
"d", "%d""d", "%d" Il numero di giorni completi nell'intervallo di tempo.The number of whole days in the time interval.

Ulteriori informazioni: identificatore di formato personalizzato "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" Il numero di giorni completi nell'intervallo di tempo, con il numero di zeri necessari all'inizio.The number of whole days in the time interval, padded with leading zeros as needed.

Ulteriori informazioni: identificatori di formato personalizzato "dd"-"dddddddd".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" Il numero di ore complete nell'intervallo di tempo non conteggiate come parti di giorni.The number of whole hours in the time interval that aren't counted as part of days. Le ore a una sola cifra non hanno uno zero iniziale.Single-digit hours don't have a leading zero.

Altre informazioni: identificatore di formato personalizzato "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" Il numero di ore complete nell'intervallo di tempo non conteggiate come parti di giorni.The number of whole hours in the time interval that aren't counted as part of days. Le ore a una sola cifra hanno uno zero iniziale.Single-digit hours have a leading zero.

Ulteriori informazioni: identificatore di formato personalizzato "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" Il numero di minuti completi nell'intervallo di tempo non conteggiati come parti di ore o di giorni.The number of whole minutes in the time interval that aren't included as part of hours or days. I minuti a una sola cifra non hanno uno zero iniziale.Single-digit minutes don't have a leading zero.

Altre informazioni: identificatore di formato personalizzato "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" Il numero di minuti completi nell'intervallo di tempo non conteggiati come parti di ore o di giorni.The number of whole minutes in the time interval that aren't included as part of hours or days. I minuti a una sola cifra hanno uno zero iniziale.Single-digit minutes have a leading zero.

Altre informazioni: identificatore di formato personalizzato "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" Il numero di secondi completi nell'intervallo di tempo non conteggiati come parti di minuti, ore o giorni.The number of whole seconds in the time interval that aren't included as part of hours, days, or minutes. I secondi a una sola cifra non hanno uno zero iniziale.Single-digit seconds don't have a leading zero.

Ulteriori informazioni: identificatore di formato personalizzato "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" Il numero di secondi completi nell'intervallo di tempo non conteggiati come parti di minuti, ore o giorni.The number of whole seconds in the time interval that aren't included as part of hours, days, or minutes. I secondi a una sola cifra hanno uno zero iniziale.Single-digit seconds have a leading zero.

Altre informazioni: identificatore di formato personalizzato "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" I decimi di secondo in un intervallo di tempo.The tenths of a second in a time interval.

Ulteriori informazioni: identificatore di formato personalizzato "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" I centesimi di secondo in un intervallo di tempo.The hundredths of a second in a time interval.

Altre informazioni: identificatore di formato personalizzato "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" I millisecondi in un intervallo di tempo.The milliseconds in a time interval.

Altre informazioni: identificatore di formato personalizzato "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" I decimillesimi di secondo in un intervallo di tempo.The ten-thousandths of a second in a time interval.

Altre informazioni: identificatore di formato personalizzato "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" I centesimi di millesimo di secondo in un intervallo di tempo.The hundred-thousandths of a second in a time interval.

Ulteriori informazioni: identificatore di formato personalizzato "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" I milionesimi di secondo in un intervallo di tempo.The millionths of a second in a time interval.

Ulteriori informazioni: identificatore di formato personalizzato "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" I decimilionesimi di secondo (o il numero frazionario di tick) in un intervallo di tempo.The ten-millionths of a second (or the fractional ticks) in a time interval.

Ulteriori informazioni: identificatore di formato personalizzato "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" I decimi di secondo in un intervallo di tempo.The tenths of a second in a time interval. Se la cifra è zero, non viene prodotta alcuna visualizzazione.Nothing is displayed if the digit is zero.

Ulteriori informazioni: identificatore di formato personalizzato "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" I centesimi di secondo in un intervallo di tempo.The hundredths of a second in a time interval. Eventuali zeri finali frazionari o doppi zeri non sono inclusi.Any fractional trailing zeros or two zero digits aren't included.

Altre informazioni: identificatore di formato personalizzato "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" I millisecondi in un intervallo di tempo.The milliseconds in a time interval. Eventuali zeri finali frazionari non sono inclusi.Any fractional trailing zeros aren't included.

Altre informazioni: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" I decimillesimi di secondo in un intervallo di tempo.The ten-thousandths of a second in a time interval. Eventuali zeri finali frazionari non sono inclusi.Any fractional trailing zeros aren't included.

Altre informazioni: identificatore di formato personalizzato "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" I centesimi di millesimo di secondo in un intervallo di tempo.The hundred-thousandths of a second in a time interval. Eventuali zeri finali frazionari non sono inclusi.Any fractional trailing zeros aren't included.

Ulteriori informazioni: identificatore di formato personalizzato "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" I milionesimi di secondo in un intervallo di tempo.The millionths of a second in a time interval. Eventuali zeri finali frazionari non sono visualizzati.Any fractional trailing zeros aren't displayed.

Ulteriori informazioni: identificatore di formato personalizzato "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" I decimilionesimi di secondo in un intervallo di tempo.The ten-millions of a second in a time interval. Eventuali zeri finali frazionari o gruppi di sette zeri non sono visualizzati.Any fractional trailing zeros or seven zeros aren't displayed.

Ulteriori informazioni: identificatore di formato personalizzato "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
'string''string' Delimitatore di stringa letterale.Literal string delimiter.

Altre informazioni: altri caratteri.More information: Other characters.
new TimeSpan(14, 32, 17):

hh':'mm':'ss --> "14:32:17"hh':'mm':'ss --> "14:32:17"
\\ Carattere di escape.The escape character.

Altre informazioni: altri caratteri.More information: Other characters.
new TimeSpan(14, 32, 17):

hh\:mm\:ss --> "14:32:17"hh\:mm\:ss --> "14:32:17"
Qualsiasi altro carattereAny other character Qualsiasi altro carattere senza escape viene interpretato come identificatore di formato personalizzato.Any other unescaped character is interpreted as a custom format specifier.

Altre informazioni: altri caratteri.More Information: Other characters.
new TimeSpan(14, 32, 17):

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

Identificatore di formato personalizzato "d"The "d" custom format specifier

L'identificatore di formato personalizzato "d" restituisce il valore della proprietà TimeSpan.Days, che rappresenta il numero di giorni completi nell'intervallo di tempo.The "d" custom format specifier outputs the value of the TimeSpan.Days property, which represents the number of whole days in the time interval. Restituisce il numero completo di giorni di un valore TimeSpan, anche se il valore ha più di una cifra.It outputs the full number of days in a TimeSpan value, even if the value has more than one digit. Se il valore della proprietà TimeSpan.Days è zero, l'identificatore restituisce "0".If the value of the TimeSpan.Days property is zero, the specifier outputs "0".

Se l'identificatore di formato personalizzato "d" viene usato da solo, specificare "%d" in modo che non venga interpretato erroneamente come stringa in formato standard.If the "d" custom format specifier is used alone, specify "%d" so that it isn't misinterpreted as a standard format string. Nell'esempio seguente viene illustrato questo concetto.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   

Nell'esempio seguente viene illustrato l'uso dell'identificatore di formato personalizzato "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      

Torna alla tabellaBack to table

Identificatori di formato personalizzati "dd"-"dddddddd"The "dd"-"dddddddd" custom format specifiers

Gli identificatori di formato personalizzato "dd", "ddd", "dddd", "ddddd", "dddddd", "ddddddd" e "dddddddd" restituiscono il valore della proprietà TimeSpan.Days, che rappresenta il numero di giorni completi nell'intervallo di tempo.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 stringa di output include un numero minimo di cifre specificato dal numero di caratteri "d" nell'identificatore di formato e il numero necessario di zeri iniziali.The output string includes a minimum number of digits specified by the number of "d" characters in the format specifier, and it's padded with leading zeros as needed. Se le cifre del numero di giorni superano il numero di caratteri "d"nell'identificatore di formato, l'output nella stringa risultato corrisponde al numero completo di giorni.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'esempio seguente usa gli identificatori di formato per visualizzare la rappresentazione stringa di due valori TimeSpan.The following example uses these format specifiers to display the string representation of two TimeSpan values. Il valore del componente giorni del primo intervallo di tempo è zero, mentre il valore del componente dei giorni del secondo è 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      

Torna alla tabellaBack to table

Identificatore di formato personalizzato "h"The "h" custom format specifier

L'identificatore di formato personalizzato "h" restituisce il valore della proprietà TimeSpan.Hours, che rappresenta il numero di ore complete nell'intervallo di tempo non conteggiate come parte del relativo componente giorno.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 isn't counted as part of its day component. Restituisce un valore stringa a una cifra se il valore della proprietà TimeSpan.Hours è compreso tra 0 e 9 e restituisce un valore stringa a due cifre se il valore della proprietà TimeSpan.Hours è compreso tra 10 e 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.

Se l'identificatore di formato personalizzato "h" viene usato da solo, specificare "%h" in modo che non venga interpretato erroneamente come stringa in formato standard.If the "h" custom format specifier is used alone, specify "%h" so that it isn't misinterpreted as a standard format string. Nell'esempio seguente viene illustrato questo concetto.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

Normalmente in un'operazione di analisi una stringa di input che include solo un numero singolo viene interpretata come numero di giorni.Ordinarily, in a parsing operation, an input string that includes only a single number is interpreted as the number of days. Usare invece l'identificatore di formato personalizzato "%h" per interpretare la stringa numerica come numero di ore.You can use the "%h" custom format specifier instead to interpret the numeric string as the number of hours. Nell'esempio seguente viene illustrato questo concetto.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                              

Nell'esempio seguente viene illustrato l'uso dell'identificatore di formato personalizzato "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

Torna alla tabellaBack to table

Identificatore di formato personalizzato "hh"The "hh" custom format specifier

L'identificatore di formato personalizzato "hh" restituisce il valore della proprietà TimeSpan.Hours, che rappresenta il numero di ore complete nell'intervallo di tempo non conteggiate come parte del relativo componente giorno.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 isn't counted as part of its day component. Per valori compresi tra 0 e 9, la stringa di output include uno zero iniziale.For values from 0 through 9, the output string includes a leading zero.

Normalmente in un'operazione di analisi una stringa di input che include solo un numero singolo viene interpretata come numero di giorni.Ordinarily, in a parsing operation, an input string that includes only a single number is interpreted as the number of days. Usare invece l'identificatore di formato personalizzato "hh" per interpretare la stringa numerica come numero di ore.You can use the "hh" custom format specifier instead to interpret the numeric string as the number of hours. Nell'esempio seguente viene illustrato questo concetto.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                              

Nell'esempio seguente viene illustrato l'uso dell'identificatore di formato personalizzato "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

Torna alla tabellaBack to table

Identificatore di formato personalizzato "m"The "m" custom format specifier

L'identificatore di formato personalizzato "m" restituisce il valore della proprietà TimeSpan.Minutes, che rappresenta il numero di minuti completi nell'intervallo di tempo non conteggiati come parte del relativo componente giorno.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 isn't counted as part of its day component. Restituisce un valore stringa a una cifra se il valore della proprietà TimeSpan.Minutes è compreso tra 0 e 9 e restituisce un valore stringa a due cifre se il valore della proprietà TimeSpan.Minutes è compreso tra 10 e 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.

Se l'identificatore di formato personalizzato "m" viene usato da solo, specificare "%m" in modo che non venga interpretato erroneamente come stringa in formato standard.If the "m" custom format specifier is used alone, specify "%m" so that it isn't misinterpreted as a standard format string. Nell'esempio seguente viene illustrato questo concetto.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

Normalmente in un'operazione di analisi una stringa di input che include solo un numero singolo viene interpretata come numero di giorni.Ordinarily, in a parsing operation, an input string that includes only a single number is interpreted as the number of days. Usare invece l'identificatore di formato personalizzato "%m" per interpretare la stringa numerica come numero di minuti.You can use the "%m" custom format specifier instead to interpret the numeric string as the number of minutes. Nell'esempio seguente viene illustrato questo concetto.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                              

Nell'esempio seguente viene illustrato l'uso dell'identificatore di formato personalizzato "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

Torna alla tabellaBack to table

Identificatore di formato personalizzato "mm"The "mm" custom format specifier

L'identificatore di formato personalizzato "mm" restituisce il valore della proprietà TimeSpan.Minutes, che rappresenta il numero di minuti completi nell'intervallo di tempo non inclusi come parte del relativo componente ore o giorni.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 isn't included as part of its hours or days component. Per valori compresi tra 0 e 9, la stringa di output include uno zero iniziale.For values from 0 through 9, the output string includes a leading zero.

Normalmente in un'operazione di analisi una stringa di input che include solo un numero singolo viene interpretata come numero di giorni.Ordinarily, in a parsing operation, an input string that includes only a single number is interpreted as the number of days. Usare invece l'identificatore di formato personalizzato "mm" per interpretare la stringa numerica come numero di minuti.You can use the "mm" custom format specifier instead to interpret the numeric string as the number of minutes. Nell'esempio seguente viene illustrato questo concetto.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           

Nell'esempio seguente viene illustrato l'uso dell'identificatore di formato personalizzato "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      

Torna alla tabellaBack to table

Identificatore di formato personalizzato "s"The "s" custom format specifier

L'identificatore di formato personalizzato "s" restituisce il valore della proprietà TimeSpan.Seconds, che rappresenta il numero di secondi completi nell'intervallo di tempo non inclusi come parte del relativo componente ore, giorni o minuti.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 isn't included as part of its hours, days, or minutes component. Restituisce un valore stringa a una cifra se il valore della proprietà TimeSpan.Seconds è compreso tra 0 e 9 e restituisce un valore stringa a due cifre se il valore della proprietà TimeSpan.Seconds è compreso tra 10 e 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.

Se l'identificatore di formato personalizzato "s" viene usato da solo, specificare "%s" in modo che non venga interpretato erroneamente come stringa in formato standard.If the "s" custom format specifier is used alone, specify "%s" so that it isn't misinterpreted as a standard format string. Nell'esempio seguente viene illustrato questo concetto.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

Normalmente in un'operazione di analisi una stringa di input che include solo un numero singolo viene interpretata come numero di giorni.Ordinarily, in a parsing operation, an input string that includes only a single number is interpreted as the number of days. Usare invece l'identificatore di formato personalizzato "%s" per interpretare la stringa numerica come numero di secondi.You can use the "%s" custom format specifier instead to interpret the numeric string as the number of seconds. Nell'esempio seguente viene illustrato questo concetto.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

Nell'esempio seguente viene illustrato l'uso dell'identificatore di formato personalizzato "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      

Torna alla tabellaBack to table

Identificatore di formato personalizzato "ss"The "ss" custom format specifier

L'identificatore di formato personalizzato "ss" restituisce il valore della proprietà TimeSpan.Seconds, che rappresenta il numero di secondi completi nell'intervallo di tempo non inclusi come parte del relativo componente ore, giorni o minuti.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 isn't included as part of its hours, days, or minutes component. Per valori compresi tra 0 e 9, la stringa di output include uno zero iniziale.For values from 0 through 9, the output string includes a leading zero.

Normalmente in un'operazione di analisi una stringa di input che include solo un numero singolo viene interpretata come numero di giorni.Ordinarily, in a parsing operation, an input string that includes only a single number is interpreted as the number of days. Usare invece l'identificatore di formato personalizzato "ss" per interpretare la stringa numerica come numero di secondi.You can use the "ss" custom format specifier instead to interpret the numeric string as the number of seconds. Nell'esempio seguente viene illustrato questo concetto.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

Nell'esempio seguente viene illustrato l'uso dell'identificatore di formato personalizzato "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

Torna alla tabellaBack to table

Identificatore di formato personalizzato "f"The "f" custom format specifier

L'identificatore di formato personalizzato "f" restituisce i decimi di secondo in un intervallo di tempo.The "f" custom format specifier outputs the tenths of a second in a time interval. In un'operazione di formattazione qualsiasi cifra frazionaria rimanente viene troncata.In a formatting operation, any remaining fractional digits are truncated. In un'operazione di analisi che chiama il metodo TimeSpan.ParseExact o TimeSpan.TryParseExact la stringa di input deve contenere esattamente una sola cifra frazionaria.In a parsing operation that calls the TimeSpan.ParseExact or TimeSpan.TryParseExact method, the input string must contain exactly one fractional digit.

Se l'identificatore di formato personalizzato "f" viene usato da solo, specificare "%f" in modo che non venga interpretato erroneamente come stringa in formato standard.If the "f" custom format specifier is used alone, specify "%f" so that it isn't misinterpreted as a standard format string.

Nell'esempio seguente viene usato l'identificatore di formato personalizzato "f" per visualizzare i decimi di secondo in un valore TimeSpan.The following example uses the "f" custom format specifier to display the tenths of a second in a TimeSpan value. "f" viene usato prima come unico identificatore di formato e quindi viene usato in combinazione con l'identificatore "s" in una stringa di formato personalizzato."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

Torna alla tabellaBack to table

Identificatore di formato personalizzato "ff"The "ff" custom format specifier

L'identificatore di formato personalizzato "ff" restituisce i centesimi di secondo in un intervallo di tempo.The "ff" custom format specifier outputs the hundredths of a second in a time interval. In un'operazione di formattazione qualsiasi cifra frazionaria rimanente viene troncata.In a formatting operation, any remaining fractional digits are truncated. In un'operazione di analisi che chiama il metodo TimeSpan.ParseExact o TimeSpan.TryParseExact la stringa di input deve contenere esattamente due cifre frazionarie.In a parsing operation that calls the TimeSpan.ParseExact or TimeSpan.TryParseExact method, the input string must contain exactly two fractional digits.

Nell'esempio seguente viene usato l'identificatore di formato personalizzato "ff" per visualizzare i centesimi di secondo in un valore TimeSpan.The following example uses the "ff" custom format specifier to display the hundredths of a second in a TimeSpan value. "ff" viene usato prima come unico identificatore di formato, quindi viene usato in combinazione con l'identificatore "s" in una stringa di formato personalizzato."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

Torna alla tabellaBack to table

Identificatore di formato personalizzato "fff"The "fff" custom format specifier

L'identificatore di formato personalizzato "fff" (con tre caratteri "f") restituisce i millisecondi in un intervallo di tempo.The "fff" custom format specifier (with three "f" characters) outputs the milliseconds in a time interval. In un'operazione di formattazione qualsiasi cifra frazionaria rimanente viene troncata.In a formatting operation, any remaining fractional digits are truncated. In un'operazione di analisi che chiama il metodo TimeSpan.ParseExact o TimeSpan.TryParseExact la stringa di input deve contenere esattamente tre cifre frazionarie.In a parsing operation that calls the TimeSpan.ParseExact or TimeSpan.TryParseExact method, the input string must contain exactly three fractional digits.

Nell'esempio seguente viene usato l'identificatore di formato personalizzato "fff" per visualizzare i millisecondi in un valore TimeSpan.The following example uses the "fff" custom format specifier to display the milliseconds in a TimeSpan value. "fff" viene usato prima come unico identificatore di formato e quindi viene usato in combinazione con l'identificatore "s" in una stringa di formato personalizzato."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

Torna alla tabellaBack to table

Identificatore di formato personalizzato "ffff"The "ffff" custom format specifier

L'identificatore di formato personalizzato "ffff" (con quattro caratteri "f") restituisce i decimillesimi di secondo in un intervallo di tempo.The "ffff" custom format specifier (with four "f" characters) outputs the ten-thousandths of a second in a time interval. In un'operazione di formattazione qualsiasi cifra frazionaria rimanente viene troncata.In a formatting operation, any remaining fractional digits are truncated. In un'operazione di analisi che chiama il metodo TimeSpan.ParseExact o TimeSpan.TryParseExact la stringa di input deve contenere esattamente quattro cifre frazionarie.In a parsing operation that calls the TimeSpan.ParseExact or TimeSpan.TryParseExact method, the input string must contain exactly four fractional digits.

Nell'esempio seguente viene usato l'identificatore di formato personalizzato "ffff" per visualizzare i decimillesimi di secondo in un valore TimeSpan.The following example uses the "ffff" custom format specifier to display the ten-thousandths of a second in a TimeSpan value. "ffff" viene usato prima come unico identificatore di formato e quindi viene usato in combinazione con l'identificatore "s" in una stringa di formato personalizzato."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

Torna alla tabellaBack to table

Identificatore di formato personalizzato "fffff"The "fffff" custom format specifier

L'identificatore di formato personalizzato "fffff" (con cinque caratteri "f") restituisce i centesimi di millesimo di secondo in un intervallo di tempo.The "fffff" custom format specifier (with five "f" characters) outputs the hundred-thousandths of a second in a time interval. In un'operazione di formattazione qualsiasi cifra frazionaria rimanente viene troncata.In a formatting operation, any remaining fractional digits are truncated. In un'operazione di analisi che chiama il metodo TimeSpan.ParseExact o TimeSpan.TryParseExact la stringa di input deve contenere esattamente cinque cifre frazionarie.In a parsing operation that calls the TimeSpan.ParseExact or TimeSpan.TryParseExact method, the input string must contain exactly five fractional digits.

Nell'esempio seguente viene usato l'identificatore di formato personalizzato "fffff" per visualizzare i centesimi di millesimo di secondo in un valore TimeSpan.The following example uses the "fffff" custom format specifier to display the hundred-thousandths of a second in a TimeSpan value. "fffff" viene usato prima come unico identificatore di formato e quindi viene usato in combinazione con l'identificatore "s" in una stringa di formato personalizzato."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

Torna alla tabellaBack to table

Identificatore di formato personalizzato "ffffff"The "ffffff" custom format specifier

L'identificatore di formato personalizzato "ffffff" (con sei caratteri "f") restituisce i milionesimi di secondo in un intervallo di tempo.The "ffffff" custom format specifier (with six "f" characters) outputs the millionths of a second in a time interval. In un'operazione di formattazione qualsiasi cifra frazionaria rimanente viene troncata.In a formatting operation, any remaining fractional digits are truncated. In un'operazione di analisi che chiama il metodo TimeSpan.ParseExact o TimeSpan.TryParseExact la stringa di input deve contenere esattamente sei cifre frazionarie.In a parsing operation that calls the TimeSpan.ParseExact or TimeSpan.TryParseExact method, the input string must contain exactly six fractional digits.

Nell'esempio seguente viene usato l'identificatore di formato personalizzato "ffffff" per visualizzare i milionesimi di secondo in un valore TimeSpan.The following example uses the "ffffff" custom format specifier to display the millionths of a second in a TimeSpan value. Viene usato prima come unico identificatore di formato, quindi viene usato in combinazione con l'identificatore "s" in una stringa di formato personalizzato.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

Torna alla tabellaBack to table

Identificatore di formato personalizzato "fffffff"The "fffffff" custom format specifier

L'identificatore di formato personalizzato "fffffff" (con sette caratteri "f") restituisce i decimilionesimi di secondo (o il numero frazionario di tick) in un intervallo di tempo.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. In un'operazione di analisi che chiama il metodo TimeSpan.ParseExact o TimeSpan.TryParseExact la stringa di input deve contenere esattamente sette cifre frazionarie.In a parsing operation that calls the TimeSpan.ParseExact or TimeSpan.TryParseExact method, the input string must contain exactly seven fractional digits.

Nell'esempio seguente viene usato l'identificatore di formato personalizzato "fffffff" per visualizzare il numero frazionario di tick in un valore TimeSpan.The following example uses the "fffffff" custom format specifier to display the fractional number of ticks in a TimeSpan value. Viene usato prima come unico identificatore di formato, quindi viene usato in combinazione con l'identificatore "s" in una stringa di formato personalizzato.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

Torna alla tabellaBack to table

Identificatore di formato personalizzato "F"The "F" custom format specifier

L'identificatore di formato personalizzato "F" restituisce i decimi di secondo in un intervallo di tempo.The "F" custom format specifier outputs the tenths of a second in a time interval. In un'operazione di formattazione qualsiasi cifra frazionaria rimanente viene troncata.In a formatting operation, any remaining fractional digits are truncated. Se il valore dei decimi di secondo dell'intervallo di tempo è zero, non viene incluso nella stringa del risultato.If the value of the time interval's tenths of a second is zero, it isn't included in the result string. In un'operazione di analisi che chiama il metodo TimeSpan.ParseExact o TimeSpan.TryParseExact la presenza della cifra dei decimi di secondo è facoltativa.In a parsing operation that calls the TimeSpan.ParseExact or TimeSpan.TryParseExact method, the presence of the tenths of a second digit is optional.

Se l'identificatore di formato personalizzato "F" viene usato da solo, specificare "%F" in modo che non venga interpretato erroneamente come stringa in formato standard.If the "F" custom format specifier is used alone, specify "%F" so that it isn't misinterpreted as a standard format string.

Nell'esempio seguente viene usato l'identificatore di formato personalizzato "F" per visualizzare i decimi di secondo in un valore TimeSpan.The following example uses the "F" custom format specifier to display the tenths of a second in a TimeSpan value. Questo identificatore di formato personalizzato viene usato anche in un'operazione di analisi.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'.      

Torna alla tabellaBack to table

Identificatore di formato personalizzato "FF"The "FF" custom format specifier

L'identificatore di formato personalizzato "FF" restituisce i centesimi di secondo in un intervallo di tempo.The "FF" custom format specifier outputs the hundredths of a second in a time interval. In un'operazione di formattazione qualsiasi cifra frazionaria rimanente viene troncata.In a formatting operation, any remaining fractional digits are truncated. Se sono presenti zeri frazionari finali, non vengono inclusi nella stringa del risultato.If there are any trailing fractional zeros, they aren't included in the result string. In un'operazione di analisi che chiama il metodo TimeSpan.ParseExact o TimeSpan.TryParseExact la presenza della cifra dei decimi e dei centesimi di secondo è facoltativa.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.

Nell'esempio seguente viene usato l'identificatore di formato personalizzato "FF" per visualizzare i centesimi di secondo in un valore TimeSpan.The following example uses the "FF" custom format specifier to display the hundredths of a second in a TimeSpan value. Questo identificatore di formato personalizzato viene usato anche in un'operazione di analisi.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'.

Torna alla tabellaBack to table

Identificatore di formato personalizzato "FFF"The "FFF" custom format specifier

L'identificatore di formato personalizzato "FFF" (con tre caratteri "F") restituisce i millisecondi in un intervallo di tempo.The "FFF" custom format specifier (with three "F" characters) outputs the milliseconds in a time interval. In un'operazione di formattazione qualsiasi cifra frazionaria rimanente viene troncata.In a formatting operation, any remaining fractional digits are truncated. Se sono presenti zeri frazionari finali, non vengono inclusi nella stringa del risultato.If there are any trailing fractional zeros, they aren't included in the result string. In un'operazione di analisi che chiama il metodo TimeSpan.ParseExact o TimeSpan.TryParseExact la presenza della cifra dei decimi, dei centesimi e dei millesimi di secondo è facoltativa.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.

Nell'esempio seguente viene usato l'identificatore di formato personalizzato "FFF" per visualizzare i millesimi di secondo in un valore TimeSpan.The following example uses the "FFF" custom format specifier to display the thousandths of a second in a TimeSpan value. Questo identificatore di formato personalizzato viene usato anche in un'operazione di analisi.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'.

Torna alla tabellaBack to table

Identificatore di formato personalizzato "FFFF"The "FFFF" custom format specifier

L'identificatore di formato personalizzato "FFFF" (con quattro caratteri "F") restituisce i decimillesimi di secondo in un intervallo di tempo.The "FFFF" custom format specifier (with four "F" characters) outputs the ten-thousandths of a second in a time interval. In un'operazione di formattazione qualsiasi cifra frazionaria rimanente viene troncata.In a formatting operation, any remaining fractional digits are truncated. Se sono presenti zeri frazionari finali, non vengono inclusi nella stringa del risultato.If there are any trailing fractional zeros, they aren't included in the result string. In un'operazione di analisi che chiama il metodo TimeSpan.ParseExact o TimeSpan.TryParseExact la presenza della cifra dei decimi, dei centesimi, dei millesimi e dei decimillesimi di secondo è facoltativa.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.

Nell'esempio seguente viene usato l'identificatore di formato personalizzato "FFFF" per visualizzare i decimillesimi di secondo in un valore TimeSpan.The following example uses the "FFFF" custom format specifier to display the ten-thousandths of a second in a TimeSpan value. L'identificatore di formato personalizzato "FFFF" viene usato anche in un'operazione di analisi.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'.

Torna alla tabellaBack to table

Identificatore di formato personalizzato "FFFFF"The "FFFFF" custom format specifier

L'identificatore di formato personalizzato "FFFFF" (con cinque caratteri "F") restituisce i centesimi di millesimo di secondo in un intervallo di tempo.The "FFFFF" custom format specifier (with five "F" characters) outputs the hundred-thousandths of a second in a time interval. In un'operazione di formattazione qualsiasi cifra frazionaria rimanente viene troncata.In a formatting operation, any remaining fractional digits are truncated. Se sono presenti zeri frazionari finali, non vengono inclusi nella stringa del risultato.If there are any trailing fractional zeros, they aren't included in the result string. In un'operazione di analisi che chiama il metodo TimeSpan.ParseExact o TimeSpan.TryParseExact la presenza della cifra dei decimi, dei centesimi, dei millesimi, dei decimillesimi e dei centesimi di millesimi di secondo è facoltativa.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.

Nell'esempio seguente viene usato l'identificatore di formato personalizzato "FFFFF" per visualizzare i centesimi di millesimo di secondo in un valore TimeSpan.The following example uses the "FFFFF" custom format specifier to display the hundred-thousandths of a second in a TimeSpan value. L'identificatore di formato personalizzato "FFFFF" viene usato anche in un'operazione di analisi.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'.

Torna alla tabellaBack to table

Identificatore di formato personalizzato "FFFFFF"The "FFFFFF" custom format specifier

L'identificatore di formato personalizzato "FFFFFF" (con sei caratteri "F") restituisce i milionesimi di secondo in un intervallo di tempo.The "FFFFFF" custom format specifier (with six "F" characters) outputs the millionths of a second in a time interval. In un'operazione di formattazione qualsiasi cifra frazionaria rimanente viene troncata.In a formatting operation, any remaining fractional digits are truncated. Se sono presenti zeri frazionari finali, non vengono inclusi nella stringa del risultato.If there are any trailing fractional zeros, they aren't included in the result string. In un'operazione di analisi che chiama il metodo TimeSpan.ParseExact o TimeSpan.TryParseExact la presenza della cifra dei decimi, dei centesimi, dei millesimi, dei decimillesimi, dei centesimi di millesimi e dei milionesimi di secondo è facoltativa.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.

Nell'esempio seguente viene usato l'identificatore di formato personalizzato "FFFFFF" per visualizzare i milionesimi di secondo in un valore TimeSpan.The following example uses the "FFFFFF" custom format specifier to display the millionths of a second in a TimeSpan value. Questo identificatore di formato personalizzato viene usato anche in un'operazione di analisi.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'.

Torna alla tabellaBack to table

Identificatore di formato personalizzato "FFFFFFF"The "FFFFFFF" custom format specifier

L'identificatore di formato personalizzato "FFFFFFF" (con sette caratteri "F") restituisce i decimilionesimi di secondo (o il numero frazionario di tick) in un intervallo di tempo.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. Se sono presenti zeri frazionari finali, non vengono inclusi nella stringa del risultato.If there are any trailing fractional zeros, they aren't included in the result string. In un'operazione di analisi che chiama il metodo TimeSpan.ParseExact o TimeSpan.TryParseExact la presenza delle sette cifre frazionarie nella stringa di input è facoltativa.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.

Nell'esempio seguente viene usato l'identificatore di formato personalizzato "FFFFFFF" per visualizzare la parte frazionaria di un secondo in un valore TimeSpan.The following example uses the "FFFFFFF" custom format specifier to display the fractional parts of a second in a TimeSpan value. Questo identificatore di formato personalizzato viene usato anche in un'operazione di analisi.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     

Torna alla tabellaBack to table

Altri caratteriOther characters

Qualsiasi altro carattere senza codice di escape in una stringa di formato, incluso un carattere di spazio vuoto, viene interpretato come identificatore di formato personalizzato.Any other unescaped character in a format string, including a white-space character, is interpreted as a custom format specifier. Nella maggior parte dei casi la presenza di qualsiasi altro carattere senza codice di escape restituisce un oggetto FormatException.In most cases, the presence of any other unescaped character results in a FormatException.

È possibile includere un carattere letterale in una stringa di formato in due modi:There are two ways to include a literal character in a format string:

  • Racchiudendolo tra virgolette singole (delimitatore di stringa letterale).Enclose it in single quotation marks (the literal string delimiter).

  • Inserendo prima del carattere una barra rovesciata("\"), interpretata come carattere di escape.Precede it with a backslash ("\"), which is interpreted as an escape character. In C#, pertanto, la stringa di formato deve essere @-quoted o il carattere letterale deve essere preceduto da una barra rovesciata aggiuntiva.This means that, in C#, the format string must either be @-quoted, or the literal character must be preceded by an additional backslash.

    In alcuni casi, potrebbe essere necessario utilizzare la logica condizionale per includere un valore letterale preceduto da una barra rovesciata in una stringa di formato.In some cases, you may have to use conditional logic to include an escaped literal in a format string. Nell'esempio seguente viene utilizzata la logica condizionale per includere un simbolo di segno per intervalli di tempo negativi.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 non definisce una grammatica per i separatori negli intervalli di tempo..NET doesn't define a grammar for separators in time intervals. I separatori tra giorni e ore, ore e minuti, minuti e secondi e secondi e frazioni di secondo devono pertanto essere trattati come valori letterali carattere in una stringa di formato.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.

Nell'esempio seguente vengono usati sia il carattere di escape che la virgoletta singola per definire una stringa di formato personalizzata che include la parola "minutes" nella stringa di output.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      

Torna alla tabellaBack to table

Vedere ancheSee also