Megosztás a következőn keresztül:


Egyéni TimeSpan formátumú sztringek

A TimeSpan formázási sztring egy formázási műveletből származó TimeSpan érték sztring-ábrázolását határozza meg. Az egyéni formázási sztringek egy vagy több egyéni TimeSpan formátumjelö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átumsztringként lesz értelmezve.

Fontos

Az egyéni TimeSpan formátumjelölők nem tartalmaznak helyőrző elválasztó szimbólumokat, például a napokat óráktól, óráktól perctől és másodperctől elválasztó szimbólumokat. Ehelyett ezeket a szimbólumokat sztringkonstansként kell szerepeltetni az egyéni formátumsztringben. A "dd\.hh\:mm" például egy pontot (.) határoz meg elválasztóként napok és órák között, és kettőspontot (:) elválasztóként órák és percek között.

Az egyéni TimeSpan formátumjelölők nem tartalmaznak olyan jelszimbólumot, amely lehetővé teszi a negatív és a pozitív időintervallumok közötti különbséget. 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.

A TimeSpan értékek sztring-ábrázolását a TimeSpan.ToString metódus túlterhelésére irányuló hívások, valamint az összetett formázást támogató metódusok, például a String.Format. 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: {duration:%d} day(s)");
      Console.WriteLine($"Time of Travel: {duration:dd\\.hh\\:mm\\:ss} days");
   }
}
// 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 egyéni TimeSpan formázási sztringeket a TimeSpan.ParseExact és TimeSpan.TryParseExact metódusok is használják 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 standard 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($"{value} --> {interval.ToString("c")}");
      else
         Console.WriteLine($"Unable to parse '{value}'");

      value = "16:32.05";
      if (TimeSpan.TryParseExact(value, @"mm\:ss\.ff", null, out interval))
         Console.WriteLine($"{value} --> {interval.ToString("c")}");
      else
         Console.WriteLine($"Unable to parse '{value}'");

      value= "12.035";
      if (TimeSpan.TryParseExact(value, "ss\\.fff", null, out interval))
         Console.WriteLine($"{value} --> {interval.ToString("c")}");
      else
         Console.WriteLine($"Unable to parse '{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" Az időintervallum egész napjainak száma.

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"-"ddddddddddd" Az időintervallum egész napjainak száma, szükség szerint kezdő nullákkal elválasztva.

További információ: A "dd"-"ddddddd" egyéni formátumjelölők.
new TimeSpan(6, 14, 32, 17, 685):

ddd -> "006"

dd\.hh\:mm -> "06.14:32"
"h", "%h" Az időintervallum teljes óráinak száma, amely nem számít bele a napok közé. Az egyjegyű órákban nincs kezdő nulla.

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 teljes ó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 -> 12

s\.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 -> 06

ss\.fff -> 06.965
"f", "%f" " A másodperc tizede egy időintervallumban.

További információ: Az "f" egyéni formátumkijelölő.
TimeSpan.FromSeconds(6.895):

f -> 8

ss\.f -> 06.8
"FF" Egy időintervallum másodpercének százada.

További információ: Az "ff" egyéni formátumkijelölő.
TimeSpan.FromSeconds(6.895):

ff -> 89

ss\.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 -> 895

ss\.fff -> 06.895
"FFFFF" Egy időintervallumban a másodperc 10 ezred része.

További információ: Az "ffff" egyéni formátumkijelölő.
TimeSpan.Parse("0:0:6.8954321"):

ffff -> 8954

ss\.ffff -> 06.8954
"fffff" Egy időintervallum 100 ezredmásedik része.

További információ: Az "fffff" egyéni formátumkijelölő.
TimeSpan.Parse("0:0:6.8954321"):

fffff -> 89543

ss\.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 -> 895432

ss\.ffffff -> 06.895432
"fffffff" A másodperc tízmilliomodik része (vagy a törtjelek) egy időintervallumban.

További információ: Az "fffffff" egyéni formátumkijelölő.
TimeSpan.Parse("0:0:6.8954321"):

fffffff -> 8954321

ss\.fffffff -> 06.8954321
"F", "%F" A 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: 3

TimeSpan.Parse("0:0:3.091"):

ss\.F: 03.
"FF" Egy időintervallum másodpercének százada. A tört záró nullákat vagy két nulla számjegyet nem tartalmazza.

További információ: Az "FF" egyéni formátumkijelölő.
TimeSpan.Parse("00:00:06.329"):

FF: 32

TimeSpan.Parse("0:0:3.101"):

ss\.FF: 03.1
"FFF" Az ezredmásodperc egy időintervallumban. A tört záró nullák nincsenek belefoglalva.

További információ:
TimeSpan.Parse("00:00:06.3291"):

FFF: 329

TimeSpan.Parse("0:0:3.1009"):

ss\.FFF: 03.1
"FFFF" Egy időintervallumban a másodperc 10 ezred része. A tört záró nullák nincsenek belefoglalva.

További információ: Az "FFFF" egyéni formátumkijelölő.
TimeSpan.Parse("00:00:06.32917"):

FFFFF: 3291

TimeSpan.Parse("0:0:3.10009"):

ss\.FFFF: 03.1
"FFFFF" Egy időintervallum 100 ezredmásedik része. A tört záró nullák nincsenek belefoglalva.

További információ: Az "FFFFF" egyéni formátumkijelölő.
TimeSpan.Parse("00:00:06.329179"):

FFFFF: 32917

TimeSpan.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: 329179

TimeSpan.Parse("0:0:3.1000009"):

ss\.FFFFFF: 03.1
"FFFFFFF" A 10 millió 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: 3291791

TimeSpan.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ő 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 beágyazott 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 TimeSpan.Days tulajdonság értékét adja ki, amely az időintervallum egész napjainak számát jelöli. Egy TimeSpan értékben 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ő a "0" értéket adja ki.

Ha a "d" egyéni formátumjelölőt egyedül használja, adja meg a "%d" értéket, 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      

Vissza a táblához

A "dd"-"ddddddddd" egyéni formátumkijelölők

A "ddd", "dddd", "ddd", "d", "d", "d" és "d" egyéni formátumjelölők a TimeSpan.Days tulajdonság értékét jelenítik meg, amely az időintervallum egész napjainak számát jelöli.

A kimeneti sztring tartalmazza a formátumjelölőben a "d" karakterek száma által megadott számjegyek minimális számát, és szükség szerint bevezető nullákkal van kitöltve. Ha a napok számában szereplő számjegyek meghaladják a formátumjelölő "d" karaktereinek számát, a napok teljes száma az eredménysztringben jelenik meg.

Az alábbi példa ezeket a formátumjelö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($"{fmt} --> {ts1.ToString(fmt)}");
   Console.WriteLine($"{fmt} --> {ts2.ToString(fmt)}");
   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      

Vissza a táblához

A "h" egyéni formátumkijelölő

A "h" egyéni formátumkijelölő a TimeSpan.Hours tulajdonság értékét adja ki, amely az időintervallum egész óráinak számát jelöli, amely nem számít bele a napi összetevőbe. Egyjegyű sztringértéket ad vissza, ha az 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 "%h" értéket, hogy az ne legyen tévesen értelmezve szabványos formátumsztringként. Az alábbi példa egy illusztrációt tartalmaz.

TimeSpan ts = new TimeSpan(3, 42, 0);
Console.WriteLine($"{ts:%h} hours {ts:%m} minutes");
// 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

Az elemzési műveletekben általában egy olyan bemeneti sztringet értelmez a rendszer, amely csak egyetlen számot tartalmaz, a napok számaként értelmezve. Ehelyett a "%h" 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 = "8";
TimeSpan interval;
if (TimeSpan.TryParseExact(value, "%h", null, out interval))
   Console.WriteLine(interval.ToString("c"));
else
   Console.WriteLine($"Unable to convert '{value}' to a time interval");
// 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

Vissza a táblához

A "hh" egyéni formátumkijelölő

A "hh" egyéni formátumkijelölő a TimeSpan.Hours tulajdonság értékét adja ki, amely az időintervallum egész óráinak számát jelöli, amely nem számít bele a napi összetevőbe. A 0 és 9 közötti értékeknél a kimeneti sztring tartalmaz egy kezdő nullát.

Az elemzési műveletekben általában egy olyan bemeneti sztringet értelmez a rendszer, amely csak egyetlen számot tartalmaz, a napok számaként értelmezve. 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 '{value}' to a time interval");
// 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 mutatja be.

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

Vissza a táblához

Az "m" egyéni formátumkijelölő

Az "m" egyéni formátumkijelölő a TimeSpan.Minutes tulajdonság értékét adja ki, amely az időintervallum egész perceinek számát jelöli, amely nem számít bele a napi összetevőbe. 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 "%m" értéket, 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($"{ts:%h} hours {ts:%m} minutes");
// 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

Az elemzési műveletekben általában egy olyan bemeneti sztringet értelmez a rendszer, amely csak egyetlen számot tartalmaz, a napok számaként értelmezve. Ehelyett a "%m" 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 = "3";
TimeSpan interval;
if (TimeSpan.TryParseExact(value, "%m", null, out interval))
   Console.WriteLine(interval.ToString("c"));
else
   Console.WriteLine($"Unable to convert '{value}' to a time interval");
// 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 mutatja be.

TimeSpan ts1 = new TimeSpan(0, 6, 32);
Console.WriteLine($"{ts1:m\\:ss} minutes");

TimeSpan ts2 = new TimeSpan(3, 4, 3, 17);
Console.WriteLine($"Elapsed time: {ts2:m\\:ss}");
// 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

Vissza a táblához

Az "mm" egyéni formátumkijelölő

Az "mm" egyéni formátumkijelölő a TimeSpan.Minutes tulajdonság értékét 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ékeknél a kimeneti sztring tartalmaz egy kezdő nullát.

Az elemzési műveletekben általában egy olyan bemeneti sztringet értelmez a rendszer, amely csak egyetlen számot tartalmaz, a napok számaként értelmezve. 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 '{value}' to a time interval");
// 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: {arriveTime - departTime:hh\\:mm}");
// 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      

Vissza a táblához

Az "s" egyéni formátumkijelölő

Az "s" 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. 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 mozog.

Ha az "s" egyéni formátumjelölőt egyedül használja, adja meg a "%s" értéket, 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 olyan bemeneti sztringet értelmez a rendszer, amely csak egyetlen számot tartalmaz, a napok számaként értelmezve. A "%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 '{value}' to a time interval");
// 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      

Vissza a táblához

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ékeknél a kimeneti sztring tartalmaz egy kezdő nullát.

Az elemzési műveletekben általában egy olyan bemeneti sztringet értelmez a rendszer, amely csak egyetlen számot tartalmaz, a napok számaként értelmezve. Az "ss" 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[] 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 '{value}' to a time interval");
}
// 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 mutatja be.

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

Vissza a táblához

Az "f" egyéni formátumkijelölő

Az "f" egyéni formátumkijelölő egy másodperc tizedét adja ki egy időintervallumban. Formázási művelet esetén a rendszer csonkolja a fennmaradó törtjegyeket. A TimeSpan.ParseExact vagy TimeSpan.TryParseExact metódust meghívó elemzési műveletben a bemeneti sztringnek pontosan egy törtjegyet kell tartalmaznia.

Ha az "f" egyéni formátumjelölőt egyedül használja, adja meg a "%f" értéket, 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 a másodperc tizedét egy TimeSpan értékben. Az "f" először az egyetlen formátumkijelölő, majd az "s" kijelölővel kombinálva 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($"{fmt,10}: {ts.ToString(fmt)}");
}
Console.WriteLine();

for (int ctr = 1; ctr <= 7; ctr++) {
   fmt = $"s\\.{new string('f', ctr)}";
   Console.WriteLine($"{fmt,10}: {ts.ToString(fmt)}");
}
// 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

Vissza a táblához

Az "ff" egyéni formátumkijelölő

Az "ff" egyéni formátumkijelölő egy időintervallumban adja ki a másodperc századát. Formázási művelet esetén a rendszer csonkolja a fennmaradó törtjegyeket. A TimeSpan.ParseExact vagy TimeSpan.TryParseExact metódust meghívó 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ő használatával jeleníti meg a másodpercek századát egy TimeSpan értékben. A "ff" először az egyetlen formátumkijelölő, majd egy egyéni formátumsztringben az "s" kijelölővel kombinálva.

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($"{fmt,10}: {ts.ToString(fmt)}");
}
Console.WriteLine();

for (int ctr = 1; ctr <= 7; ctr++) {
   fmt = $"s\\.{new string('f', ctr)}";
   Console.WriteLine($"{fmt,10}: {ts.ToString(fmt)}");
}
// 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

Vissza a táblához

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. Formázási művelet esetén a rendszer csonkolja a fennmaradó törtjegyeket. A TimeSpan.ParseExact vagy TimeSpan.TryParseExact metódust meghívó elemzési műveletben a bemeneti sztringnek pontosan három törtjegyet 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. Az "fff" először az egyetlen formátumkijelölő, majd egy egyéni formátumsztringben az "s" kijelölővel kombinálva.

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($"{fmt,10}: {ts.ToString(fmt)}");
}
Console.WriteLine();

for (int ctr = 1; ctr <= 7; ctr++) {
   fmt = $"s\\.{new string('f', ctr)}";
   Console.WriteLine($"{fmt,10}: {ts.ToString(fmt)}");
}
// 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

Vissza a táblához

Az "ffff" egyéni formátumkijelölő

Az "ffff" egyéni formátumkijelölő (négy "f" karakterrel) egy időintervallumban a másodperc tízezredét adja ki. Formázási művelet esetén a rendszer csonkolja a fennmaradó törtjegyeket. A TimeSpan.ParseExact vagy TimeSpan.TryParseExact metódust meghívó elemzési műveletben a bemeneti sztringnek pontosan négy törtjegyet kell tartalmaznia.

Az alábbi példa az "ffff" egyéni formátumkijelölő használatával jeleníti meg a másodperc tízezredét egy TimeSpan értékben. A "ffff" először az egyetlen formátumkijelölő, majd egy egyéni formátumsztringben az "s" kijelölővel kombinálva.

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($"{fmt,10}: {ts.ToString(fmt)}");
}
Console.WriteLine();

for (int ctr = 1; ctr <= 7; ctr++) {
   fmt = $"s\\.{new string('f', ctr)}";
   Console.WriteLine($"{fmt,10}: {ts.ToString(fmt)}");
}
// 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

Vissza a táblához

Az "fffff" egyéni formátumkijelölő

Az "fffff" egyéni formátumkijelölő (öt "f" karakterrel) egy időintervallumban a másodperc százezredét adja ki. Formázási művelet esetén a rendszer csonkolja a fennmaradó törtjegyeket. A TimeSpan.ParseExact vagy TimeSpan.TryParseExact metódust meghívó 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ővel jeleníti meg a másodpercek százezredét egy TimeSpan értékben. Az "fffff" először az egyetlen formátumkijelölő, majd egy egyéni formátumsztring "s" kijelölőjével kombinálva.

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($"{fmt,10}: {ts.ToString(fmt)}");
}
Console.WriteLine();

for (int ctr = 1; ctr <= 7; ctr++) {
   fmt = $"s\\.{new string('f', ctr)}";
   Console.WriteLine($"{fmt,10}: {ts.ToString(fmt)}");
}
// 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

Vissza a táblához

Az "ffffff" egyéni formátumkijelölője

Az "ffffff" egyéni formátumjelölő (hat "f" karakterrel) egy másodperc milliomodikát adja ki egy időintervallumban. Formázási művelet esetén a rendszer csonkolja a fennmaradó törtjegyeket. A TimeSpan.ParseExact vagy TimeSpan.TryParseExact metódust hívó 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ő használatával jeleníti meg a másodperc milliomodik értékeit egy TimeSpan értékben. Először az egyetlen formátumkijelölőként használják, majd egy egyéni formátumsztringben az "s" kijelölővel kombinálva.

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($"{fmt,10}: {ts.ToString(fmt)}");
}
Console.WriteLine();

for (int ctr = 1; ctr <= 7; ctr++) {
   fmt = $"s\\.{new string('f', ctr)}";
   Console.WriteLine($"{fmt,10}: {ts.ToString(fmt)}");
}
// 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

Vissza a táblához

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 a kullancsok tört számát) adja ki egy időintervallumban. A TimeSpan.ParseExact vagy TimeSpan.TryParseExact metódust meghívó elemzési műveletben a bemeneti sztringnek pontosan hét törtjegyet kell tartalmaznia.

Az alábbi példa az "fffffff" egyéni formátumkijelölővel jeleníti meg a osztásjelek tört számát egy TimeSpan értékben. Először az egyetlen formátumkijelölőként használják, majd egy egyéni formátumsztringben az "s" kijelölővel kombinálva.

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($"{fmt,10}: {ts.ToString(fmt)}");
}
Console.WriteLine();

for (int ctr = 1; ctr <= 7; ctr++) {
   fmt = $"s\\.{new string('f', ctr)}";
   Console.WriteLine($"{fmt,10}: {ts.ToString(fmt)}");
}
// 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

Vissza a táblához

Az "F" egyéni formátumkijelölő

Az "F" egyéni formátumkijelölő egy másodperc tizedét adja ki egy időintervallumban. Formázási művelet esetén a rendszer csonkolja a fennmaradó törtjegyeket. Ha az időintervallum másodperctizedének értéke nulla, akkor az eredménysztring nem tartalmazza. A TimeSpan.ParseExact vagy TimeSpan.TryParseExact metódust hívó elemzési műveletben a második számjegy tizedének jelenléte nem kötelező.

Ha az "F" egyéni formátumjelölőt egyedül használja, adja meg a "%F" értéket, hogy ne értelmezze félre szabványos formátumsztringként.

Az alábbi példa az "F" egyéni formátumkijelölő használatával jeleníti meg a másodperc tizedét egy TimeSpan értékben. Ezt az egyéni formátumkijelölőt egy elemzési műveletben is használja.

Console.WriteLine("Formatting:");
TimeSpan ts1 = TimeSpan.Parse("0:0:3.669");
Console.WriteLine($"{ts1} ('%F') --> {ts1:%F}");

TimeSpan ts2 = TimeSpan.Parse("0:0:3.091");
Console.WriteLine($"{ts2} ('ss\\.F') --> {ts2:ss\\.F}");
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($"{input} ('{fmt}') --> {ts3}");
   else
      Console.WriteLine($"Cannot parse {input} with '{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'.      

Vissza a táblához

Az "FF" egyéni formátumkijelölő

Az "FF" egyéni formátumkijelölő egy időintervallumban adja ki a másodperc századát. Formázási művelet esetén a rendszer csonkolja a fennmaradó törtjegyeket. Ha vannak záró tört nullák, azok nem szerepelnek az eredménysztringben. A TimeSpan.ParseExact vagy TimeSpan.TryParseExact metódust meghívó 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ő használatával jeleníti meg a másodpercek századát egy TimeSpan értékben. Ezt az egyéni formátumkijelölőt egy elemzési műveletben is használja.

Console.WriteLine("Formatting:");
TimeSpan ts1 = TimeSpan.Parse("0:0:3.697");
Console.WriteLine($"{ts1} ('FF') --> {ts1:FF}");

TimeSpan ts2 = TimeSpan.Parse("0:0:3.809");
Console.WriteLine($"{ts2} ('ss\\.FF') --> {ts2:ss\\.FF}");
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($"{input} ('{fmt}') --> {ts3}");
   else
      Console.WriteLine($"Cannot parse {input} with '{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'.

Vissza a táblához

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. Formázási művelet esetén a rendszer csonkolja a fennmaradó törtjegyeket. Ha vannak záró tört nullák, azok nem szerepelnek az eredménysztringben. A TimeSpan.ParseExact vagy TimeSpan.TryParseExact metódust hívó elemzési műveletekben a második számjegy tizedeinek, századainak és ezredeinek jelenléte nem kötelező.

Az alábbi példa az "FFF" egyéni formátumkijelölővel jeleníti meg a másodperc ezredét egy TimeSpan értékben. Ezt az egyéni formátumkijelölőt egy elemzési műveletben is használja.

Console.WriteLine("Formatting:");
TimeSpan ts1 = TimeSpan.Parse("0:0:3.6974");
Console.WriteLine($"{ts1} ('FFF') --> {ts1:FFF}");

TimeSpan ts2 = TimeSpan.Parse("0:0:3.8009");
Console.WriteLine($"{ts2} ('ss\\.FFF') --> {ts2:ss\\.FFF}");
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($"{input} ('{fmt}') --> {ts3}");
   else
      Console.WriteLine($"Cannot parse {input} with '{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'.

Vissza a táblához

Az "FFFF" egyéni formátumkijelölője

Az "FFFF" egyéni formátumkijelölő (négy "F" karakterrel) egy időintervallumban egy másodperc tízezredét adja ki. Formázási művelet esetén a rendszer csonkolja a fennmaradó törtjegyeket. Ha vannak záró tört nullák, azok nem szerepelnek az eredménysztringben. A TimeSpan.ParseExact vagy TimeSpan.TryParseExact metódust meghívó elemzési műveletekben a második számjegy tizedeinek, századainak, ezredeinek és tizedeinek jelenléte nem kötelező.

Az alábbi példa az "FFFF" egyéni formátumkijelölő használatával jeleníti meg a másodperc tízezredét egy TimeSpan értékben. Az elemzési műveletben az "FFFF" egyéni formátumjelölőt is használja.

Console.WriteLine("Formatting:");
TimeSpan ts1 = TimeSpan.Parse("0:0:3.69749");
Console.WriteLine($"{ts1} ('FFFF') --> {ts1:FFFF}");

TimeSpan ts2 = TimeSpan.Parse("0:0:3.80009");
Console.WriteLine($"{ts2} ('ss\\.FFFF') --> {ts2:ss\\.FFFF}");
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($"{input} ('{fmt}') --> {ts3}");
   else
      Console.WriteLine($"Cannot parse {input} with '{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'.

Vissza a táblához

Az "FFFFF" egyéni formátumkijelölője

Az "FFFFF" egyéni formátumkijelölő (öt "F" karakterrel) egy időintervallumban a másodpercek százezredét adja ki. Formázási művelet esetén a rendszer csonkolja a fennmaradó törtjegyeket. Ha vannak záró tört nullák, azok nem szerepelnek az eredménysztringben. A TimeSpan.ParseExact vagy TimeSpan.TryParseExact metódust meghívó elemzési műveletben a második számjegy tizedeinek, századainak, ezredeinek, tizedeinek és 10 ezredeinek jelenléte nem kötelező.

Az alábbi példa az "FFFFF" egyéni formátumkijelölővel jeleníti meg a másodpercek százezredét egy TimeSpan értékben. Az elemzési műveletben az "FFFFF" egyéni formátumjelölőt is használja.

Console.WriteLine("Formatting:");
TimeSpan ts1 = TimeSpan.Parse("0:0:3.697497");
Console.WriteLine($"{ts1} ('FFFFF') --> {ts1:FFFFF}");

TimeSpan ts2 = TimeSpan.Parse("0:0:3.800009");
Console.WriteLine($"{ts2} ('ss\\.FFFFF') --> {ts2:ss\\.FFFFF}");
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($"{input} ('{fmt}') --> {ts3}");
   else
      Console.WriteLine($"Cannot parse {input} with '{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'.

Vissza a táblához

Az "FFFFFF" egyéni formátumjelölője

Az "FFFFFF" egyéni formátumkijelölő (hat "F" karakterrel) egy másodperc milliomodikát adja ki egy időintervallumban. Formázási művelet esetén a rendszer csonkolja a fennmaradó törtjegyeket. Ha vannak záró tört nullák, azok nem szerepelnek az eredménysztringben. A TimeSpan.ParseExact vagy TimeSpan.TryParseExact metódust meghívó elemzési műveletben a második számjegy tizedeinek, századainak, ezredeinek, tizedeinek, 10 ezredeinek és milliomod részének jelenléte nem kötelező.

Az alábbi példa az "FFFFFF" egyéni formátumkijelölővel jeleníti meg a másodperc milliomodik értékeit egy TimeSpan értékben. Ezt az egyéni formátumkijelölőt egy elemzési műveletben is használja.

Console.WriteLine("Formatting:");
TimeSpan ts1 = TimeSpan.Parse("0:0:3.6974974");
Console.WriteLine($"{ts1} ('FFFFFF') --> {ts1:FFFFFF}");

TimeSpan ts2 = TimeSpan.Parse("0:0:3.8000009");
Console.WriteLine($"{ts2} ('ss\\.FFFFFF') --> {ts2:ss\\.FFFFFF}");
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($"{input} ('{fmt}') --> {ts3}");
   else
      Console.WriteLine($"Cannot parse {input} with '{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'.

Vissza a táblához

Az "FFFFFFF" egyéni formátumkijelölője

Az "FFFFFFF" egyéni formátumkijelölő (hét "F" karakterrel) egy másodperc tízmilliomodik értékét (vagy a kullancsok tört számát) adja ki egy időintervallumban. Ha vannak záró tört nullák, azok nem szerepelnek az eredménysztringben. A TimeSpan.ParseExact vagy TimeSpan.TryParseExact metódust meghívó elemzési műveletben a bemeneti sztringben szereplő hét törtjegy jelenléte nem kötelező.

Az alábbi példa az "FFFFFFF" egyéni formátumkijelölővel jeleníti meg a másodperc törtrészeit egy TimeSpan értékben. Ezt az egyéni formátumkijelölőt egy elemzési műveletben is használja.

Console.WriteLine("Formatting:");
TimeSpan ts1 = TimeSpan.Parse("0:0:3.6974974");
Console.WriteLine($"{ts1} ('FFFFFFF') --> {ts1:FFFFFFF}");

TimeSpan ts2 = TimeSpan.Parse("0:0:3.9500000");
Console.WriteLine($"{ts2} ('ss\\.FFFFFFF') --> {ts2:ss\\.FFFFFFF}");
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($"{input} ('{fmt}') --> {ts3}");
   else
      Console.WriteLine($"Cannot parse {input} with '{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     

Vissza a táblához

Egyéb karakterek

A formátumsztringben lévő többi nem beágyazott 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 kibontott karakter jelenléte FormatExceptioneredményez.

A literális karaktereket kétféleképpen lehet formázni:

  • Egyetlen idézőjelbe (a literális sztringelválasztóba) ágyazza be.

  • Ezt megelőzi egy fordított perjel ("\"), amelyet a rendszer menekülési karakterként értelmez. Ez azt jelenti, hogy a C#-ban a formázási sztringnek @-idézőjelet kell tartalmaznia, vagy a literál karaktert egy további fordított perjelnek kell megelőznie.

    Bizonyos esetekben előfordulhat, hogy feltételes logikát kell használnia egy szökött 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: {result.ToString(fmt)}");
       }
    }
    // The example displays output like the following:
    //       -5582.12:21
    //       Interval: -5582.12:21
    
    Module Example
        Public Sub Main()
            Dim result As TimeSpan = New DateTime(2010, 01, 01) - Date.Now
            Dim fmt As String = If(result < TimeSpan.Zero, "\-", "") + "dd\.hh\:mm"
    
            Console.WriteLine(result.ToString(fmt))
            Console.WriteLine("Interval: {0:" + fmt + "}", result)
        End Sub
    End Module
    ' The example displays output like the following:
    '       -1291.10:54
    '       Interval: -1291.10:54
    

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 és másodpercek, valamint másodpercek és másodpercek közötti elválasztójeleket egy formátumsztringben szereplő karakterkonstansként kell kezelni.

Az alábbi példa a feloldó karaktert és az egyetlen idézőjelet is használja egy egyéni formázási sztring 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      

Vissza a táblához

Lásd még