Vlastní řetězce formátu TimeSpanCustom TimeSpan format strings

Řetězec formátu TimeSpan definuje řetězcovou reprezentaci hodnoty TimeSpan, která je výsledkem operace formátování.A TimeSpan format string defines the string representation of a TimeSpan value that results from a formatting operation. Vlastní formátovací řetězec se skládá z jednoho nebo více vlastních specifikátorů formátu TimeSpan spolu s libovolným počtem literálních znaků.A custom format string consists of one or more custom TimeSpan format specifiers along with any number of literal characters. Libovolný řetězec, který není standardním řetězcem formátu TimeSpan , je interpretován jako řetězec formátu vlastního TimeSpan.Any string that isn't a standard TimeSpan format string is interpreted as a custom TimeSpan format string.

Důležité

Specifikátory vlastního formátu TimeSpan neobsahují zástupné symboly oddělovačů, jako jsou například symboly, které oddělují dny od hodin, hodin od minut nebo sekund od zlomků sekund.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. Místo toho je nutné tyto symboly zahrnout do vlastního řetězce formátu jako řetězcové literály.Instead, these symbols must be included in the custom format string as string literals. "dd\.hh\:mm" například definuje tečku (.) jako oddělovač mezi dny a hodiny a dvojtečku (:) jako oddělovač mezi hodinami a minutami.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.

Vlastní specifikátory formátu TimeSpan také nezahrnují symbol znaménka, který umožňuje odlišit záporné a kladné časové intervaly.Custom TimeSpan format specifiers also don't include a sign symbol that enables you to differentiate between negative and positive time intervals. Chcete-li zahrnout symbol znaménka, je nutné sestavit řetězec formátu pomocí podmíněné logiky.To include a sign symbol, you have to construct a format string by using conditional logic. Část s dalšími znaky obsahuje příklad.The Other characters section includes an example.

Řetězcové reprezentace hodnot TimeSpan jsou vytvářeny voláním přetížení TimeSpan.ToString metody a metodami, které podporují složené formátování, jako je například 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. Další informace najdete v tématu typy formátování a složené formátování.For more information, see Formatting Types and Composite Formatting. Následující příklad ukazuje použití vlastních řetězců formátu při formátování operací.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

Vlastní řetězce formátu TimeSpan jsou také používány metodami TimeSpan.ParseExact a TimeSpan.TryParseExact k definování požadovaného formátu vstupních řetězců k analýze operací.Custom TimeSpan format strings are also used by the TimeSpan.ParseExact and TimeSpan.TryParseExact methods to define the required format of input strings for parsing operations. (Analýza převede řetězcovou reprezentaci hodnoty na tuto hodnotu.) Následující příklad ilustruje použití standardního formátovacího řetězce při analýze operací.(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

Následující tabulka popisuje specifikátory vlastního formátu data a času.The following table describes the custom date and time format specifiers.

Specifikátor formátuFormat specifier PopisDescription PříkladExample
"d", "% d""d", "%d" Počet celých dnů v časovém intervalu.The number of whole days in the time interval.

Další informace: Specifikátor vlastního formátu "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" Počet celých dnů v časovém intervalu, doplněno počátečními nulami podle potřeby.The number of whole days in the time interval, padded with leading zeros as needed.

Další informace: specifikátory "dd" – "dddddddd" vlastního formátu.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" Počet celých hodin v časovém intervalu, které se nepočítají jako součást dnů.The number of whole hours in the time interval that aren't counted as part of days. Jednociferné číslo hodiny nemá počáteční nulu.Single-digit hours don't have a leading zero.

Další informace: specifikátor "h" vlastního formátu.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" Počet celých hodin v časovém intervalu, které se nepočítají jako součást dnů.The number of whole hours in the time interval that aren't counted as part of days. Jednociferné číslo hodiny má počáteční nulu.Single-digit hours have a leading zero.

Další informace: specifikátor "HH" vlastního formátu.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" Počet celých minut v časovém intervalu, které nejsou zahrnuté jako součást hodin nebo dnů.The number of whole minutes in the time interval that aren't included as part of hours or days. Jednociferné číslo minut nemá počáteční nulu.Single-digit minutes don't have a leading zero.

Další informace: Specifikátor vlastního formátu "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" Počet celých minut v časovém intervalu, které nejsou zahrnuté jako součást hodin nebo dnů.The number of whole minutes in the time interval that aren't included as part of hours or days. Jednociferné číslo minut má počáteční nulu.Single-digit minutes have a leading zero.

Další informace: specifikátor "mm" vlastního formátu.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" Počet celých sekund v časovém intervalu, které nejsou zahrnuté jako součást hodin, dnů nebo minut.The number of whole seconds in the time interval that aren't included as part of hours, days, or minutes. Jednociferné číslo sekund nemá počáteční nulu.Single-digit seconds don't have a leading zero.

Další informace: Specifikátor vlastního formátu "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" Počet celých sekund v časovém intervalu, které nejsou zahrnuté jako součást hodin, dnů nebo minut.The number of whole seconds in the time interval that aren't included as part of hours, days, or minutes. Jednociferné číslo sekund má počáteční nulu.Single-digit seconds have a leading zero.

Další informace: Specifikátor vlastního formátu "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" Desetiny sekundy v časovém intervalu.The tenths of a second in a time interval.

Další informace: specifikátor "f" vlastního formátu.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" Setiny sekundy v časovém intervalu.The hundredths of a second in a time interval.

Další informace: specifikátor "FF" vlastního formátu.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" Milisekundy v časovém intervalu.The milliseconds in a time interval.

Další informace: specifikátor "fff" vlastního formátu.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" Deset – sekundy sekundy v časovém intervalu.The ten-thousandths of a second in a time interval.

Další informace: Specifikátor vlastního formátu "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" Set-sekundy sekundy v časovém intervalu.The hundred-thousandths of a second in a time interval.

Další informace: Specifikátor vlastního formátu "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" Desetimiliontiny sekundy v časovém intervalu.The millionths of a second in a time interval.

Další informace: Specifikátor vlastního formátu "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" Desítkový Desetimiliontiny sekundy (nebo zlomkové takty) v časovém intervalu.The ten-millionths of a second (or the fractional ticks) in a time interval.

Další informace: Specifikátor vlastního formátu "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" Desetiny sekundy v časovém intervalu.The tenths of a second in a time interval. Pokud je číslice nula, nezobrazí se žádná hodnota.Nothing is displayed if the digit is zero.

Další informace: specifikátor "F" vlastního formátu.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" Setiny sekundy v časovém intervalu.The hundredths of a second in a time interval. Nezahrnují se žádné zlomkové koncové nuly nebo dvě číslice nula.Any fractional trailing zeros or two zero digits aren't included.

Další informace: specifikátor "FF" vlastního formátu.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" Milisekundy v časovém intervalu.The milliseconds in a time interval. Žádné zlomkové koncové nuly nejsou zahrnuty.Any fractional trailing zeros aren't included.

Další informace: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" Deset – sekundy sekundy v časovém intervalu.The ten-thousandths of a second in a time interval. Žádné zlomkové koncové nuly nejsou zahrnuty.Any fractional trailing zeros aren't included.

Další informace: Specifikátor vlastního formátu "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" Set-sekundy sekundy v časovém intervalu.The hundred-thousandths of a second in a time interval. Žádné zlomkové koncové nuly nejsou zahrnuty.Any fractional trailing zeros aren't included.

Další informace: Specifikátor vlastního formátu "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" Desetimiliontiny sekundy v časovém intervalu.The millionths of a second in a time interval. Nezobrazí se žádné zlomkové koncové nuly.Any fractional trailing zeros aren't displayed.

Další informace: Specifikátor vlastního formátu "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" Deset milionů sekund v časovém intervalu.The ten-millions of a second in a time interval. Nezobrazí se žádné zlomkové koncové nuly nebo sedm nul.Any fractional trailing zeros or seven zeros aren't displayed.

Další informace: Specifikátor vlastního formátu "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
řetězec "String"'string' Oddělovač řetězcového literálu.Literal string delimiter.

Další informace: jiné znaky.More information: Other characters.
new TimeSpan(14, 32, 17):

hh':'mm':'ss--> "14:32:17"hh':'mm':'ss --> "14:32:17"
\\ Řídicí znak.The escape character.

Další informace: jiné znaky.More information: Other characters.
new TimeSpan(14, 32, 17):

hh\:mm\:ss--> "14:32:17"hh\:mm\:ss --> "14:32:17"
Jakýkoli jiný znakAny other character Jakýkoli jiný znak bez řídicího znaku je interpretován jako specifikátor vlastního formátu.Any other unescaped character is interpreted as a custom format specifier.

Další informace: jiné znaky.More Information: Other characters.
new TimeSpan(14, 32, 17):

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

Specifikátor vlastního formátu "d"The "d" custom format specifier

Specifikátor vlastního formátu "d" vypíše hodnotu vlastnosti TimeSpan.Days, která představuje počet celých dnů v časovém intervalu.The "d" custom format specifier outputs the value of the TimeSpan.Days property, which represents the number of whole days in the time interval. Výstupem je celý počet dnů ve TimeSpan hodnotě, i když má hodnota více než jednu číslici.It outputs the full number of days in a TimeSpan value, even if the value has more than one digit. Pokud je hodnota vlastnosti TimeSpan.Days nula, výstup specifikátoru "0".If the value of the TimeSpan.Days property is zero, the specifier outputs "0".

Pokud je specifikátor vlastního formátu "d" použit samostatně, zadejte "% d", aby nebyl špatně interpretován jako řetězec standardního formátu.If the "d" custom format specifier is used alone, specify "%d" so that it isn't misinterpreted as a standard format string. V následujícím příkladu je uvedena ukázka.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   

Následující příklad ilustruje použití specifikátoru vlastního formátu "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      

Zpět na tabulkuBack to table

Specifikátory vlastního formátu "dd"-"dddddddd"The "dd"-"dddddddd" custom format specifiers

Specifikátor vlastního formátu "dd", "ddd", "dddd", "ddddd", "DDDDDD", "ddddddd" a "dddddddd" mají výstup hodnoty vlastnosti TimeSpan.Days, která představuje počet celých dnů v časovém intervalu.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.

Výstupní řetězec obsahuje minimální počet číslic určený počtem "d" znaků ve specifikátoru formátu a je doplněn počátečními nulami podle potřeby.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. Pokud číslice v počtu dní překročí počet znaků "d" ve specifikátoru formátu, je celý počet dní výstup ve výsledném řetězci.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.

Následující příklad používá tyto specifikátory formátu k zobrazení řetězcové reprezentace dvou hodnot TimeSpan.The following example uses these format specifiers to display the string representation of two TimeSpan values. Hodnota komponenty dní v prvním časovém intervalu je nulová. hodnota složky dní druhé hodnoty je 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      

Zpět na tabulkuBack to table

Specifikátor vlastního formátu "h"The "h" custom format specifier

Specifikátor vlastního formátu "h" vypíše hodnotu vlastnosti TimeSpan.Hours, která představuje počet celých hodin v časovém intervalu, který není počítán jako součást jeho komponenty Day.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. Vrátí jednociferné číslo řetězce, pokud je hodnota vlastnosti TimeSpan.Hours 0 až 9 a vrátí hodnotu řetězce se dvěma číslicemi, pokud je hodnota vlastnosti TimeSpan.Hours od 10 do 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.

Pokud je specifikátor vlastního formátu "h" použit samostatně, zadejte "% h" tak, že není špatně interpretován jako řetězec standardního formátu.If the "h" custom format specifier is used alone, specify "%h" so that it isn't misinterpreted as a standard format string. V následujícím příkladu je uvedena ukázka.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

V rámci operace analýzy obvykle je vstupní řetězec, který obsahuje pouze jedno číslo, interpretován jako počet dní.Ordinarily, in a parsing operation, an input string that includes only a single number is interpreted as the number of days. Pomocí specifikátoru vlastního formátu "% h" můžete místo toho interpretovat číselný řetězec jako počet hodin.You can use the "%h" custom format specifier instead to interpret the numeric string as the number of hours. V následujícím příkladu je uvedena ukázka.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                              

Následující příklad ilustruje použití specifikátoru vlastního formátu "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

Zpět na tabulkuBack to table

Specifikátor vlastního formátu "HH"The "hh" custom format specifier

Specifikátor vlastního formátu "HH" vypíše hodnotu vlastnosti TimeSpan.Hours, která představuje počet celých hodin v časovém intervalu, který není počítán jako součást jeho komponenty Day.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. V případě hodnot od 0 do 9 obsahuje výstupní řetězec úvodní nuly.For values from 0 through 9, the output string includes a leading zero.

V rámci operace analýzy obvykle je vstupní řetězec, který obsahuje pouze jedno číslo, interpretován jako počet dní.Ordinarily, in a parsing operation, an input string that includes only a single number is interpreted as the number of days. Místo toho můžete použít Specifikátor vlastního formátu "HH" k interpretaci číselného řetězce jako počet hodin.You can use the "hh" custom format specifier instead to interpret the numeric string as the number of hours. V následujícím příkladu je uvedena ukázka.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                              

Následující příklad ilustruje použití specifikátoru vlastního formátu "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

Zpět na tabulkuBack to table

Specifikátor vlastního formátu "m"The "m" custom format specifier

Specifikátor vlastního formátu "m" vypíše hodnotu vlastnosti TimeSpan.Minutes, která představuje počet celých minut v časovém intervalu, který není počítán jako součást jeho komponenty Day.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. Vrátí jednociferné číslo řetězce, pokud je hodnota vlastnosti TimeSpan.Minutes 0 až 9 a vrátí hodnotu řetězce s dvojnásobnou hodnotou, pokud je hodnota vlastnosti TimeSpan.Minutes rozsahu od 10 do 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.

Pokud je specifikátor vlastního formátu "m" použit samostatně, zadejte "% m" tak, že není špatně interpretován jako standardní formátovací řetězec.If the "m" custom format specifier is used alone, specify "%m" so that it isn't misinterpreted as a standard format string. V následujícím příkladu je uvedena ukázka.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

V rámci operace analýzy obvykle je vstupní řetězec, který obsahuje pouze jedno číslo, interpretován jako počet dní.Ordinarily, in a parsing operation, an input string that includes only a single number is interpreted as the number of days. Místo toho můžete pomocí specifikátoru vlastního formátu "% m" interpretovat číselný řetězec jako počet minut.You can use the "%m" custom format specifier instead to interpret the numeric string as the number of minutes. V následujícím příkladu je uvedena ukázka.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                              

Následující příklad ilustruje použití specifikátoru vlastního formátu "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

Zpět na tabulkuBack to table

Specifikátor vlastního formátu "mm"The "mm" custom format specifier

Specifikátor vlastního formátu "mm" vyprodukuje hodnotu vlastnosti TimeSpan.Minutes, která představuje počet celých minut v časovém intervalu, který není zahrnutý jako součást jeho hodin nebo dnů.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. V případě hodnot od 0 do 9 obsahuje výstupní řetězec úvodní nuly.For values from 0 through 9, the output string includes a leading zero.

V rámci operace analýzy obvykle je vstupní řetězec, který obsahuje pouze jedno číslo, interpretován jako počet dní.Ordinarily, in a parsing operation, an input string that includes only a single number is interpreted as the number of days. Místo toho můžete použít Specifikátor vlastního formátu "mm" k interpretaci číselného řetězce jako počet minut.You can use the "mm" custom format specifier instead to interpret the numeric string as the number of minutes. V následujícím příkladu je uvedena ukázka.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           

Následující příklad ilustruje použití specifikátoru vlastního formátu "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      

Zpět na tabulkuBack to table

Specifikátor vlastního formátu "s"The "s" custom format specifier

Specifikátor vlastního formátu "s" obsahuje hodnotu vlastnosti TimeSpan.Seconds, která představuje počet celých sekund v časovém intervalu, který není zahrnutý jako součást jeho hodin, dnů nebo minut.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. Vrátí jednociferné číslo řetězce, pokud je hodnota vlastnosti TimeSpan.Seconds 0 až 9 a vrátí hodnotu řetězce s dvojnásobnou hodnotou, pokud je hodnota vlastnosti TimeSpan.Seconds rozsahu od 10 do 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.

Pokud je specifikátor vlastního formátu "s" použit samostatně, zadejte "% s", aby nebyl špatně interpretován jako řetězec standardního formátu.If the "s" custom format specifier is used alone, specify "%s" so that it isn't misinterpreted as a standard format string. V následujícím příkladu je uvedena ukázka.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

V rámci operace analýzy obvykle je vstupní řetězec, který obsahuje pouze jedno číslo, interpretován jako počet dní.Ordinarily, in a parsing operation, an input string that includes only a single number is interpreted as the number of days. Pomocí specifikátoru vlastního formátu "% s" můžete místo toho interpretovat číselný řetězec jako počet sekund.You can use the "%s" custom format specifier instead to interpret the numeric string as the number of seconds. V následujícím příkladu je uvedena ukázka.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

Následující příklad ilustruje použití specifikátoru vlastního formátu "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      

Zpět na tabulkuBack to table

Specifikátor vlastního formátu "SS"The "ss" custom format specifier

Specifikátor vlastního formátu "SS" vypíše hodnotu vlastnosti TimeSpan.Seconds, která představuje počet celých sekund v časovém intervalu, který není zahrnutý jako součást své hodiny, dny nebo minuty.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. V případě hodnot od 0 do 9 obsahuje výstupní řetězec úvodní nuly.For values from 0 through 9, the output string includes a leading zero.

V rámci operace analýzy obvykle je vstupní řetězec, který obsahuje pouze jedno číslo, interpretován jako počet dní.Ordinarily, in a parsing operation, an input string that includes only a single number is interpreted as the number of days. Specifikátor vlastního formátu "SS" můžete použít místo toho k interpretaci číselného řetězce jako počtu sekund.You can use the "ss" custom format specifier instead to interpret the numeric string as the number of seconds. V následujícím příkladu je uvedena ukázka.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

Následující příklad ilustruje použití specifikátoru vlastního formátu "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

Zpět na tabulkuBack to table

Specifikátor vlastního formátu "f"The "f" custom format specifier

Specifikátor vlastního formátu "f" vyprodukuje desetiny sekundy v časovém intervalu.The "f" custom format specifier outputs the tenths of a second in a time interval. V operaci formátování se zkrátí zbývající zlomkové číslice.In a formatting operation, any remaining fractional digits are truncated. V operaci analýzy, která volá metodu TimeSpan.ParseExact nebo TimeSpan.TryParseExact, musí vstupní řetězec obsahovat právě jednu zlomkovou číslici.In a parsing operation that calls the TimeSpan.ParseExact or TimeSpan.TryParseExact method, the input string must contain exactly one fractional digit.

Pokud specifikátor vlastního formátu "f" použijete samostatně, zadejte "% f", takže není špatně interpretován jako standardní formátovací řetězec.If the "f" custom format specifier is used alone, specify "%f" so that it isn't misinterpreted as a standard format string.

Následující příklad používá specifikátor vlastního formátu "f" k zobrazení desetiny sekundy ve TimeSpan hodnotě.The following example uses the "f" custom format specifier to display the tenths of a second in a TimeSpan value. "f" se používá jako jediný specifikátor formátu a v kombinaci se specifikátorem "s" ve vlastním formátovacím řetězci."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

Zpět na tabulkuBack to table

Specifikátor vlastního formátu "FF"The "ff" custom format specifier

Specifikátor vlastního formátu "FF" vyprodukuje setiny sekundy v časovém intervalu.The "ff" custom format specifier outputs the hundredths of a second in a time interval. V operaci formátování se zkrátí zbývající zlomkové číslice.In a formatting operation, any remaining fractional digits are truncated. V operaci analýzy, která volá metodu TimeSpan.ParseExact nebo TimeSpan.TryParseExact, musí vstupní řetězec obsahovat přesně dvě zlomkové číslice.In a parsing operation that calls the TimeSpan.ParseExact or TimeSpan.TryParseExact method, the input string must contain exactly two fractional digits.

Následující příklad používá specifikátor vlastního formátu "FF" pro zobrazení setiny sekundy ve TimeSpan hodnotě.The following example uses the "ff" custom format specifier to display the hundredths of a second in a TimeSpan value. "FF" se používá jako jediný specifikátor formátu a v kombinaci se specifikátorem "s" ve vlastním formátovacím řetězci."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

Zpět na tabulkuBack to table

Specifikátor vlastního formátu "fff"The "fff" custom format specifier

Specifikátor vlastního formátu "fff" (se třemi "f" znaky) vytvoří výstup milisekund v časovém intervalu.The "fff" custom format specifier (with three "f" characters) outputs the milliseconds in a time interval. V operaci formátování se zkrátí zbývající zlomkové číslice.In a formatting operation, any remaining fractional digits are truncated. V operaci analýzy, která volá metodu TimeSpan.ParseExact nebo TimeSpan.TryParseExact, musí vstupní řetězec obsahovat přesně tři zlomkové číslice.In a parsing operation that calls the TimeSpan.ParseExact or TimeSpan.TryParseExact method, the input string must contain exactly three fractional digits.

Následující příklad používá specifikátor vlastního formátu "fff" k zobrazení milisekund v hodnotě TimeSpan.The following example uses the "fff" custom format specifier to display the milliseconds in a TimeSpan value. "fff" se používá jako jediný specifikátor formátu a v kombinaci se specifikátorem "s" ve vlastním formátovacím řetězci."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

Zpět na tabulkuBack to table

Specifikátor vlastního formátu "FFFF"The "ffff" custom format specifier

Specifikátor vlastního formátu "FFFF" (se čtyřmi znaky "f") vytvoří výstup deseti sekundy sekundy v časovém intervalu.The "ffff" custom format specifier (with four "f" characters) outputs the ten-thousandths of a second in a time interval. V operaci formátování se zkrátí zbývající zlomkové číslice.In a formatting operation, any remaining fractional digits are truncated. V operaci analýzy, která volá metodu TimeSpan.ParseExact nebo TimeSpan.TryParseExact, musí vstupní řetězec obsahovat přesně čtyři zlomkové číslice.In a parsing operation that calls the TimeSpan.ParseExact or TimeSpan.TryParseExact method, the input string must contain exactly four fractional digits.

Následující příklad používá specifikátor vlastního formátu "FFFF" pro zobrazení deseti sekundy sekundy ve TimeSpan hodnotě.The following example uses the "ffff" custom format specifier to display the ten-thousandths of a second in a TimeSpan value. "FFFF" se používá jako jediný specifikátor formátu a v kombinaci se specifikátorem "s" ve vlastním formátovacím řetězci."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

Zpět na tabulkuBack to table

Specifikátor vlastního formátu "fffff"The "fffff" custom format specifier

Specifikátor vlastního formátu "fffff" (s pěti znaky "f") zapisuje stovky-sekundy sekundy v časovém intervalu.The "fffff" custom format specifier (with five "f" characters) outputs the hundred-thousandths of a second in a time interval. V operaci formátování se zkrátí zbývající zlomkové číslice.In a formatting operation, any remaining fractional digits are truncated. V operaci analýzy, která volá metodu TimeSpan.ParseExact nebo TimeSpan.TryParseExact, musí vstupní řetězec obsahovat přesně pět zlomkových číslic.In a parsing operation that calls the TimeSpan.ParseExact or TimeSpan.TryParseExact method, the input string must contain exactly five fractional digits.

Následující příklad používá specifikátor vlastního formátu "fffff" pro zobrazení hodnoty set-sekundy sekundy ve TimeSpan hodnotě.The following example uses the "fffff" custom format specifier to display the hundred-thousandths of a second in a TimeSpan value. "fffff" slouží jako první specifikátor formátu a v kombinaci se specifikátorem "s" v řetězci vlastního formátu."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

Zpět na tabulkuBack to table

Specifikátor vlastního formátu "FFFFFF"The "ffffff" custom format specifier

Specifikátor vlastního formátu "FFFFFF" (obsahující šest znaků f) výstupuje Desetimiliontiny sekundy v časovém intervalu.The "ffffff" custom format specifier (with six "f" characters) outputs the millionths of a second in a time interval. V operaci formátování se zkrátí zbývající zlomkové číslice.In a formatting operation, any remaining fractional digits are truncated. V operaci analýzy, která volá metodu TimeSpan.ParseExact nebo TimeSpan.TryParseExact, musí vstupní řetězec obsahovat přesně šest zlomkových číslic.In a parsing operation that calls the TimeSpan.ParseExact or TimeSpan.TryParseExact method, the input string must contain exactly six fractional digits.

V následujícím příkladu je použit Specifikátor vlastního formátu "FFFFFF" pro zobrazení Desetimiliontiny sekundy v hodnotě TimeSpan.The following example uses the "ffffff" custom format specifier to display the millionths of a second in a TimeSpan value. Slouží jako první specifikátor formátu a v kombinaci se specifikátorem "s" ve vlastním formátovacím řetězci.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

Zpět na tabulkuBack to table

Specifikátor vlastního formátu "fffffff"The "fffffff" custom format specifier

Specifikátor vlastního formátu "fffffff" (se sedmi "f" znaky) vytvoří výstup deseti Desetimiliontiny sekundy (nebo desetinné číslo tiků) v časovém intervalu.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. V operaci analýzy, která volá metodu TimeSpan.ParseExact nebo TimeSpan.TryParseExact, musí vstupní řetězec obsahovat přesně sedm zlomkových číslic.In a parsing operation that calls the TimeSpan.ParseExact or TimeSpan.TryParseExact method, the input string must contain exactly seven fractional digits.

Následující příklad používá specifikátor vlastního formátu "fffffff" pro zobrazení desetinného počtu tiků v TimeSpan hodnotě.The following example uses the "fffffff" custom format specifier to display the fractional number of ticks in a TimeSpan value. Slouží jako první specifikátor formátu a v kombinaci se specifikátorem "s" ve vlastním formátovacím řetězci.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

Zpět na tabulkuBack to table

Specifikátor vlastního formátu "F"The "F" custom format specifier

Specifikátor vlastního formátu "F" vyprodukuje desetiny sekundy v časovém intervalu.The "F" custom format specifier outputs the tenths of a second in a time interval. V operaci formátování se zkrátí zbývající zlomkové číslice.In a formatting operation, any remaining fractional digits are truncated. Pokud je hodnota počtu desetin časových intervalů sekundy nula, není součástí výsledného řetězce.If the value of the time interval's tenths of a second is zero, it isn't included in the result string. V operaci analýzy, která volá metodu TimeSpan.ParseExact nebo TimeSpan.TryParseExact, je přítomnost desetin druhé číslice volitelná.In a parsing operation that calls the TimeSpan.ParseExact or TimeSpan.TryParseExact method, the presence of the tenths of a second digit is optional.

Pokud specifikátor vlastního formátu "F" použijete samostatně, zadejte "% F", takže není špatně interpretován jako standardní formátovací řetězec.If the "F" custom format specifier is used alone, specify "%F" so that it isn't misinterpreted as a standard format string.

Následující příklad používá specifikátor vlastního formátu "F" k zobrazení desetiny sekundy ve TimeSpan hodnotě.The following example uses the "F" custom format specifier to display the tenths of a second in a TimeSpan value. Používá také tento vlastní specifikátor formátu v operaci analýzy.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'.      

Zpět na tabulkuBack to table

Specifikátor vlastního formátu "FF"The "FF" custom format specifier

Specifikátor vlastního formátu "FF" vyprodukuje setiny sekundy v časovém intervalu.The "FF" custom format specifier outputs the hundredths of a second in a time interval. V operaci formátování se zkrátí zbývající zlomkové číslice.In a formatting operation, any remaining fractional digits are truncated. Pokud jsou žádné koncové zlomky nula, nejsou zahrnuty ve výsledném řetězci.If there are any trailing fractional zeros, they aren't included in the result string. V operaci analýzy, která volá metodu TimeSpan.ParseExact nebo TimeSpan.TryParseExact, je přítomnost desátého a setiny druhé číslice volitelná.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.

Následující příklad používá specifikátor vlastního formátu "FF" pro zobrazení setiny sekundy ve TimeSpan hodnotě.The following example uses the "FF" custom format specifier to display the hundredths of a second in a TimeSpan value. Používá také tento vlastní specifikátor formátu v operaci analýzy.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'.

Zpět na tabulkuBack to table

Specifikátor vlastního formátu "FFF"The "FFF" custom format specifier

Specifikátor vlastního formátu "FFF" (se třemi "F" znaky) vytvoří výstup milisekund v časovém intervalu.The "FFF" custom format specifier (with three "F" characters) outputs the milliseconds in a time interval. V operaci formátování se zkrátí zbývající zlomkové číslice.In a formatting operation, any remaining fractional digits are truncated. Pokud jsou žádné koncové zlomky nula, nejsou zahrnuty ve výsledném řetězci.If there are any trailing fractional zeros, they aren't included in the result string. V operaci analýzy, která volá metodu TimeSpan.ParseExact nebo TimeSpan.TryParseExact, je přítomnost desetin, setinách a sekundy druhé číslice volitelná.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.

Následující příklad používá specifikátor vlastního formátu "FFF" pro zobrazení sekundy sekundy v hodnotě TimeSpan.The following example uses the "FFF" custom format specifier to display the thousandths of a second in a TimeSpan value. Používá také tento vlastní specifikátor formátu v operaci analýzy.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'.

Zpět na tabulkuBack to table

Specifikátor vlastního formátu "FFFF"The "FFFF" custom format specifier

Specifikátor vlastního formátu "FFFF" (se čtyřmi znaky "F") vytvoří výstup deseti sekundy sekundy v časovém intervalu.The "FFFF" custom format specifier (with four "F" characters) outputs the ten-thousandths of a second in a time interval. V operaci formátování se zkrátí zbývající zlomkové číslice.In a formatting operation, any remaining fractional digits are truncated. Pokud jsou žádné koncové zlomky nula, nejsou zahrnuty ve výsledném řetězci.If there are any trailing fractional zeros, they aren't included in the result string. V operaci analýzy, která volá metodu TimeSpan.ParseExact nebo TimeSpan.TryParseExact, je přítomnost desetin, setinách, sekundy a desíti-sekundy druhé číslice volitelná.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.

Následující příklad používá specifikátor vlastního formátu "FFFF" pro zobrazení deseti sekundy sekundy ve TimeSpan hodnotě.The following example uses the "FFFF" custom format specifier to display the ten-thousandths of a second in a TimeSpan value. Používá také specifikátor vlastního formátu "FFFF" v operaci analýzy.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'.

Zpět na tabulkuBack to table

Specifikátor vlastního formátu "FFFFF"The "FFFFF" custom format specifier

Specifikátor vlastního formátu "FFFFF" (s pěti znaky "F") zapisuje stovky-sekundy sekundy v časovém intervalu.The "FFFFF" custom format specifier (with five "F" characters) outputs the hundred-thousandths of a second in a time interval. V operaci formátování se zkrátí zbývající zlomkové číslice.In a formatting operation, any remaining fractional digits are truncated. Pokud jsou žádné koncové zlomky nula, nejsou zahrnuty ve výsledném řetězci.If there are any trailing fractional zeros, they aren't included in the result string. V operaci analýzy, která volá metodu TimeSpan.ParseExact nebo TimeSpan.TryParseExact, je přítomnost desetin, setinách, sekundy, deseti sekundy a stě-sekundy druhé číslice volitelná.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.

Následující příklad používá specifikátor vlastního formátu "FFFFF" pro zobrazení hodnoty set-sekundy sekundy ve TimeSpan hodnotě.The following example uses the "FFFFF" custom format specifier to display the hundred-thousandths of a second in a TimeSpan value. Používá také specifikátor vlastního formátu "FFFFF" v operaci analýzy.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'.

Zpět na tabulkuBack to table

Specifikátor vlastního formátu "FFFFFF"The "FFFFFF" custom format specifier

Specifikátor vlastního formátu "FFFFFF" (obsahující šest znaků F) výstupuje Desetimiliontiny sekundy v časovém intervalu.The "FFFFFF" custom format specifier (with six "F" characters) outputs the millionths of a second in a time interval. V operaci formátování se zkrátí zbývající zlomkové číslice.In a formatting operation, any remaining fractional digits are truncated. Pokud jsou žádné koncové zlomky nula, nejsou zahrnuty ve výsledném řetězci.If there are any trailing fractional zeros, they aren't included in the result string. V operaci analýzy, která volá metodu TimeSpan.ParseExact nebo TimeSpan.TryParseExact, je jako volitelná existence desátých, setinách, sekundy, deseti-sekundy, stě-sekundy a Desetimiliontiny druhé číslice.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.

V následujícím příkladu je použit Specifikátor vlastního formátu "FFFFFF" pro zobrazení Desetimiliontiny sekundy v hodnotě TimeSpan.The following example uses the "FFFFFF" custom format specifier to display the millionths of a second in a TimeSpan value. Používá také tento vlastní specifikátor formátu v operaci analýzy.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'.

Zpět na tabulkuBack to table

Specifikátor vlastního formátu "FFFFFFF"The "FFFFFFF" custom format specifier

Specifikátor vlastního formátu "FFFFFFF" (se sedmi "F" znaky) vytvoří výstup deseti Desetimiliontiny sekundy (nebo desetinné číslo tiků) v časovém intervalu.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. Pokud jsou žádné koncové zlomky nula, nejsou zahrnuty ve výsledném řetězci.If there are any trailing fractional zeros, they aren't included in the result string. V operaci analýzy, která volá metodu TimeSpan.ParseExact nebo TimeSpan.TryParseExact, je přítomnost sedmi zlomkových číslic ve vstupním řetězci volitelná.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.

Následující příklad používá specifikátor vlastního formátu "FFFFFFF" pro zobrazení zlomkových částí sekundy ve TimeSpan hodnotě.The following example uses the "FFFFFFF" custom format specifier to display the fractional parts of a second in a TimeSpan value. Používá také tento vlastní specifikátor formátu v operaci analýzy.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     

Zpět na tabulkuBack to table

Jiné znakyOther characters

Jakýkoli jiný znak bez řídicího znaku ve formátovacím řetězci, včetně prázdného znaku, je interpretován jako specifikátor vlastního formátu.Any other unescaped character in a format string, including a white-space character, is interpreted as a custom format specifier. Ve většině případů přítomnost jakéhokoli jiného neřídicího znaku má za následek FormatException.In most cases, the presence of any other unescaped character results in a FormatException.

Existují dva způsoby, jak zahrnout literální znak do formátovacího řetězce:There are two ways to include a literal character in a format string:

  • Uzavřete ho do jednoduchých uvozovek (literální řetězcový oddělovač).Enclose it in single quotation marks (the literal string delimiter).

  • Před něj uveďte zpětné lomítko ("\"), které je interpretováno jako řídicí znak.Precede it with a backslash ("\"), which is interpreted as an escape character. To znamená, že v C#nástroji musí být formátovací řetězec buď @-quoted, nebo znak literálu musí předcházet další zpětné lomítko.This means that, in C#, the format string must either be @-quoted, or the literal character must be preceded by an additional backslash.

    V některých případech může být nutné použít podmíněnou logiku pro zahrnutí řídicího literálu do řetězce formátu.In some cases, you may have to use conditional logic to include an escaped literal in a format string. V následujícím příkladu je použita podmíněná logika pro zahrnutí symbol znaménka pro záporné časové intervaly.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 nedefinuje gramatiku pro oddělovače v časových intervalech..NET doesn't define a grammar for separators in time intervals. To znamená, že oddělovače mezi dny a hodiny, hodiny a minuty, minuty a sekundy a sekundy a zlomky sekund musí být zpracovány jako znakové literály v řetězci formátu.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.

Následující příklad používá řídicí znak i jednoduchou uvozovku k definování vlastního formátovacího řetězce, který obsahuje slovo "minuty" ve výstupním řetězci.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      

Zpět na tabulkuBack to table

Viz také:See also