Vlastní řetězce formátu TimeSpan
Formátovací TimeSpan řetězec definuje řetězcovou reprezentaci TimeSpan hodnoty, která je výsledkem operace formátování. Řetězec vlastního formátu se skládá z jednoho nebo více specifikátorů vlastního TimeSpan formátu spolu s libovolným počtem literálových znaků. Každý řetězec, který není standardním řetězcem formátu TimeSpan , se interpretuje jako řetězec vlastního TimeSpan formátu.
Důležité
Specifikátory vlastního TimeSpan formátu neobsahují zástupné symboly oddělovače, například symboly, které oddělují dny od hodin, hodiny od minut nebo sekundy od zlomků sekund. Místo toho musí být tyto symboly součástí řetězce vlastního formátu 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 hodinou a minutou.
Specifikátory vlastního TimeSpan formátu také neobsahují symbol znaménka, který umožňuje rozlišovat mezi zápornými a kladnými časovými intervaly. Pokud chcete zahrnout symbol znaménka, musíte vytvořit formátovací řetězec pomocí podmíněné logiky. Část Další znaky obsahuje příklad.
Řetězcová reprezentace TimeSpan hodnot se vytváří voláním přetížení TimeSpan.ToString metody a metodami, které podporují složené formátování, například String.Format. Další informace najdete v tématu Typy formátování a Složené formátování. Následující příklad ukazuje použití řetězců vlastního formátu v operacích formátování.
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í TimeSpan formátovací řetězce jsou také používány metodami TimeSpan.ParseExact a TimeSpan.TryParseExact k definování požadovaného formátu vstupních řetězců pro operace analýzy. (Analýza převede řetězcovou reprezentaci hodnoty na danou hodnotu.) Následující příklad ukazuje použití řetězců standardního formátu v operacích analýzy.
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 vlastní specifikátory formátu data a času.
| Specifikátor formátu | Popis | Příklad |
|---|---|---|
| "d", "%d" | Počet celých dnů v časovém intervalu. Další informace: Specifikátor vlastního formátu "d". |
new TimeSpan(6, 14, 32, 17, 685):%d --> "6"d\.hh\:mm --> "6,14:32" |
| "dd"-"ddddddddd" | Počet celých dnů v časovém intervalu s počátečními nulami podle potřeby. Další informace: Specifikátory vlastního formátu "ddddddddd". |
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 nezapočítávají do dnů. Jednociferné hodiny nemají úvodní nulu. Další informace: Specifikátor vlastního 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 nezapočítávají do dnů. Jednociferné hodiny mají úvodní nulu. Další informace: Specifikátor vlastního 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 zahrnuté do hodin nebo dnů. Jednociferné minuty nemají úvodní nulu. Další informace: Specifikátor vlastního 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 zahrnuté do hodin nebo dnů. Jednociferné minuty mají úvodní nulu. Další informace: Specifikátor vlastního 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 zahrnuté v hodinách, dnech nebo minutách. Jednociferné číslo sekund nemá úvodní nulu. Další informace: Specifikátor vlastního formátu "s". |
TimeSpan.FromSeconds(12.965):%s --> 12s\.fff --> 12.965 |
| "ss" | Počet celých sekund v časovém intervalu, které nejsou zahrnuté v hodinách, dnech nebo minutách. Jednociferné sekundy mají úvodní nulu. Další informace: Specifikátor vlastního formátu "ss". |
TimeSpan.FromSeconds(6.965):ss --> 06ss\.fff --> 06,965 |
| "f", "%f" | Desetinu sekundy v časovém intervalu. Další informace: Specifikátor vlastního formátu "f". |
TimeSpan.FromSeconds(6.895):f --> 8ss\.f --> 06,8 |
| "ff" | Setiny sekundy v časovém intervalu Další informace: Specifikátor vlastního formátu "ff". |
TimeSpan.FromSeconds(6.895):ff --> 89ss\.ff --> 06,89 |
| "fff" | Milisekundy v časovém intervalu. Další informace: Specifikátor vlastního formátu "fff". |
TimeSpan.FromSeconds(6.895):fff --> 895ss\.fff --> 06,895 |
| "ffff" | Desetitisíciny sekundy v časovém intervalu. Další informace: Specifikátor vlastního formátu "ffff". |
TimeSpan.Parse("0:0:6.8954321"):ffff --> 8954ss\.ffff --> 06,8954 |
| "fffff" | Stotisítiny sekundy v časovém intervalu. Další informace: Specifikátor vlastního formátu "fffff". |
TimeSpan.Parse("0:0:6.8954321"):fffff --> 89543ss\.fffff --> 06,89543 |
| "ffffff" | Milioniny sekundy v časovém intervalu Další informace: Specifikátor vlastního formátu "ffffff". |
TimeSpan.Parse("0:0:6.8954321"):ffffff --> 895432ss\.ffffff --> 06,895432 |
| "fffffff" | Desetimiliontiny sekundy (nebo zlomkové škrty) v časovém intervalu. Další informace: Specifikátor vlastního formátu "fffffff". |
TimeSpan.Parse("0:0:6.8954321"):fffffff --> 8954321ss\.fffffff --> 06,8954321 |
| "F", "%F" | Desetinu sekundy v časovém intervalu. Pokud je číslice nula, nezobrazí se žádná hodnota. Další informace: Specifikátor vlastního formátu "F". |
TimeSpan.Parse("00:00:06.32"):%F: 3TimeSpan.Parse("0:0:3.091"):ss\.F: 03. |
| "FF" | Setiny sekundy v časovém intervalu Nezahrnou se žádné koncové desetinné koncové nuly ani dvě číslice nuly. Další informace: Specifikátor vlastního formátu "FF". |
TimeSpan.Parse("00:00:06.329"):FF: 32TimeSpan.Parse("0:0:3.101"):ss\.FF: 03.1 |
| "FFF" | Milisekundy v časovém intervalu. Koncové desetinné koncové nuly se nezahrnou. Další informace: |
TimeSpan.Parse("00:00:06.3291"):FFF: 329TimeSpan.Parse("0:0:3.1009"):ss\.FFF: 03.1 |
| "FFFF" | Desetitisíciny sekundy v časovém intervalu. Koncové desetinné koncové nuly se nezahrnou. Další informace: Specifikátor vlastního formátu "FFFF". |
TimeSpan.Parse("00:00:06.32917"):FFFFF: 3291TimeSpan.Parse("0:0:3.10009"):ss\.FFFF: 03.1 |
| "FFFFF" | Stotisítiny sekundy v časovém intervalu. Koncové desetinné koncové nuly se nezahrnou. Další informace: Specifikátor vlastního formátu "FFFFF". |
TimeSpan.Parse("00:00:06.329179"):FFFFF: 32917TimeSpan.Parse("0:0:3.100009"):ss\.FFFFF: 03.1 |
| "FFFFFF" | Milioniny sekundy v časovém intervalu Koncové desetinné koncové nuly se nezobrazí. Další informace: Specifikátor vlastního formátu "FFFFFF". |
TimeSpan.Parse("00:00:06.3291791"):FFFFFF: 329179TimeSpan.Parse("0:0:3.1000009"):ss\.FFFFFF: 03.1 |
| "FFFFFFF" | Deset milionů sekund v časovém intervalu. Koncové desetinné koncové nuly nebo sedm nul se nezobrazí. Další informace: Specifikátor vlastního formátu "FFFFFFF". |
TimeSpan.Parse("00:00:06.3291791"):FFFFFF: 3291791TimeSpan.Parse("0:0:3.1900000"):ss\.FFFFFF: 03.19 |
| 'řetězec' | Oddělovač řetězcového literálu. Další informace: Další znaky. |
new TimeSpan(14, 32, 17):hh':'mm':'ss --> "14:32:17" |
| \ | Řídicí znak. Další informace: Další znaky. |
new TimeSpan(14, 32, 17):hh\:mm\:ss --> "14:32:17" |
| Jakýkoli jiný znak | Jakýkoli jiný znak bez panoramatu je interpretován jako specifikátor vlastního formátu. Další informace: Další znaky. |
new TimeSpan(14, 32, 17):hh\:mm\:ss --> "14:32:17" |
Specifikátor vlastního formátu "d"
Specifikátor vlastního TimeSpan.Days formátu "d" vypíše hodnotu vlastnosti , která představuje počet celých dnů v časovém intervalu. Výstupem je úplný počet dní v hodnotě TimeSpan , i když má hodnota více než jednu číslici. Pokud je hodnota TimeSpan.Days vlastnosti nula, specifikátor vypíše hodnotu "0".
Pokud se specifikátor vlastního formátu "d" používá samostatně, zadejte "%d", aby nebyl nesprávně interpretován jako standardní formátovací řetězec. V následujícím příkladu je uvedena ukázka.
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 ukazuje použití specifikátoru vlastního formátu "d".
TimeSpan ts2 = new TimeSpan(4, 3, 17);
Console.WriteLine(ts2.ToString(@"d\.hh\:mm\:ss"));
TimeSpan ts3 = new TimeSpan(3, 4, 3, 17);
Console.WriteLine(ts3.ToString(@"d\.hh\:mm\:ss"));
// The example displays the following output:
// 0.04:03:17
// 3.04:03:17
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
Specifikátory vlastního formátu "ddddddddd"
Specifikátory vlastního formátu "ddd", "dd", "ddddd", "dddddd", "dddddd" a "dddddddd" výstupem hodnoty TimeSpan.Days vlastnosti, která představuje počet celých dnů v časovém intervalu.
Výstupní řetězec obsahuje minimální počet číslic určený počtem znaků "d" ve specifikátoru formátu a podle potřeby je vyplněný počátečními nulami. Pokud číslice v počtu dnů překročí počet znaků "d" ve specifikátoru formátu, ve výsledném řetězci se zobrazí celý počet dnů.
Následující příklad používá tyto specifikátory formátu k zobrazení řetězcové reprezentace dvou TimeSpan hodnot. Hodnota dny součást prvního časového intervalu je nula; hodnota složky days sekundy je 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
Specifikátor vlastního formátu "h"
Specifikátor vlastního TimeSpan.Hours formátu "h" vypíše hodnotu vlastnosti , která představuje počet celých hodin v časovém intervalu, který se nezapočítává jako součást komponenty dne. Vrátí hodnotu jednociferného řetězce, pokud je hodnota TimeSpan.Hours vlastnosti 0 až 9, a vrátí dvoumístnou řetězcovou hodnotu, pokud je hodnota vlastnosti v rozsahu TimeSpan.Hours od 10 do 23.
Pokud se specifikátor vlastního formátu "h" používá samostatně, zadejte "%h", aby nebyl nesprávně interpretován jako řetězec standardního formátu. V následujícím příkladu je uvedena ukázka.
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
Při operaci analýzy se obvykle vstupní řetězec, který obsahuje pouze jedno číslo, interpretuje jako počet dnů. K interpretaci číselného řetězce jako počtu hodin můžete místo toho použít specifikátor vlastního formátu %h. V následujícím příkladu je uvedena ukázka.
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 ukazuje použití specifikátoru vlastního formátu "h".
TimeSpan ts1 = new TimeSpan(14, 3, 17);
Console.WriteLine(ts1.ToString(@"d\.h\:mm\:ss"));
TimeSpan ts2 = new TimeSpan(3, 4, 3, 17);
Console.WriteLine(ts2.ToString(@"d\.h\:mm\:ss"));
// The example displays the following output:
// 0.14:03:17
// 3.4:03:17
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
Specifikátor vlastního formátu "hh"
Specifikátor vlastního TimeSpan.Hours formátu "hh" vypíše hodnotu vlastnosti , která představuje počet celých hodin v časovém intervalu, který se nezapočítává jako součást komponenty dne. Pro hodnoty od 0 do 9 obsahuje výstupní řetězec úvodní nulu.
Při operaci analýzy se obvykle vstupní řetězec, který obsahuje pouze jedno číslo, interpretuje jako počet dnů. Místo toho můžete použít specifikátor vlastního formátu "hh" a interpretovat číselný řetězec jako počet hodin. V následujícím příkladu je uvedena ukázka.
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 ukazuje použití specifikátoru vlastního formátu "hh".
TimeSpan ts1 = new TimeSpan(14, 3, 17);
Console.WriteLine(ts1.ToString(@"d\.hh\:mm\:ss"));
TimeSpan ts2 = new TimeSpan(3, 4, 3, 17);
Console.WriteLine(ts2.ToString(@"d\.hh\:mm\:ss"));
// The example displays the following output:
// 0.14:03:17
// 3.04:03:17
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
Specifikátor vlastního formátu "m"
Specifikátor vlastního TimeSpan.Minutes formátu "m" vypíše hodnotu vlastnosti , která představuje počet celých minut v časovém intervalu, který se nezapočítává do jeho komponenty day. Vrátí hodnotu jednociferného řetězce, pokud je hodnota TimeSpan.Minutes vlastnosti 0 až 9, a vrátí hodnotu dvoumístného řetězce, pokud se hodnota TimeSpan.Minutes vlastnosti pohybuje od 10 do 59.
Pokud je specifikátor vlastního formátu "m" použit samostatně, zadejte "%m", aby nebyl nesprávně interpretován jako standardní formátovací řetězec. V následujícím příkladu je uvedena ukázka.
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
Při operaci analýzy se obvykle vstupní řetězec, který obsahuje pouze jedno číslo, interpretuje jako počet dnů. K interpretaci číselného řetězce jako počtu minut můžete použít specifikátor vlastního formátu %m. V následujícím příkladu je uvedena ukázka.
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 ukazuje použití specifikátoru vlastního formátu "m".
TimeSpan ts1 = new TimeSpan(0, 6, 32);
Console.WriteLine("{0:m\\:ss} minutes", ts1);
TimeSpan ts2 = new TimeSpan(3, 4, 3, 17);
Console.WriteLine("Elapsed time: {0:m\\:ss}", ts2);
// The example displays the following output:
// 6:32 minutes
// Elapsed time: 18:44
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
Specifikátor vlastního formátu "mm"
Specifikátor vlastního TimeSpan.Minutes formátu "mm" vypíše hodnotu vlastnosti, která představuje počet celých minut v časovém intervalu, který není zahrnut jako součást komponenty hodin nebo dnů. Pro hodnoty od 0 do 9 obsahuje výstupní řetězec úvodní nulu.
Obvykle se při operaci parsování vstupní řetězec, který obsahuje pouze jedno číslo, interpretuje jako počet dnů. Místo toho můžete použít specifikátor vlastního formátu "mm" k interpretaci číselného řetězce jako počtu minut. V následujícím příkladu je uvedena ukázka.
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 ukazuje použití specifikátoru vlastního formátu "mm".
TimeSpan departTime = new TimeSpan(11, 12, 00);
TimeSpan arriveTime = new TimeSpan(16, 28, 00);
Console.WriteLine("Travel time: {0:hh\\:mm}",
arriveTime - departTime);
// The example displays the following output:
// Travel time: 05:16
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
Specifikátor vlastního formátu "s"
Specifikátor vlastního TimeSpan.Seconds formátu "s" vypíše hodnotu vlastnosti, která představuje počet celých sekund v časovém intervalu, který není zahrnut jako součást jeho hodin, dnů nebo minut. Vrátí hodnotu řetězce s jedním číslicemi, pokud je hodnota TimeSpan.Seconds vlastnosti 0 až 9, a vrátí dvoumístnou řetězcovou hodnotu, pokud se hodnota TimeSpan.Seconds vlastnosti pohybuje od 10 do 59.
Pokud se specifikátor vlastního formátu "s" používá samostatně, zadejte %s, aby nebyl nesprávně interpretován jako řetězec standardního formátu. V následujícím příkladu je uvedena ukázka.
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
Obvykle se při operaci parsování vstupní řetězec, který obsahuje pouze jedno číslo, interpretuje jako počet dnů. Místo toho můžete použít specifikátor vlastního formátu %s a interpretovat číselný řetězec jako počet sekund. V následujícím příkladu je uvedena ukázka.
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 ukazuje použití specifikátoru vlastního formátu "s".
TimeSpan startTime = new TimeSpan(0, 12, 30, 15, 0);
TimeSpan endTime = new TimeSpan(0, 12, 30, 21, 3);
Console.WriteLine(@"Elapsed Time: {0:s\:fff} seconds",
endTime - startTime);
// The example displays the following output:
// Elapsed Time: 6:003 seconds
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
Specifikátor vlastního formátu "ss"
Specifikátor vlastního TimeSpan.Seconds formátu "ss" vypíše hodnotu vlastnosti, která představuje počet celých sekund v časovém intervalu, který není zahrnut do součásti hodin, dnů nebo minut. Pro hodnoty od 0 do 9 obsahuje výstupní řetězec úvodní nulu.
Obvykle se při operaci parsování vstupní řetězec, který obsahuje pouze jedno číslo, interpretuje jako počet dnů. Místo toho můžete použít specifikátor vlastního formátu "ss" k interpretaci číselného řetězce jako počtu sekund. V následujícím příkladu je uvedena ukázka.
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 ukazuje použití specifikátoru vlastního formátu "ss".
TimeSpan interval1 = TimeSpan.FromSeconds(12.60);
Console.WriteLine(interval1.ToString(@"ss\.fff"));
TimeSpan interval2 = TimeSpan.FromSeconds(6.485);
Console.WriteLine(interval2.ToString(@"ss\.fff"));
// The example displays the following output:
// 12.600
// 06.485
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
Specifikátor vlastního formátu "f"
Specifikátor vlastního formátu "f" vypíše desetiny sekundy v časovém intervalu. Při operaci formátování se všechny zbývající desetinné číslice zkrátí. V operaci parsování, která volá metodu TimeSpan.ParseExact nebo TimeSpan.TryParseExact , musí vstupní řetězec obsahovat přesně jednu desetinnou číslici.
Pokud se specifikátor vlastního formátu "f" používá samostatně, zadejte %f, aby nebyl nesprávně interpretován jako řetězec standardního formátu.
Následující příklad používá specifikátor vlastního formátu "f" k zobrazení desetiny sekundy v hodnotě TimeSpan . "f" se nejprve použije jako jediný specifikátor formátu a pak se zkombinuje se specifikátorem "s" v řetězci vlastního formátu.
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
Specifikátor vlastního formátu "ff"
Specifikátor vlastního formátu "ff" vypíše setiny sekundy v časovém intervalu. Při operaci formátování se všechny zbývající desetinné číslice zkrátí. Při operaci analýzy, která volá metodu TimeSpan.ParseExact nebo TimeSpan.TryParseExact , musí vstupní řetězec obsahovat přesně dvě desetinné číslice.
Následující příklad používá specifikátor vlastního formátu "ff" k zobrazení setin sekundy v hodnotě TimeSpan . "ff" se nejprve použije jako jediný specifikátor formátu a pak se v kombinaci se specifikátorem "s" v řetězci vlastního formátu.
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
Specifikátor vlastního formátu "fff"
Specifikátor vlastního formátu "fff" (se třemi znaky "f") vypíše milisekundy v časovém intervalu. Při operaci formátování se všechny zbývající desetinné číslice zkrátí. Při operaci analýzy, která volá metodu TimeSpan.ParseExact nebo TimeSpan.TryParseExact , musí vstupní řetězec obsahovat přesně tři desetinné číslice.
Následující příklad používá specifikátor vlastního formátu "fff" k zobrazení milisekund v hodnotě TimeSpan . "fff" se nejprve použije jako jediný specifikátor formátu a pak se v kombinaci se specifikátorem "s" v řetězci vlastního formátu.
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
Specifikátor vlastního formátu "ffff"
Specifikátor vlastního formátu "ffff" (se čtyřmi znaky "f") vypíše desetitisíce sekundy v časovém intervalu. Při operaci formátování se všechny zbývající desetinné číslice zkrátí. Při operaci parsování, která volá metodu TimeSpan.ParseExact nebo TimeSpan.TryParseExact , musí vstupní řetězec obsahovat přesně čtyři desetinné číslice.
Následující příklad používá specifikátor vlastního formátu "ffff" k zobrazení desetitisíc sekundy v hodnotě TimeSpan . "ffff" se nejprve použije jako jediný specifikátor formátu a pak se v kombinaci se specifikátorem "s" v řetězci vlastního formátu.
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
Specifikátor vlastního formátu "fffff"
Specifikátor vlastního formátu "fffff" (s pěti znaky "f") vypíše v časovém intervalu stotisítiny sekundy. Při operaci formátování se všechny zbývající desetinné číslice zkrátí. Při operaci parsování, která volá metodu TimeSpan.ParseExact nebo TimeSpan.TryParseExact , musí vstupní řetězec obsahovat přesně pět desetinných číslic.
Následující příklad používá specifikátor vlastního formátu "fffff" k zobrazení stotisíctin sekundy v hodnotě TimeSpan . "fffff" se nejprve použije jako jediný specifikátor formátu a pak se v kombinaci se specifikátorem "s" v řetězci vlastního formátu.
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
Specifikátor vlastního formátu "ffffff"
Specifikátor vlastního formátu "ffffff" (se šesti znaky "f") vypíše milionty sekundy v časovém intervalu. Při operaci formátování se všechny zbývající desetinné číslice zkrátí. V operaci parsování, která volá metodu TimeSpan.ParseExact nebo TimeSpan.TryParseExact , musí vstupní řetězec obsahovat přesně šest desetinných číslic.
Následující příklad používá specifikátor vlastního formátu "ffffff" k zobrazení miliont sekundy v hodnotě TimeSpan . Nejprve se použije jako jediný specifikátor formátu a pak se zkombinuje se specifikátorem "s" v řetězci vlastního formátu.
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
Specifikátor vlastního formátu "fffffff"
Specifikátor vlastního formátu "fffffff" (se sedmi znaky "f") vypíše desetimilionty sekundy (neboli zlomkový počet odškrtávků) v časovém intervalu. V operaci analýzy, která volá metodu TimeSpan.ParseExact nebo TimeSpan.TryParseExact , musí vstupní řetězec obsahovat přesně sedm desetinných číslic.
Následující příklad používá specifikátor vlastního formátu "fffffff" k zobrazení desetinného počtu zaškrtnutí v hodnotě TimeSpan . Nejprve se použije jako jediný specifikátor formátu a pak se zkombinuje se specifikátorem "s" v řetězci vlastního formátu.
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
Specifikátor vlastního formátu "F"
Specifikátor vlastního formátu "F" vypíše desetiny sekundy v časovém intervalu. Při operaci formátování se všechny zbývající desetinné číslice zkrátí. Pokud je hodnota desetin časového intervalu nula, není zahrnuta ve výsledném řetězci. V operaci parsování, která volá metodu TimeSpan.ParseExact nebo TimeSpan.TryParseExact , je přítomnost desetiny sekundy číslice volitelná.
Pokud se specifikátor vlastního formátu "F" používá samostatně, zadejte "%F", aby nebyl nesprávně interpretován jako řetězec standardního formátu.
Následující příklad používá specifikátor vlastního formátu "F" k zobrazení desetiny sekundy v hodnotě TimeSpan . Tento specifikátor vlastního formátu používá také v operaci parsování.
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'.
Specifikátor vlastního formátu FF
Specifikátor vlastního formátu "FF" vypíše setiny sekundy v časovém intervalu. Při operaci formátování se všechny zbývající desetinné číslice zkrátí. Pokud existují koncové desetinné nuly, nejsou zahrnuté ve výsledném řetězci. V operaci parsování, která volá metodu TimeSpan.ParseExact nebo TimeSpan.TryParseExact , je přítomnost desetiny a setin sekundy číslice volitelná.
Následující příklad používá specifikátor vlastního formátu "FF" k zobrazení setin sekundy v hodnotě TimeSpan . Tento specifikátor vlastního formátu používá také v operaci parsování.
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'.
Specifikátor vlastního formátu "FFF"
Specifikátor vlastního formátu "FFF" (se třemi znaky "F") vypíše milisekundy v časovém intervalu. Při operaci formátování se všechny zbývající desetinné číslice zkrátí. Pokud existují koncové desetinné nuly, nejsou zahrnuté ve výsledném řetězci. V operaci parsování, která volá metodu TimeSpan.ParseExact nebo TimeSpan.TryParseExact , je přítomnost desetiny, setin a tisíciny sekundy číslice volitelná.
Následující příklad používá specifikátor vlastního formátu "FFF" k zobrazení tisíciny sekundy v hodnotě TimeSpan . Tento specifikátor vlastního formátu používá také v operaci parsování.
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'.
Specifikátor vlastního formátu "FFFF"
Specifikátor vlastního formátu "FFFF" (se čtyřmi znaky "F") vypíše deset tisíciny sekundy v časovém intervalu. Při operaci formátování se všechny zbývající desetinné číslice zkrátí. Pokud existují koncové desetinné nuly, nejsou zahrnuté ve výsledném řetězci. V operaci parsování, která volá metodu TimeSpan.ParseExact nebo TimeSpan.TryParseExact , je přítomnost desetiny, setiny, tisíciny a desetitisíce sekundy číslice volitelná.
Následující příklad používá specifikátor vlastního formátu FFFF k zobrazení desetitisíc sekundy v hodnotě TimeSpan . Používá také specifikátor vlastního formátu FFFF v operaci parsování.
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'.
Specifikátor vlastního formátu "FFFFF"
Specifikátor vlastního formátu "FFFFF" (s pěti znaky "F") vypíše v časovém intervalu stotisítiny sekundy. Při operaci formátování se všechny zbývající desetinné číslice zkrátí. Pokud existují koncové desetinné nuly, nejsou zahrnuté ve výsledném řetězci. V operaci parsování, která volá metodu TimeSpan.ParseExact nebo TimeSpan.TryParseExact , je přítomnost desetiny, setiny, tisíciny, desetitisíc a stotisíc sekundy nepovinná.
Následující příklad používá specifikátor vlastního formátu "FFFFF" k zobrazení stotisíctin sekundy v hodnotě TimeSpan . Používá také specifikátor vlastního formátu "FFFFF" v operaci parsování.
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'.
Specifikátor vlastního formátu FFFFFF
Specifikátor vlastního formátu "FFFFFF" (se šesti znaky "F") vypíše milionty sekundy v časovém intervalu. Při operaci formátování se všechny zbývající desetinné číslice zkrátí. Pokud existují koncové desetinné nuly, nejsou zahrnuté ve výsledném řetězci. V operaci parsování, která volá metodu TimeSpan.ParseExact nebo TimeSpan.TryParseExact , je přítomnost desetiny, setiny, tisíciny, desetitisíc, stotisíc a miliontin druhé číslice volitelná.
Následující příklad používá specifikátor vlastního formátu "FFFFFF" k zobrazení miliont sekundy v hodnotě TimeSpan . Tento specifikátor vlastního formátu používá také v operaci parsování.
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'.
Specifikátor vlastního formátu "FFFFFFF"
Specifikátor vlastního formátu "FFFFFFF" (se sedmi znaky "F") vypíše desetimilionty sekundy (neboli zlomkový počet zaškrtnutí) v časovém intervalu. Pokud existují koncové desetinné nuly, nejsou zahrnuté ve výsledném řetězci. V operaci parsování, která volá metodu TimeSpan.ParseExact nebo TimeSpan.TryParseExact , je přítomnost sedmi desetinných číslic ve vstupním řetězci volitelná.
Následující příklad používá specifikátor vlastního formátu "FFFFFFF" k zobrazení zlomkové části sekundy v hodnotě TimeSpan . Tento specifikátor vlastního formátu používá také v operaci parsování.
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
Další znaky
Jakýkoli jiný znak bez panoramatu ve formátovacím řetězci, včetně prázdného znaku, je interpretován jako specifikátor vlastního formátu. Ve většině případů má přítomnost jakéhokoli jiného znaku bez zobrazení za FormatExceptionnásledek .
Existují dva způsoby, jak do řetězce formátu zahrnout literál:
Uzavřete ho do jednoduchých uvozovek (oddělovač řetězců literálu).
Před ním zadejte zpětné lomítko (\), které je interpretováno jako řídicí znak. To znamená, že v jazyce C# musí být formátovací řetězec buď @-quoted, nebo literálu musí předcházet další zpětné lomítko.
V některých případech může být nutné použít podmíněnou logiku k zahrnutí řídicího literálu do řetězce formátu. Následující příklad používá podmíněnou logiku k zahrnutí symbolu znaménka pro záporné časové intervaly.
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:54Module 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. To znamená, že oddělovače mezi dny a hodinami, hodinami a minutami, minutami a sekundami a sekundami a zlomky sekundy musí být všechny považovány za literály znaků ve formátovacím řetězci.
Následující příklad používá řídicí znak i jednoduchou uvozovku k definování řetězce vlastního formátu, který ve výstupním řetězci obsahuje slovo "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
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
Viz také
Váš názor
Připravujeme: V průběhu roku 2024 budeme postupně vyřazovat problémy z GitHub coby mechanismus zpětné vazby pro obsah a nahrazovat ho novým systémem zpětné vazby. Další informace naleznete v tématu: https://aka.ms/ContentUserFeedback.
Odeslat a zobrazit názory pro