Egyéni TimeSpan formátumú sztringek
A TimeSpan formátumsztring egy formázási műveletből származó érték sztring-ábrázolását TimeSpan határozza meg. Az egyéni formázási sztringek egy vagy több egyéni TimeSpan formátumkijelölőből és tetszőleges számú literális karakterből állnak. Minden olyan sztring, amely nem standard timeSpan formátumú sztring , egyéni TimeSpan formázási sztringként lesz értelmezve.
Fontos
Az egyéni TimeSpan formátumkijelölők nem tartalmaznak helyőrző elválasztó szimbólumokat, például azokat a szimbólumokat, amelyek a napokat óráktól, óráktól percektől vagy másodperceket választják el a tört másodperctől. Ehelyett ezeket a szimbólumokat sztringkonstansként kell szerepeltetni az egyéni formátumsztringben. Definiál például "dd\.hh\:mm" egy pontot (.) a napok és órák közötti elválasztóként, valamint egy kettőspontot (:) az órák és percek közötti elválasztóként.
Az egyéni TimeSpan formátumkijelölők nem tartalmaznak olyan jelszimbólumot is, amely lehetővé teszi a negatív és a pozitív időintervallumok közötti különbségtételt. A jelszimbólumok hozzáadásához feltételes logikával kell formázni a sztringet. Az Egyéb karakterek szakasz tartalmaz egy példát.
Az értékek sztringreprezentációit TimeSpan a metódus túlterhelésére irányuló hívások és az TimeSpan.ToString összetett formázást támogató metódusok( például String.Format) állítják elő. További információ: Formázástípusok és összetett formázás. Az alábbi példa az egyéni formázási sztringek formázási műveletekben való használatát mutatja be.
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
Az és TimeSpan.TryParseExact metódusok TimeSpan.ParseExact egyéni TimeSpan formátumsztringeket is használnak az elemzési műveletekhez szükséges bemeneti sztringek formátumának meghatározásához. (Az elemzés egy érték sztring-ábrázolását konvertálja erre az értékre.) Az alábbi példa a szabványos formátumú sztringek használatát mutatja be az elemzési műveletekben.
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
Az alábbi táblázat az egyéni dátum- és időformátum-meghatározókat ismerteti.
| Formátumkijelölő | Leírás | Példa |
|---|---|---|
| "d", "%d" | A teljes napok száma az időintervallumban. További információ: A "d" egyéni formátumkijelölő. |
new TimeSpan(6, 14, 32, 17, 685):%d --> "6"d\.hh\:mm --> "6.14:32" |
| "dd"-"ddddddddd" | A teljes napok száma az időintervallumban, szükség szerint kezdő nullákkal. További információ: A "dd"-"dddddd" egyéni formátumkijelölők. |
new TimeSpan(6, 14, 32, 17, 685):ddd --> "006"dd\.hh\:mm --> "06.14:32" |
| "h", "%h" | Az időintervallum egész óráinak száma, amely nem számít bele a napok közé. Az egyjegyű óráknak nincs kezdő nullájuk. További információ: A "h" egyéni formátumkijelölő. |
new TimeSpan(6, 14, 32, 17, 685):%h --> "14"hh\:mm --> "14:32" |
| "óó" | Az időintervallum egész óráinak száma, amely nem számít bele a napok közé. Az egyjegyű órák kezdő nullával rendelkeznek. További információ: A "hh" egyéni formátumkijelölő. |
new TimeSpan(6, 14, 32, 17, 685):hh --> "14"new TimeSpan(6, 8, 32, 17, 685):hh --> 08 |
| "m", "%m" | A teljes percek száma az időintervallumban, amely nem szerepel az órák vagy napok részeként. Az egyjegyű percek nem rendelkeznek kezdő nullával. További információ: Az "m" egyéni formátumkijelölő. |
new TimeSpan(6, 14, 8, 17, 685):%m --> "8"h\:m --> "14:8" |
| "mm" | A teljes percek száma az időintervallumban, amely nem szerepel az órák vagy napok részeként. Az egyjegyű percek kezdő nullával rendelkeznek. További információ: Az "mm" egyéni formátumkijelölő. |
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" | A teljes másodpercek száma az időintervallumban, amely nem szerepel az órák, napok vagy percek részeként. Az egyjegyű másodpercnek nincs kezdő nullája. További információ: Az "s" egyéni formátumkijelölő. |
TimeSpan.FromSeconds(12.965):%s --> 12s\.fff --> 12.965 |
| "ss" | A teljes másodpercek száma az időintervallumban, amely nem szerepel az órák, napok vagy percek részeként. Az egyjegyű másodpercek kezdő nullával rendelkeznek. További információ: Az "ss" egyéni formátumkijelölő. |
TimeSpan.FromSeconds(6.965):ss --> 06ss\.fff --> 06.965 |
| "f", "%f" | Egy másodperc tizede egy időintervallumban. További információ: Az "f" egyéni formátumkijelölő. |
TimeSpan.FromSeconds(6.895):f --> 8ss\.f --> 06.8 |
| "ff" | Egy másodperc százada egy időintervallumban. További információ: Az "ff" egyéni formátumkijelölő. |
TimeSpan.FromSeconds(6.895):ff --> 89ss\.ff --> 06.89 |
| "fff" | Az ezredmásodperc egy időintervallumban. További információ: Az "fff" egyéni formátumkijelölő. |
TimeSpan.FromSeconds(6.895):fff --> 895ss\.fff --> 06.895 |
| "ffff" | Egy másodperc tízezred része egy időintervallumban. További információ: Az "ffff" egyéni formátumkijelölő. |
TimeSpan.Parse("0:0:6.8954321"):ffff --> 8954ss\.ffff --> 06.8954 |
| "fffff" | Egy másodperc 10 ezred része egy időintervallumban. További információ: Az "fffff" egyéni formátumkijelölő. |
TimeSpan.Parse("0:0:6.8954321"):fffff --> 89543ss\.fffff --> 06.89543 |
| "ffffff" | Egy másodperc milliomodik része egy időintervallumban. További információ: Az "ffffff" egyéni formátumkijelölő. |
TimeSpan.Parse("0:0:6.8954321"):ffffff --> 895432ss\.ffffff --> 06.895432 |
| "fffffff" | Egy másodperc tízmilliomodik része (vagy a törtjelek) egy időintervallumban. További információ: A "fffffff" egyéni formátumkijelölő. |
TimeSpan.Parse("0:0:6.8954321"):fffffff --> 8954321ss\.fffffff --> 06.8954321 |
| "F", "%F" | Egy másodperc tizede egy időintervallumban. Semmi sem jelenik meg, ha a számjegy nulla. További információ: Az "F" egyéni formátumkijelölő. |
TimeSpan.Parse("00:00:06.32"):%F: 3TimeSpan.Parse("0:0:3.091"):ss\.F: 03. |
| "FF" | Egy másodperc százada egy időintervallumban. A tört záró nullákat vagy két nulla számjegyet nem tartalmazza a függvény. További információ: Az "FF" egyéni formátumkijelölő. |
TimeSpan.Parse("00:00:06.329"):FF: 32TimeSpan.Parse("0:0:3.101"):ss\.FF: 03.1 |
| "FFF" | Az ezredmásodperc egy időintervallumban. A tört záró nullák nem szerepelnek benne. További információ: |
TimeSpan.Parse("00:00:06.3291"):FFF: 329TimeSpan.Parse("0:0:3.1009"):ss\.FFF: 03.1 |
| "FFFF" | Egy másodperc tízezred része egy időintervallumban. A tört záró nullák nem szerepelnek benne. További információ: Az "FFFF" egyéni formátumkijelölő. |
TimeSpan.Parse("00:00:06.32917"):FFFFF: 3291TimeSpan.Parse("0:0:3.10009"):ss\.FFFF: 03.1 |
| "FFFFF" | Egy másodperc 10 ezred része egy időintervallumban. A tört záró nullák nem szerepelnek benne. További információ: Az "FFFFF" egyéni formátumkijelölő. |
TimeSpan.Parse("00:00:06.329179"):FFFFF: 32917TimeSpan.Parse("0:0:3.100009"):ss\.FFFFF: 03.1 |
| "FFFFFF" | Egy másodperc milliomodik része egy időintervallumban. A tört záró nullák nem jelennek meg. További információ: Az "FFFFFF" egyéni formátumkijelölő. |
TimeSpan.Parse("00:00:06.3291791"):FFFFFF: 329179TimeSpan.Parse("0:0:3.1000009"):ss\.FFFFFF: 03.1 |
| "FFFFFFF" | A tízmillió másodperc egy időintervallumban. A tört záró nullák vagy hét nullák nem jelennek meg. További információ: Az "FFFFFFF" egyéni formátumkijelölő. |
TimeSpan.Parse("00:00:06.3291791"):FFFFFF: 3291791TimeSpan.Parse("0:0:3.1900000"):ss\.FFFFFF: 03.19 |
| "sztring" | Literális sztringelválasztó. További információ: Egyéb karakterek. |
new TimeSpan(14, 32, 17):hh':'mm':'ss --> "14:32:17" |
| \ | A menekülési karakter. További információ: Egyéb karakterek. |
new TimeSpan(14, 32, 17):hh\:mm\:ss --> "14:32:17" |
| Bármely más karakter | A rendszer minden más, nem kibontott karaktert egyéni formátumkijelölőként értelmez. További információ: Egyéb karakterek. |
new TimeSpan(14, 32, 17):hh\:mm\:ss --> "14:32:17" |
A "d" egyéni formátumkijelölő
A "d" egyéni formátumkijelölő a tulajdonság értékét TimeSpan.Days adja ki, amely az időintervallum egész napjainak számát jelöli. Egy értékben TimeSpan a napok teljes számát adja ki, még akkor is, ha az érték egynél több számjegyből áll. Ha a TimeSpan.Days tulajdonság értéke nulla, a kijelölő "0" kimenetet ad ki.
Ha a "d" egyéni formátumjelölőt egyedül használja, adja meg a következőt: %d, hogy ne értelmezze félre szabványos formátumsztringként. Az alábbi példa egy illusztrációt tartalmaz.
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
Az alábbi példa a "d" egyéni formátumkijelölő használatát szemlélteti.
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
A "dd"-"dddddd" egyéni formátumkijelölők
A "dd", "ddd", "dddd", "d", "d", "d" és "d" egyéni formátum-meghatározók a tulajdonság értékét TimeSpan.Days jelenítik meg, amely az időintervallum egész napjainak számát jelöli.
A kimeneti sztring tartalmazza a formátumkijelölő "d" karaktereinek száma által megadott számjegyek minimális számát, és szükség szerint kezdő nullákkal van kitöltve. Ha a napok számában szereplő számjegyek meghaladják a formátumkijelölő "d" karaktereinek számát, a napok teljes száma az eredménysztringben lesz kimenet.
Az alábbi példa ezeket a formátumkijelölőket használja két TimeSpan érték sztringképének megjelenítéséhez. Az első időintervallum napok összetevőjének értéke nulla; a második nap összetevőjének értéke 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
A "h" egyéni formátumkijelölő
A "h" egyéni formátumkijelölő a tulajdonság értékét TimeSpan.Hours adja ki, amely az időintervallumban a teljes órák számát jelöli, amely nem számít bele a nap összetevőjéhez. Egyjegyű sztringértéket ad vissza, ha a TimeSpan.Hours tulajdonság értéke 0 és 9 között van, és kétjegyű sztringértéket ad vissza, ha a TimeSpan.Hours tulajdonság értéke 10 és 23 között van.
Ha a "h" egyéni formátumkijelölőt egyedül használja, adja meg a következőt: %h, hogy az ne legyen szabványos formátumsztringként értelmezve. Az alábbi példa egy illusztrációt tartalmaz.
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
Általában egy elemzési műveletben egy bemeneti sztringet, amely csak egyetlen számot tartalmaz, a napok számaként értelmezi. A(z) "%h" egyéni formátumkijelölőt használhatja a numerikus sztring órák számaként való értelmezéséhez. Az alábbi példa egy illusztrációt tartalmaz.
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
Az alábbi példa a "h" egyéni formátumkijelölő használatát szemlélteti.
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
A "hh" egyéni formátumkijelölő
A "hh" egyéni formátumkijelölő a tulajdonság értékét TimeSpan.Hours adja ki, amely az időintervallumban lévő teljes órák számát jelöli, amely nem számít bele a nap összetevőjéhez. A 0 és 9 közötti értékeknél a kimeneti sztring tartalmaz egy kezdő nullát.
Általában egy elemzési műveletben egy bemeneti sztringet, amely csak egyetlen számot tartalmaz, a napok számaként értelmezi. A "hh" egyéni formátumjelölőt használhatja a numerikus sztring órák számaként való értelmezéséhez. Az alábbi példa egy illusztrációt tartalmaz.
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
Az alábbi példa a "hh" egyéni formátumkijelölő használatát szemlélteti.
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
Az "m" egyéni formátumkijelölő
Az "m" egyéni formátumkijelölő a tulajdonság értékét TimeSpan.Minutes adja ki, amely az időintervallum egész perceinek számát jelöli, amely nem számít bele a nap összetevőjéhez. Egyjegyű sztringértéket ad vissza, ha a TimeSpan.Minutes tulajdonság értéke 0 és 9 között van, és kétjegyű sztringértéket ad vissza, ha a TimeSpan.Minutes tulajdonság értéke 10 és 59 között mozog.
Ha az "m" egyéni formátumjelölőt egyedül használja, adja meg a következőt: "%m", hogy ne értelmezze félre szabványos formátumsztringként. Az alábbi példa egy illusztrációt tartalmaz.
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
Általában egy elemzési műveletben egy bemeneti sztringet, amely csak egyetlen számot tartalmaz, a napok számaként értelmezi. A(z) "%m" egyéni formátumkijelölőt használhatja a numerikus sztring percek számaként való értelmezéséhez. Az alábbi példa egy illusztrációt tartalmaz.
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
Az alábbi példa az "m" egyéni formátumkijelölő használatát szemlélteti.
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
Az "mm" egyéni formátumkijelölő
Az "mm" egyéni formátumkijelölő a tulajdonság értékét TimeSpan.Minutes adja ki, amely az időintervallum egész perceinek számát jelöli, amely nem szerepel az óra- vagy napösszetevőben. A 0 és 9 közötti értékek esetén a kimeneti sztring tartalmaz egy kezdő nullát.
Az elemzési műveletekben általában egy csak egy számot tartalmazó bemeneti sztringet a napok számaként értelmez a rendszer. Az "mm" egyéni formátumjelölőt használhatja a numerikus sztring percek számaként való értelmezéséhez. Az alábbi példa egy illusztrációt tartalmaz.
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
Az alábbi példa az "mm" egyéni formátumkijelölő használatát szemlélteti.
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
Az "s" egyéni formátumkijelölő
Az "s" egyéni formátumkijelölő a tulajdonság értékét TimeSpan.Seconds adja ki, amely az időintervallum egész másodperceinek számát jelöli, amely nem szerepel az óra, a nap vagy a perc összetevő részeként. Egyjegyű sztringértéket ad vissza, ha a TimeSpan.Seconds tulajdonság értéke 0 és 9 között van, és kétjegyű sztringértéket ad vissza, ha a TimeSpan.Seconds tulajdonság értéke 10 és 59 között van.
Ha az "s" egyéni formátumjelölőt egyedül használja, adja meg a következőt: "%s", hogy ne értelmezze félre szabványos formátumsztringként. Az alábbi példa egy illusztrációt tartalmaz.
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
Az elemzési műveletekben általában egy csak egy számot tartalmazó bemeneti sztringet a napok számaként értelmez a rendszer. A(z) "%s" egyéni formátumjelölőt használhatja a numerikus sztring másodpercek számaként való értelmezéséhez. Az alábbi példa egy illusztrációt tartalmaz.
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
Az alábbi példa az "s" egyéni formátumkijelölő használatát szemlélteti.
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
Az "ss" egyéni formátumkijelölője
Az "ss" egyéni formátumkijelölő a TimeSpan.Seconds tulajdonság értékét adja ki, amely az időintervallum egész másodperceinek számát jelöli, amely nem szerepel az óra, a nap vagy a perc összetevő részeként. A 0 és 9 közötti értékek esetén a kimeneti sztring tartalmaz egy kezdő nullát.
Az elemzési műveletekben általában egy csak egy számot tartalmazó bemeneti sztringet a napok számaként értelmez a rendszer. Az "ss" egyéni formátumkijelölő használatával a numerikus sztringet másodpercek számaként értelmezheti. Az alábbi példa egy illusztrációt tartalmaz.
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
Az alábbi példa az "ss" egyéni formátumkijelölő használatát szemlélteti.
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
Az "f" egyéni formátumkijelölő
Az "f" egyéni formátumkijelölő egy másodperc tizedét adja ki egy időintervallumban. Egy formázási műveletben a fennmaradó törtjegyek csonkulnak. Az vagy TimeSpan.TryParseExact metódust meghívó TimeSpan.ParseExact elemzési műveletben a bemeneti sztringnek pontosan egy tört számjegyet kell tartalmaznia.
Ha az "f" egyéni formátumkijelölőt egyedül használja, adja meg a következőt: "%f", hogy ne értelmezze félre szabványos formátumsztringként.
Az alábbi példa az "f" egyéni formátumkijelölővel jeleníti meg egy értékben a másodperc TimeSpan tizedét. A rendszer először az "f" formátumot használja egyetlen formátumkijelölőként, majd kombinálja az "s" kijelölővel egy egyéni formátumsztringben.
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
Az "ff" egyéni formátumkijelölő
Az "ff" egyéni formátumkijelölő egy időintervallumban adja ki a másodpercek századát. Egy formázási műveletben a fennmaradó törtjegyek csonkulnak. Az vagy TimeSpan.TryParseExact metódust meghívó TimeSpan.ParseExact elemzési műveletben a bemeneti sztringnek pontosan két törtjegyet kell tartalmaznia.
Az alábbi példa az "ff" egyéni formátumkijelölővel jeleníti meg egy érték másodperceinek TimeSpan századait. A rendszer először az "ff" formátumot használja egyetlen formátumkijelölőként, majd kombinálja az "s" kijelölővel egy egyéni formátumsztringben.
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
Az "fff" egyéni formátumkijelölő
Az "fff" egyéni formátumkijelölő (három "f" karakterrel) időintervallumban adja ki az ezredmásodperceket. Egy formázási műveletben a fennmaradó törtjegyek csonkulnak. Az vagy TimeSpan.TryParseExact metódust meghívó TimeSpan.ParseExact elemzési műveletekben a bemeneti sztringnek pontosan három tört számjegyet kell tartalmaznia.
Az alábbi példa az "fff" egyéni formátumkijelölővel jeleníti meg az ezredmásodperceket egy TimeSpan értékben. A rendszer először az "fff" formátumot használja egyetlen formátumkijelölőként, majd kombinálja az "s" paraméterrel egy egyéni formátumsztringben.
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
Az "ffff" egyéni formátumkijelölő
Az "ffff" egyéni formátumkijelölő (négy "f" karakterrel) egy időintervallumban adja ki a másodperc tízezredét. Egy formázási műveletben a fennmaradó törtjegyek csonkulnak. Az vagy TimeSpan.TryParseExact metódust meghívó TimeSpan.ParseExact elemzési műveletekben a bemeneti sztringnek pontosan négy törtjegyet kell tartalmaznia.
Az alábbi példa az "ffff" egyéni formátumkijelölővel jeleníti meg egy érték 10 ezredmásik másodpercét TimeSpan . A rendszer először az "ffff" formátumot használja egyetlen formátumkijelölőként, majd kombinálja az "s" paraméterrel egy egyéni formátumsztringben.
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
Az "fffff" egyéni formátumkijelölő
Az "fffff" egyéni formátumkijelölő (öt "f" karakterrel) egy másodperc százezredét adja ki egy időintervallumban. Egy formázási műveletben a fennmaradó törtjegyek csonkulnak. Az vagy TimeSpan.TryParseExact metódust meghívó TimeSpan.ParseExact elemzési műveletben a bemeneti sztringnek pontosan öt törtjegyet kell tartalmaznia.
Az alábbi példa az "fffff" egyéni formátumkijelölő használatával jeleníti meg egy érték százezredik másodpercét TimeSpan . A rendszer először az "fffff" formátumot használja egyetlen formátumkijelölőként, majd kombinálja az "s" paraméterrel egy egyéni formátumsztringben.
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
Az "ffffff" egyéni formátumkijelölő
Az "ffffff" egyéni formátumkijelölő (hat "f" karakterrel) egy másodperc milliomodik részét adja ki egy időintervallumban. Egy formázási műveletben a fennmaradó törtjegyek csonkulnak. Az vagy TimeSpan.TryParseExact metódust meghívó TimeSpan.ParseExact elemzési műveletben a bemeneti sztringnek pontosan hat törtjegyet kell tartalmaznia.
Az alábbi példa az "ffffff" egyéni formátumkijelölőt használja egy érték másodperc milliomodik értékének TimeSpan megjelenítéséhez. Először az egyetlen formátumkijelölőként használják, majd egy egyéni formátumsztringben kombinálják az "s" kijelölővel.
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
Az "fffffff" egyéni formátumkijelölő
Az "fffffff" egyéni formátumkijelölő (hét "f" karakterrel) egy másodperc tízmilliomodik értékét (vagy az órajelek tört számát) adja ki egy időintervallumban. Az vagy TimeSpan.TryParseExact metódust meghívó TimeSpan.ParseExact elemzési műveletekben a bemeneti sztringnek pontosan hét törtjegyet kell tartalmaznia.
Az alábbi példa az "fffffff" egyéni formátumkijelölőt használja az értékben lévő TimeSpan kullancsok törtszámának megjelenítéséhez. Először az egyetlen formátumkijelölőként használják, majd egy egyéni formátumsztringben kombinálják az "s" kijelölővel.
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
Az "F" egyéni formátumkijelölő
Az "F" egyéni formátumkijelölő egy másodperc tizedét adja ki egy időintervallumban. Egy formázási műveletben a fennmaradó törtjegyek csonkulnak. Ha az időintervallum tized másodperces értéke nulla, akkor az eredménysztring nem tartalmazza. A vagy TimeSpan.TryParseExact metódust meghívó TimeSpan.ParseExact elemzési műveletekben a második számjegy tizedének jelenléte nem kötelező.
Ha az "F" egyéni formátumkijelölőt egyedül használja, adja meg a következőt: %F, hogy ne értelmezze félre szabványos formátumsztringként.
Az alábbi példa az "F" egyéni formátumkijelölővel jeleníti meg egy értékben a másodperc TimeSpan tizedét. Ezt az egyéni formátumkijelölőt is használja egy elemzési műveletben.
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'.
Az "FF" egyéni formátumkijelölő
Az "FF" egyéni formátumkijelölő egy időintervallumban adja ki a másodpercek századát. Egy formázási műveletben a fennmaradó törtjegyek csonkulnak. Ha vannak záró tört nullák, azok nem szerepelnek az eredménysztringben. Az vagy TimeSpan.TryParseExact metódust meghívó TimeSpan.ParseExact elemzési műveletekben a második számjegy tizedeinek és századainak jelenléte nem kötelező.
Az alábbi példa az "FF" egyéni formátumkijelölővel jeleníti meg egy érték másodperceinek TimeSpan századát. Ezt az egyéni formátumkijelölőt is használja egy elemzési műveletben.
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'.
Az "FFF" egyéni formátumkijelölője
Az "FFF" egyéni formátumkijelölő (három "F" karakterrel) időintervallumban adja ki az ezredmásodperceket. Egy formázási műveletben a fennmaradó törtjegyek csonkulnak. Ha vannak záró tört nullák, azok nem szerepelnek az eredménysztringben. Az vagy TimeSpan.TryParseExact metódust meghívó TimeSpan.ParseExact elemzési műveletekben a tizedek, a századok és az ezredmásodik számjegyek jelenléte nem kötelező.
Az alábbi példa az "FFF" egyéni formátumkijelölővel jeleníti meg az értékben a TimeSpan másodperc ezred részét. Ezt az egyéni formátumkijelölőt is használja egy elemzési műveletben.
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'.
Az "FFFF" egyéni formátumkijelölő
Az "FFFF" egyéni formátumkijelölő (négy "F" karakterrel) egy időintervallumban adja ki a másodperc tízezredét. Egy formázási műveletben a fennmaradó törtjegyek csonkulnak. Ha vannak záró tört nullák, azok nem szerepelnek az eredménysztringben. Az vagy TimeSpan.TryParseExact metódust meghívó TimeSpan.ParseExact elemzési műveletekben a tizedek, a századok, az ezredek és a 10 ezredmásodik számjegyek jelenléte nem kötelező.
Az alábbi példa az "FFFF" egyéni formátumkijelölőt használja egy érték 10 ezredmásik másodpercének TimeSpan megjelenítéséhez. Az "FFFF" egyéni formátumkijelölőt is használja egy elemzési műveletben.
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'.
Az "FFFFF" egyéni formátumkijelölő
Az "FFFFF" egyéni formátumkijelölő (öt "F" karakterrel) egy időintervallumban adja ki a másodpercek százezredét. Egy formázási műveletben a fennmaradó törtjegyek csonkulnak. Ha vannak záró tört nullák, azok nem szerepelnek az eredménysztringben. Az vagy TimeSpan.TryParseExact metódust meghívó TimeSpan.ParseExact elemzési műveletekben a tizedek, a századok, az ezredek, a tízezredek és a második számjegyek százezredeinek jelenléte nem kötelező.
Az alábbi példa az "FFFFF" egyéni formátumkijelölő használatával jeleníti meg egy érték százezredik másodpercét TimeSpan . Az "FFFFF" egyéni formátumkijelölőt is használja egy elemzési műveletben.
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'.
Az "FFFFFF" egyéni formátumkijelölő
Az "FFFFFF" egyéni formátumkijelölő (hat "F" karakterrel) egy másodperc milliomodik értékét adja ki egy időintervallumban. Egy formázási műveletben a fennmaradó törtjegyek csonkulnak. Ha vannak záró tört nullák, azok nem szerepelnek az eredménysztringben. Az vagy TimeSpan.TryParseExact metódust meghívó TimeSpan.ParseExact elemzési műveletekben a tizedek, a századok, az ezredek, a tízezredek, a százezredek és a második számjegy milliomod része nem kötelező.
Az alábbi példa az "FFFFFF" egyéni formátumkijelölővel jeleníti meg egy másodperc milliomodik értékét egy TimeSpan értékben. Ezt az egyéni formátumkijelölőt is használja egy elemzési műveletben.
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'.
Az "FFFFFFF" egyéni formátumkijelölő
Az "FFFFFFF" egyéni formátumkijelölő (hét "F" karakterrel) egy másodperc tízmilliomodik értékét (vagy az órajelek tört számát) adja ki egy időintervallumban. Ha vannak záró tört nullák, azok nem szerepelnek az eredménysztringben. Az vagy TimeSpan.TryParseExact metódust meghívó TimeSpan.ParseExact elemzési műveletekben a bemeneti sztringben a hét tört számjegy jelenléte nem kötelező.
Az alábbi példa az "FFFFFFF" egyéni formátumkijelölővel jeleníti meg egy másodperc törtrészeit egy TimeSpan értékben. Ezt az egyéni formátumkijelölőt is használja egy elemzési műveletben.
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
Egyéb karakterek
A formázási sztringben lévő összes többi nem kibontott karakter, beleértve a szóköz karaktert is, egyéni formátumkijelölőként lesz értelmezve. A legtöbb esetben a többi nem beágyazott karakter jelenléte a FormatExceptionkövetkezőt eredményezi: .
A literális karaktereket kétféleképpen lehet befoglalni egy formátumsztringbe:
Tegye idézőjelek közé (a literális sztringelválasztóba).
Előtte egy fordított perjel ("\"), amely feloldó karakterként van értelmezve. Ez azt jelenti, hogy a C#-ban a formátumsztringnek @-idézőjelnek kell lennie, vagy a literál karaktert egy további fordított perjelnek kell megelőznie.
Bizonyos esetekben feltételes logikát kell használnia egy feloldott literál formázási sztringbe való belefoglalásához. Az alábbi példa feltételes logikát használ a negatív időintervallumok jelszimbólumának hozzáadásához.
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
A .NET nem határoz meg nyelvtant az elválasztókhoz időintervallumokban. Ez azt jelenti, hogy a napok és órák, órák és percek, percek, percek és másodpercek, valamint másodpercek és másodpercek közötti elválasztó karaktereket karakterkonstansként kell kezelni egy formátumsztringben.
Az alábbi példa a feloldó karaktert és az egyetlen idézőjelet is használja egy egyéni formátumsztring definiálásához, amely tartalmazza a "minutes" szót a kimeneti sztringben.
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
Lásd még
Visszajelzés
Hamarosan elérhető: 2024-ben fokozatosan kivezetjük a GitHub-problémákat a tartalom visszajelzési mechanizmusaként, és lecseréljük egy új visszajelzési rendszerre. További információ: https://aka.ms/ContentUserFeedback.
Visszajelzés küldése és megtekintése a következőhöz: