Vlastní formátovací řetězce TimeSpan
Formátovací řetězec TimeSpan definuje řetězcové vyjádření hodnoty TimeSpan, která je výsledkem operace formátování. 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ů. Libovolný řetězec, který není standardní formátovací řetězec třídy TimeSpan je interpretován jako vlastní formátovací řetězec TimeSpan.
.gif "Důležitá poznámka") Důležité |
|---|
Vlastní specifikátory formátu třídy TimeSpan neobsahují zástupné symboly oddělovače, jako například symboly, které oddělují dny od hodin, hodiny od minut nebo sekundy od zlomků sekund. Místo toho tyto symboly musí být součástí vlastních formátovacích řetězců jako řetězcové literály.Například "dd\.hh\:mm" definuje tečku (.) jako oddělovač mezi dny a hodinami a dvojtečku (:) jako oddělovač mezi hodinami a minutami. |
Řetězcové reprezentace hodnot TimeSpan jsou vytvářeny voláním přetížení metody TimeSpan.ToString a metodami, které podporují složené formátování, jako například String.Format. Další informace naleznete v tématu Typy formátování a Složené formátování. Následující příklad ukazuje použití vlastních formátovacích řetězců v operacích formátování.
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
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
Vlastní formátovací řetězce TimeSpan jsou také používány metodami TimeSpan.ParseExact a TimeSpan.TryParseExact pro definování požadovaného formátu vstupních řetězců pro operace analýzy. (Analýza převede řetězcovou reprezentaci hodnoty na tuto hodnotu.) Následující příklad ukazuje použití standardního formátovacího řetězce v operacích analýzy.
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
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
Následující tabulka popisuje vlastní specifikátory formátu pro datum a čas.
Specifikátor formátu |
Popis |
Příklad |
|---|---|---|
"d", "%d" |
Počet celých dnů v časovém intervalu. Další informace: Vlastní specifikátor formátu d. |
new TimeSpan(6, 14, 32, 17, 685): %d --> "6" d\.hh\:mm --> "6.14:32" |
"dd"-"dddddddd" |
Počet celých dnů v časovém intervalu doplněný počátečními nulami podle potřeby. Další informace: Vlastní specifikátory formátu "dd"-"dddddddd". |
new TimeSpan(6, 14, 32, 17, 685): ddd --> "006" dd\.hh\:mm --> "06.14:32" |
"h", "%h" |
Počet celých hodin v časovém intervalu, které se nepočítají jako části dnů. Jednociferné označení hodin nemají počáteční nuly. Další informace: Vlastní specifikátor formátu h. |
new TimeSpan(6, 14, 32, 17, 685): %h --> "14" hh\:mm --> "14:32" |
"hh" |
Počet celých hodin v časovém intervalu, které se nepočítají jako části dnů. Jednociferné označení hodiny má počáteční nulu. Další informace: Vlastní specifikátor formátu hh. |
new TimeSpan(6, 14, 32, 17, 685): hh --> "14" new TimeSpan(6, 8, 32, 17, 685): hh --> 08 |
"m", "%m" |
Počet celých minut v časovém intervalu, které nejsou zahrnuty jako části dnů nebo hodin. Jednociferného označení minut nemají počáteční nulu. Další informace: Vlastní specifikátor formátu m. |
new TimeSpan(6, 14, 8, 17, 685): %m --> "8" h\:m --> "14:8" |
"mm" |
Počet celých minut v časovém intervalu, které nejsou zahrnuty jako části dnů nebo hodin. Jednociferné označení minut mají počáteční nulu. Další informace: Vlastní specifikátor formátu mm. |
new TimeSpan(6, 14, 8, 17, 685): mm --> "08" new TimeSpan(6, 8, 5, 17, 685): d\.hh\:mm\:ss --> 6.08:05:17 |
"s", "%s" |
Počet celých sekund v časovém intervalu, které nejsou zahrnuty jako části hodin, dnů nebo minut. Jednociferné označení sekund nemají počáteční nulu. Další informace: Vlastní specifikátor formátu s. |
TimeSpan.FromSeconds(12.965): %s --> 12 s\.fff --> 12.965 |
"ss" |
Počet celých sekund v časovém intervalu, které nejsou zahrnuty jako části hodin, dnů nebo minut. Jednociferné označení sekund mají počáteční nulu. Další informace: Vlastní specifikátor formátu ss. |
TimeSpan.FromSeconds(6.965): ss --> 06 ss\.fff --> 06.965 |
"f", "%f" |
Desetiny sekundy v časovém intervalu. Další informace: Vlastní specifikátor formátu f. |
TimeSpan.FromSeconds(6.895): f --> 8 ss\.f --> 06.8 |
"ff" |
Setiny sekundy v časovém intervalu. Další informace:Vlastní specifikátor formátu ff. |
TimeSpan.FromSeconds(6.895): ff --> 89 ss\.ff --> 06.89 |
"fff" |
Milisekundy v časovém intervalu. Další informace: Vlastní specifikátor formátu fff. |
TimeSpan.FromSeconds(6.895): fff --> 895 ss\.fff --> 06.895 |
"ffff" |
Desetitisíciny sekund v časovém intervalu. Další informace: Vlastní specifikátor formátu ffff. |
TimeSpan.Parse("0:0:6.8954321"): ffff --> 8954 ss\.ffff --> 06.8954 |
"fffff" |
Stotisíciny sekund v časovém intervalu. Další informace: Vlastní specifikátor formátu fffff. |
TimeSpan.Parse("0:0:6.8954321"): fffff --> 89543 ss\.fffff --> 06.89543 |
"ffffff" |
Milióntiny sekundy v časovém intervalu. Další informace: Vlastní specifikátor formátu ffffff. |
TimeSpan.Parse("0:0:6.8954321"): ffffff --> 895432 ss\.ffffff --> 06.895432 |
"fffffff" |
Deseti-milióntiny sekund (nebo zlomkových tiků) v časovém intervalu. Další informace: Vlastní specifikátor formátu fffffff. |
TimeSpan.Parse("0:0:6.8954321"): fffffff --> 8954321 ss\.fffffff --> 06.8954321 |
"F", "%F" |
Desetiny sekundy v časovém intervalu. Nic se nezobrazí v případě, že je číslice nula. Další informace: Vlastní specifikátor formátu F. |
TimeSpan.Parse("00:00:06.32"): %F: 3 TimeSpan.Parse("0:0:3.091"): ss\.F: 03. |
"FF" |
Setiny sekundy v časovém intervalu. Jakékoli koncové zlomkové nuly nebo dvě nuly nejsou zahrnuty. Další informace: Vlastní specifikátor formátu "FF". |
TimeSpan.Parse("00:00:06.329"): FF: 32 TimeSpan.Parse("0:0:3.101"): ss\.FF: 03.1 |
FFF |
Milisekundy v časovém intervalu. Jakékoli zlomkové koncové nuly nejsou zahrnuty. Další informace: |
TimeSpan.Parse("00:00:06.3291"): FFF: 329 TimeSpan.Parse("0:0:3.1009"): ss\.FFF: 03.1 |
FFFF |
Desetitisíciny sekund v časovém intervalu. Jakékoli zlomkové koncové nuly nejsou zahrnuty. Další informace: Vlastní specifikátor formátu FFFF. |
TimeSpan.Parse("00:00:06.32917"): FFFFF: 3291 TimeSpan.Parse("0:0:3.10009"): ss\.FFFF: 03.1 |
FFFFF |
Stotisíciny sekund v časovém intervalu. Jakékoli zlomkové koncové nuly nejsou zahrnuty. Další informace: Vlastní specifikátor formátu FFFFF. |
TimeSpan.Parse("00:00:06.329179"): FFFFF: 32917 TimeSpan.Parse("0:0:3.100009"): ss\.FFFFF: 03.1 |
FFFFFF |
Milióntiny sekundy v časovém intervalu. Jakékoli zlomkové koncové nuly se nezobrazí. Další informace: Vlastní specifikátor formátu FFFFFF. |
TimeSpan.Parse("00:00:06.3291791"): FFFFFF: 329179 TimeSpan.Parse("0:0:3.1000009"): ss\.FFFFFF: 03.1 |
FFFFFFF |
Desetimiliontiny sekund v časovém intervalu. Jakékoli koncové zlomkové nuly nebo sedm nul se nezobrazí. Další informace: Vlastní specifikátor formátu FFFFFFF. |
TimeSpan.Parse("00:00:06.3291791"): FFFFFF: 3291791 TimeSpan.Parse("0:0:3.1900000"): ss\.FFFFFF: 03.19 |
'string' |
Oddělovač literálního řetězce. Další informace: Jiné znaky. |
new TimeSpan(14, 32, 17): hh':'mm':'ss --> "14:32:17" |
\ |
Řídící znak. Další informace: Ostatní znaky. |
new TimeSpan(14, 32, 17): hh\:mm\:ss --> "14:32:17" |
Jakýkoli jiný znak |
Jakýkoli jiný znak bez řídícího znaku je interpretován jako vlastní specifikátor formátu. Další informace: Jiné znaky. |
new TimeSpan(14, 32, 17): hh\:mm\:ss --> "14:32:17" |
Vlastní specifikátor formátu d.
Vlastní specifikátor formátu d vyprodukuje hodnotu vlastnosti TimeSpan.Days, která představuje počet celých dnů v časovém intervalu. Vyprodukuje plný počet dnů v hodnotě TimeSpan, i když má hodnota více než jednu číslici. Pokud je hodnota vlastnosti TimeSpan.Days nula, výstup specifikátoru je 0.
Pokud je vlastní specifikátor formátu d použitý samostatně, zadejte %d", aby nebyl chybně interpretován jako standardní formátovací řetězec. Následující příklad uvádí ukázku.
Dim ts As New TimeSpan(16, 4, 3, 17, 250)
Console.WriteLine(ts.ToString("%d"))
' Displays 16
TimeSpan ts1 = new TimeSpan(16, 4, 3, 17, 250);
Console.WriteLine(ts1.ToString("%d"));
// Displays 16
Následující příklad ukazuje použití vlastního specifikátoru formátu d.
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
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
Zpět na tabulku
Vlastní specifikátory formátu dd-dddddddd.
Vlastní specifikátory formátu dd, ddd, dddd, ddddd, dddddd, ddddddd a dddddddd produkují výstupní hodnotu vlastnosti TimeSpan.Days, která představuje počet celých dnů v časovém intervalu.
Výstupní řetězec obsahuje minimální počet číslic určených počtem znaků d ve specifikátoru formátu a je doplněn počátečními nulami podle potřeby. Pokud číslice v počtu dní překročí počet znaků d ve specifikátoru formátu, je výstupem ve výsledném řetězci úplný počet dní.
Následujícím příklad používá tyto specifikátory formátu pro zobrazení řetězcové reprezentace dvou hodnot TimeSpan. Hodnota komponenty dnů prvního časového intervalu je nula. Hodnota komponenty dní druhého intervalu je 365.
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
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
Zpět na tabulku
Vlastní specifikátor formátu h.
Vlastní specifikátor formátu h vyprodukuje výstupní hodnotu vlastnosti TimeSpan.Hours, která představuje počet celých hodin v časovém intervalu, které nejsou počítány jako část komponenty dní. Vrátí jednocifernou řetězcovou hodnotu, jestliže hodnota vlastnosti TimeSpan.Hours je 0 až 9 a vrátí dvoucifernou řetězcovou hodnotu, jestliže je hodnota vlastnosti TimeSpan.Hours v rozsahu od 10 do 23.
Pokud je vlastní specifikátor formátu h použitý samostatně, zadejte %h, aby nebyl chybně interpretován jako standardní formátovací řetězec. Následující příklad uvádí ukázku.
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
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
Obvykle v rámci operace analýzy, vstupní řetězec, který obsahuje pouze jedno číslo je interpretován jako počet dní. Můžete použít vlastní specifikátor formátu %h místo interpretace číselného řetězce jako počet hodin. Následující příklad uvádí ukázku.
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
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
Následující příklad ukazuje použití vlastního specifikátoru formátu h.
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
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
Zpět na tabulku
Vlastní specifikátor formátu hh.
Vlastní specifikátor formátu hh vyprodukuje výstupní hodnotu vlastnosti TimeSpan.Hours, která představuje počet celých hodin v časovém intervalu, které nejsou počítány jako část komponenty dní. Pro hodnoty od 0 do 9 obsahuje výstupní řetězec počáteční nuly.
Obvykle v rámci operace analýzy, vstupní řetězec, který obsahuje pouze jedno číslo je interpretován jako počet dní. Můžete použít vlastní specifikátor formátu hh místo interpretace číselného řetězce jako počet hodin. Následující příklad uvádí ukázku.
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
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
Následující příklad ukazuje použití vlastního specifikátoru formátu hh.
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
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
Zpět na tabulku
Vlastní specifikátor formátu m.
Vlastní specifikátor formátu m vyprodukuje výstupní hodnotu vlastnosti TimeSpan.Minutes, která představuje počet celých minut v časovém intervalu, které nejsou počítány jako část komponenty dní. Vrátí jednocifernou řetězcovou hodnotu, jestliže hodnota vlastnosti TimeSpan.Minutes je 0 až 9 a vrátí dvoucifernou řetězcovou hodnotu, jestliže je hodnota vlastnosti TimeSpan.Minutes rozsahu od 10 do 59.
Pokud je vlastní specifikátor formátu m použitý samostatně, zadejte %m, aby nebyl chybně interpretován jako standardní formátovací řetězec. Následující příklad uvádí ukázku.
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
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
Obvykle v rámci operace analýzy, vstupní řetězec, který obsahuje pouze jedno číslo je interpretován jako počet dní. Můžete použít vlastní specifikátor formátu %m místo interpretace číselného řetězce jako počet minut. Následující příklad uvádí ukázku.
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
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
Následující příklad ukazuje použití vlastního specifikátoru formátu m.
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
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
Zpět na tabulku
Vlastní specifikátor formátu mm.
Vlastní specifikátor formátu mm vyprodukuje výstupní hodnotu vlastnosti TimeSpan.Minutes, která představuje počet celých minut v časovém intervalu, které nejsou zahrnuty jako část hodin a dnů. Pro hodnoty od 0 do 9 obsahuje výstupní řetězec počáteční nuly.
Obvykle v rámci operace analýzy, vstupní řetězec, který obsahuje pouze jedno číslo je interpretován jako počet dní. Můžete použít vlastní specifikátor formátu mm místo interpretace číselného řetězce jako počet minut. Následující příklad uvádí ukázku.
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
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
Následující příklad ukazuje použití vlastního specifikátoru formátu mm.
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
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
Zpět na tabulku
Vlastní specifikátor formátu s.
Vlastní specifikátor formátu s vyprodukuje výstupní hodnotu vlastnosti TimeSpan.Seconds, která představuje počet celých sekund v časovém intervalu, které nejsou zahrnuty jako část komponenty hodin, dnů nebo minut. Vrátí jednocifernou řetězcovou hodnotu, jestliže hodnota vlastnosti TimeSpan.Seconds je 0 až 9 a vrátí dvoucifernou řetězcovou hodnotu, jestliže je hodnota vlastnosti TimeSpan.Seconds v rozsahu od 10 do 59.
Pokud je vlastní specifikátor formátu s použitý samostatně, zadejte %s, aby nebyl chybně interpretován jako standardní formátovací řetězec. Následující příklad uvádí ukázku.
Dim ts As TimeSpan = TimeSpan.FromSeconds(12.465)
Console.WriteLine(ts.ToString("%s"))
' The example displays the following output:
' 12
TimeSpan ts = TimeSpan.FromSeconds(12.465);
Console.WriteLine(ts.ToString("%s"));
// The example displays the following output:
// 12
Obvykle v rámci operace analýzy, vstupní řetězec, který obsahuje pouze jedno číslo je interpretován jako počet dní. Můžete použít vlastní specifikátor formátu %s místo interpretace číselného řetězce jako počet sekund. Následující příklad uvádí ukázku.
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
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
Následující příklad ukazuje použití vlastního specifikátoru formátu s.
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
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
Zpět na tabulku
Vlastní specifikátor formátu ss.
Vlastní specifikátor formátu ss vyprodukuje výstupní hodnotu vlastnosti TimeSpan.Seconds, která představuje počet celých sekund v časovém intervalu, které nejsou zahrnuty jako část komponenty hodin, dnů nebo minut. Pro hodnoty od 0 do 9 obsahuje výstupní řetězec počáteční nuly.
Obvykle v rámci operace analýzy, vstupní řetězec, který obsahuje pouze jedno číslo je interpretován jako počet dní. Můžete použít vlastní specifikátor formátu ss místo interpretace číselného řetězce jako počet sekund. Následující příklad uvádí ukázku.
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
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
Následující příklad ukazuje použití vlastního specifikátoru formátu ss.
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
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
Zpět na tabulku
Vlastní specifikátor formátu f.
Výstupem vlastního specifikátoru formátu f jsou desetiny sekundy v časovém intervalu. Během operace formátování jsou zkráceny všechny zbývající zlomkové číslice. V operaci analýzy, která volá metodu TimeSpan.ParseExact nebo TimeSpan.TryParseExact, vstupní řetězec musí obsahovat přesně jednu zlomkovou číslici.
Pokud je vlastní specifikátor formátu f použitý samostatně, zadejte %f, aby nebyl chybně interpretován jako standardní formátovací řetězec.
Následující příklad používá vlastní specifikátor formátu f pro zobrazení desetin sekundy v hodnotě TimeSpan. " Specifikátor f je použitý nejdříve jako jediný specifikátor formátu a potom v kombinaci se specifikátorem s ve vlastním formátovacím řetězci.
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
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
Zpět na tabulku
Vlastní specifikátor formátu ff.
Výstupem vlastního specifikátoru formátu ff jsou setiny sekundy v časovém intervalu. Během operace formátování jsou zkráceny všechny zbývající zlomkové číslice. V operaci analýzy, která volá metodu TimeSpan.ParseExact nebo TimeSpan.TryParseExact, vstupní řetězec musí obsahovat přesně dvě zlomkové číslice.
Následující příklad používá vlastní specifikátor formátu ff pro zobrazení setin sekundy v hodnotě TimeSpan. " Specifikátor ff je použitý nejdříve jako jediný specifikátor formátu a potom v kombinaci se specifikátorem s ve vlastním formátovacím řetězci.
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
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
Zpět na tabulku
Vlastní specifikátor formátu fff.
Vlastní specifikátor formátu fff (se třemi znaky f) poskytuje jako výstup milisekundy v časovém intervalu. Během operace formátování jsou zkráceny všechny zbývající zlomkové číslice. V operaci analýzy, která volá metodu TimeSpan.ParseExact nebo TimeSpan.TryParseExact, vstupní řetězec musí obsahovat přesně tři zlomkové číslice.
Následující příklad používá vlastní specifikátor formátu fff pro zobrazení milisekundy v hodnotě TimeSpan. " Specifikátor fff je použitý nejdříve jako jediný specifikátor formátu a potom v kombinaci se specifikátorem s ve vlastním formátovacím řetězci.
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
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
Zpět na tabulku
Vlastní specifikátor formátu ffff.
Vlastní specifikátor formátu ffff (se čtyřmi znaky f) poskytuje jako výstup desetitisíciny sekund v časovém intervalu. Během operace formátování jsou zkráceny všechny zbývající zlomkové číslice. V operaci analýzy, která volá metodu TimeSpan.ParseExact nebo TimeSpan.TryParseExact, vstupní řetězec musí obsahovat přesně čtyři zlomkové číslice.
Následující příklad používá vlastní specifikátor formátu ffff pro zobrazení desetitisícín sekundy v hodnotě TimeSpan. " Specifikátor ffff je použitý nejdříve jako jediný specifikátor formátu a potom v kombinaci se specifikátorem s ve vlastním formátovacím řetězci.
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
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
Zpět na tabulku
Vlastní specifikátor formátu fffff.
Vlastní specifikátor formátu fffff (s pěti znaky f) poskytuje jako výstup stotisíciny sekund v časovém intervalu. Během operace formátování jsou zkráceny všechny zbývající zlomkové číslice. V operaci analýzy, která volá metodu TimeSpan.ParseExact nebo TimeSpan.TryParseExact, vstupní řetězec musí obsahovat přesně pět zlomkových číslic.
Následující příklad používá vlastní specifikátor formátu fffff pro zobrazení stotisícin sekundy v hodnotě TimeSpan. " Specifikátor fffff je použitý nejdříve jako jediný specifikátor formátu a potom v kombinaci se specifikátorem s ve vlastním formátovacím řetězci.
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
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
Zpět na tabulku
Vlastní specifikátor formátu ffffff.
Vlastní specifikátor formátu ffffff (s šesti znaky f) poskytuje výstup miliontin sekundy v časovém intervalu. Během operace formátování jsou zkráceny všechny zbývající zlomkové číslice. V operaci analýzy, která volá metodu TimeSpan.ParseExact nebo TimeSpan.TryParseExact, vstupní řetězec musí obsahovat přesně šest zlomkových číslic.
Následující příklad používá vlastní specifikátor formátu ffffff pro zobrazení miliontin sekundy v hodnotě TimeSpan. Je použitý nejdříve jako jediný specifikátor formátu a potom v kombinaci se specifikátorem s ve vlastním formátovacím řetězci.
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
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
Zpět na tabulku
Vlastní specifikátor formátu fffffff.
Vlastní specifikátor formátu fffffff (se sedmi znaky f) poskytuje výstup desetimiliontin sekundy (nebo zlomkový počet tiků) v časovém intervalu. V operaci analýzy, která volá metodu TimeSpan.ParseExact nebo TimeSpan.TryParseExact, vstupní řetězec musí obsahovat přesně sedm zlomkových číslic.
Následující příklad používá vlastní specifikátor formátu fffffff pro zobrazení zlomkového počtu tiků v hodnotě TimeSpan. Je použitý nejdříve jako jediný specifikátor formátu a potom v kombinaci se specifikátorem s ve vlastním formátovacím řetězci.
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
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
Zpět na tabulku
Vlastní specifikátor formátu F.
Výstupem vlastního specifikátoru formátu F jsou desetiny sekundy v časovém intervalu. Během operace formátování jsou zkráceny všechny zbývající zlomkové číslice. Pokud je hodnota časového intervalu desetin sekund nula, není zahrnutý ve výsledném řetězci. V operaci analýzy, která volá metodu TimeSpan.ParseExact nebo TimeSpan.TryParseExact, je přítomnost číslice desetin sekund volitelná.
Pokud je vlastní specifikátor formátu F použitý samostatně, zadejte %F, aby nebyl chybně interpretován jako standardní formátovací řetězec.
Následující příklad používá vlastní specifikátor formátu F pro zobrazení desetin sekundy v hodnotě TimeSpan. V rámci operace analýzy také používá vlastní specifikátor formátu.
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'.
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'.
Zpět na tabulku
Vlastní specifikátor formátu FF.
Výstupem vlastního specifikátoru formátu FF jsou setiny sekundy v časovém intervalu. Během operace formátování jsou zkráceny všechny zbývající zlomkové číslice. Pokud tam jsou jakékoli koncové zlomkové nuly, nejsou zahrnuty ve výsledném řetězci. V operaci analýzy, která volá metodu TimeSpan.ParseExact nebo TimeSpan.TryParseExact, je přítomnost číslice setin sekund volitelná.
Následující příklad používá vlastní specifikátor formátu FF pro zobrazení setin sekundy v hodnotě TimeSpan. V rámci operace analýzy také používá vlastní specifikátor formátu.
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'.
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'.
Zpět na tabulku
Vlastní specifikátor formátu FFF.
Vlastní specifikátor formátu FFF (se třemi znaky F) poskytuje jako výstup milisekundy v časovém intervalu. Během operace formátování jsou zkráceny všechny zbývající zlomkové číslice. Pokud tam jsou jakékoli koncové zlomkové nuly, nejsou zahrnuty ve výsledném řetězci. V operaci analýzy, která volá metodu TimeSpan.ParseExact nebo TimeSpan.TryParseExact, je přítomnost číslice desetin, setin a tisícin sekundy volitelná.
Následující příklad používá vlastní specifikátor formátu FFF pro zobrazení tisícín sekundy v hodnotě TimeSpan. V rámci operace analýzy také používá vlastní specifikátor formátu.
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'.
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'.
Zpět na tabulku
Vlastní specifikátor formátu FFFF.
Vlastní specifikátor formátu FFFF (se čtyřmi znaky F) poskytuje jako výstup desetitisíciny sekund v časovém intervalu. Během operace formátování jsou zkráceny všechny zbývající zlomkové číslice. Pokud tam jsou jakékoli koncové zlomkové nuly, nejsou zahrnuty ve výsledném řetězci. V operaci analýzy, která volá metodu TimeSpan.ParseExact nebo TimeSpan.TryParseExact, je přítomnost číslice desetin, setin, tisícin a desetitisícín sekundy volitelná.
Následující příklad používá vlastní specifikátor formátu FFFF pro zobrazení desetitisícín sekundy v hodnotě TimeSpan. V rámci operace analýzy také používá vlastní specifikátor formátu 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'.
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'.
Zpět na tabulku
Vlastní specifikátor formátu FFFFF.
Vlastní specifikátor formátu FFFFF (s pěti znaky F) poskytuje jako výstup stotisíciny sekund v časovém intervalu. Během operace formátování jsou zkráceny všechny zbývající zlomkové číslice. Pokud tam jsou jakékoli koncové zlomkové nuly, nejsou zahrnuty ve výsledném řetězci. V operaci analýzy, která volá metodu TimeSpan.ParseExact nebo TimeSpan.TryParseExact, je přítomnost číslice desetin, setin, tisícin, desetitisícín a stotisícin sekundy volitelná.
Následující příklad používá vlastní specifikátor formátu FFFFF pro zobrazení stotisícin sekundy v hodnotě TimeSpan. V rámci operace analýzy také používá vlastní specifikátor formátu FFFFF.
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'.
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'.
Zpět na tabulku
Vlastní specifikátor formátu FFFFFF.
Vlastní specifikátor formátu FFFFFF (s šesti znaky FFFFFF) poskytuje výstup miliontin sekundy v časovém intervalu. Během operace formátování jsou zkráceny všechny zbývající zlomkové číslice. Pokud tam jsou jakékoli koncové zlomkové nuly, nejsou zahrnuty ve výsledném řetězci. V operaci analýzy, která volá metodu TimeSpan.ParseExact nebo TimeSpan.TryParseExact, je přítomnost číslice desetin, setin, tisícin, desetitisícín, stotisícin a miliontin sekundy volitelná.
Následující příklad používá vlastní specifikátor formátu FFFFFF pro zobrazení miliontin sekundy v hodnotě TimeSpan. V rámci operace analýzy také používá vlastní specifikátor formátu.
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'.
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'.
Zpět na tabulku
Vlastní specifikátor formátu FFFFFFF.
Vlastní specifikátor formátu FFFFFFF (se sedmi znaky F) poskytuje výstup desetimiliontin sekundy (nebo zlomkový počet tiků) v časovém intervalu. Pokud tam jsou jakékoli koncové zlomkové nuly, nejsou zahrnuty ve výsledném řetězci. V operace analýzy, která volá metodu TimeSpan.ParseExact nebo TimeSpan.TryParseExact, je přítomnost sedmi zlomkových číslic ve vstupní řetězci volitelná.
Následující příklad používá vlastní specifikátor formátu FFFFFFF pro zobrazení zlomkových částí sekundy v hodnotě TimeSpan. V rámci operace analýzy také používá vlastní specifikátor formátu.
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
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
Zpět na tabulku
Ostatní znaky
Jakýkoli jiný znak bez řídícího znaku ve formátovacím řetězci, včetně prázdných znaků, je interpretován jako vlastní specifikátor formátu. Ve většině případů vede přítomnost jiných znaků bez řídících znaků k FormatException.
Existují dva způsoby, jak zahrnout literální znak ve formátovacím řetězci:
Vložte jej do jednoduchých uvozovek (literální oddělovač řetězce).
Uveďte před ním zpětné lomítko \, které je interpretováno jako řídicí znak. To znamená, že v jazyce C# formátovací řetězec musí být buď @-quoted nebo další zpětné lomítko musí předcházet literální znak.
Rozhraní .NET Framework nedefinuje gramatiku pro oddělovače v časových intervalech. To znamená, že se všemi oddělovačemi mezi dny a hodinami, hodinami a minutami, minutami a sekundami a sekundami a zlomky sekundy musí být zacházeno jako s literálními znaky ve formátovacím řetězci.
Následující příklad používá řídicí znaky i jednoduchou uvozovku pro definování vlastního formátovacího řetězce, který obsahuje slovo minuty ve výstupním řetězci.
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
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
Zpět na tabulku