Dela via

Anpassade TimeSpan-formatsträngar

  • Artikel

En TimeSpan formatsträng definierar strängrepresentationen av ett TimeSpan värde som är resultatet av en formateringsåtgärd. En anpassad formatsträng består av en eller flera anpassade TimeSpan formatspecificerare tillsammans med valfritt antal literaltecken. Alla strängar som inte är en Standard TimeSpan-formatsträng tolkas som en anpassad TimeSpan formatsträng.

Viktigt

De anpassade TimeSpan formatspecificerarna innehåller inte platshållaravgränsare, till exempel de symboler som skiljer dagar från timmar, timmar från minuter eller sekunder från bråksekunder. I stället måste dessa symboler inkluderas i den anpassade formatsträngen som strängliteraler. Definierar till exempel "dd\.hh\:mm" en punkt (.) som avgränsare mellan dagar och timmar och ett kolon (:) som avgränsare mellan timmar och minuter.

Anpassade TimeSpan formatspecificerare innehåller inte heller någon teckensymbol som gör att du kan skilja mellan negativa och positiva tidsintervall. Om du vill inkludera en teckensymbol måste du skapa en formatsträng med hjälp av villkorsstyrd logik. Avsnittet Andra tecken innehåller ett exempel.

Strängrepresentationerna av TimeSpan värden skapas av anrop till överlagringar av TimeSpan.ToString metoden och av metoder som stöder sammansatt formatering, till exempel String.Format. Mer information finns i Formateringstyper och Sammansatt formatering. I följande exempel visas användningen av anpassade formatsträngar i formateringsåtgärder.

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

Anpassade TimeSpan formatsträngar används också av TimeSpan.ParseExact metoderna och TimeSpan.TryParseExact för att definiera det format som krävs för indatasträngar för parsningsåtgärder. (Parsning konverterar strängrepresentationen av ett värde till det värdet.) I följande exempel visas användningen av standardformatsträngar vid parsningsåtgärder.

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

I följande tabell beskrivs de anpassade datum- och tidsformatsspecificerarna.

Formatspecificerare Beskrivning Exempel
"d", "%d" Antalet hela dagar i tidsintervallet.

Mer information: Den anpassade formatspecificeraren "d".		 new TimeSpan(6, 14, 32, 17, 685):

%d --> "6"

d\.hh\:mm --> "6.14:32"
"dd"-"ddddddddd" Antalet hela dagar i tidsintervallet, vadderat med inledande nollor efter behov.

Mer information: De anpassade formatspecificerarna "dd"-"dddddddd".		 new TimeSpan(6, 14, 32, 17, 685):

ddd --> "006"

dd\.hh\:mm --> "06.14:32"
"h", "%h" Antalet hela timmar i tidsintervallet som inte räknas som en del av dagar. Ensiffriga timmar har inte inledande nolla.

Mer information: Den anpassade formatspecificeraren "h".		 new TimeSpan(6, 14, 32, 17, 685):

%h --> "14"

hh\:mm --> "14:32"
"hh" Antalet hela timmar i tidsintervallet som inte räknas som en del av dagar. Ensiffriga timmar har inledande nolla.

Mer information: Den anpassade formatspecificeraren "hh".		 new TimeSpan(6, 14, 32, 17, 685):

hh --> "14"

new TimeSpan(6, 8, 32, 17, 685):

hh --> 08
"m", "%m" Antalet hela minuter i tidsintervallet som inte ingår som en del av timmar eller dagar. Ensiffriga minuter har ingen inledande nolla.

Mer information: Den anpassade formatspecificeraren "m".		 new TimeSpan(6, 14, 8, 17, 685):

%m --> "8"

h\:m --> "14:8"
"mm" Antalet hela minuter i tidsintervallet som inte ingår som en del av timmar eller dagar. Ensiffriga minuter har inledande nolla.

Mer information: Den anpassade formatspecificeraren "mm".		 new TimeSpan(6, 14, 8, 17, 685):

mm --> "08"

new TimeSpan(6, 8, 5, 17, 685):

d\.hh\:mm\:ss --> 6.08:05:17
"s", "%s" Antalet hela sekunder i tidsintervallet som inte ingår som en del av timmar, dagar eller minuter. Ensiffriga sekunder har inte inledande nolla.

Mer information: Den anpassade formatspecificeraren "s".		 TimeSpan.FromSeconds(12.965):

%s --> 12

s\.fff --> 12.965
"ss" Antalet hela sekunder i tidsintervallet som inte ingår som en del av timmar, dagar eller minuter. Ensiffriga sekunder har inledande nolla.

Mer information: Den anpassade formatspecificeraren för "ss".		 TimeSpan.FromSeconds(6.965):

ss --> 06

ss\.fff --> 06.965
"f", "%f" Tiondelen i en sekund i ett tidsintervall.

Mer information: Den anpassade formatspecificeraren "f".		 TimeSpan.FromSeconds(6.895):

f --> 8

ss\.f --> 06.8
"ff" Hundradelarna av en sekund i ett tidsintervall.

Mer information: Den anpassade formatspecificeraren "ff".		 TimeSpan.FromSeconds(6.895):

ff --> 89

ss\.ff --> 06.89
"fff" Millisekunderna i ett tidsintervall.

Mer information: Den anpassade formatspecificeraren "fff".		 TimeSpan.FromSeconds(6.895):

fff --> 895

ss\.fff --> 06.895
"ffffff" Tiotusendels sekunden i ett tidsintervall.

Mer information: Den anpassade formatspecificeraren "ffffff".		 TimeSpan.Parse("0:0:6.8954321"):

ffff --> 8954

ss\.ffff --> 06.8954
"fffff" Hundratusendel av en sekund i ett tidsintervall.

Mer information: Den anpassade formatspecificeraren "fffff".		 TimeSpan.Parse("0:0:6.8954321"):

fffff --> 89543

ss\.fffff --> 06.89543
"ffffffff" Miljondelarna av en sekund i ett tidsintervall.

Mer information: Den anpassade formatspecificeraren "ffffff".		 TimeSpan.Parse("0:0:6.8954321"):

ffffff --> 895432

ss\.ffffff --> 06.895432
"fffffff" De tio miljonerdelerna av en sekund (eller bråkfästingarna) i ett tidsintervall.

Mer information: Den anpassade formatspecificeraren "fffffff".		 TimeSpan.Parse("0:0:6.8954321"):

fffffff --> 8954321

ss\.fffffff --> 06.8954321
"F", "%F" Tiondelen i en sekund i ett tidsintervall. Ingenting visas om siffran är noll.

Mer information: Den anpassade formatspecificeraren "F".		 TimeSpan.Parse("00:00:06.32"):

%F: 3

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

ss\.F: 03.
"FF" Hundradelarna av en sekund i ett tidsintervall. Eventuella efterföljande nollor eller två nollsiffror ingår inte.

Mer information: Den anpassade formatspecificeraren "FF".		 TimeSpan.Parse("00:00:06.329"):

FF: 32

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

ss\.FF: 03.1
"FFF" Millisekunderna i ett tidsintervall. Eventuella bråkande nollor ingår inte.

Mer information:		 TimeSpan.Parse("00:00:06.3291"):

FFF: 329

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

ss\.FFF: 03.1
"FFFF" Tiotusendels sekunden i ett tidsintervall. Eventuella bråkande nollor ingår inte.

Mer information: Den anpassade formatspecificeraren "FFFF".		 TimeSpan.Parse("00:00:06.32917"):

FFFFF: 3291

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

ss\.FFFF: 03.1
"FFFFF" Hundratusendel av en sekund i ett tidsintervall. Eventuella bråkande nollor ingår inte.

Mer information: Specificeraren för anpassat FFFFF-format.		 TimeSpan.Parse("00:00:06.329179"):

FFFFF: 32917

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

ss\.FFFFF: 03.1
"FFFFFF" Miljondelarna av en sekund i ett tidsintervall. Eventuella efterföljande nollor visas inte.

Mer information: Den anpassade formatspecificeraren "FFFFFF".		 TimeSpan.Parse("00:00:06.3291791"):

FFFFFF: 329179

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

ss\.FFFFFF: 03.1
"FFFFFFF" De 10 miljoner i sekunden i ett tidsintervall. Eventuella efterföljande nollor eller sju nollor visas inte.

Mer information: Specificeraren för anpassat FFFFFFF-format.		 TimeSpan.Parse("00:00:06.3291791"):

FFFFFF: 3291791

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

ss\.FFFFFF: 03.19
"string" Avgränsare för literalsträng.

Mer information: Andra tecken.		 new TimeSpan(14, 32, 17):

hh':'mm':'ss --> "14:32:17"
\ Escape-tecknet.

Mer information: Andra tecken.		 new TimeSpan(14, 32, 17):

hh\:mm\:ss --> "14:32:17"
Andra tecken Andra tecken som inte är inkapslade tolkas som en anpassad formatspecificerare.

Mer information: Andra tecken.		 new TimeSpan(14, 32, 17):

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

Den anpassade formatspecificeraren "d"

Den anpassade formatspecificeraren "d" matar ut värdet för TimeSpan.Days egenskapen, som representerar antalet hela dagar i tidsintervallet. Det returnerar det fullständiga antalet dagar i ett TimeSpan värde, även om värdet har fler än en siffra. Om värdet för TimeSpan.Days egenskapen är noll returnerar specificeraren "0".

Om den anpassade formatspecificeraren "d" används ensam anger du %d så att den inte misstolkas som en standardformatsträng. I följande exempel visas en bild.

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

I följande exempel visas användningen av den anpassade formatspecificeraren "d".

TimeSpan ts2 = new TimeSpan(4, 3, 17);
Console.WriteLine(ts2.ToString(@"d\.hh\:mm\:ss"));

TimeSpan ts3 = new TimeSpan(3, 4, 3, 17);
Console.WriteLine(ts3.ToString(@"d\.hh\:mm\:ss"));
// The example displays the following output:
//       0.04:03:17
//       3.04:03:17

Dim ts2 As New TimeSpan(4, 3, 17)
Console.WriteLine(ts2.ToString("d\.hh\:mm\:ss"))

Dim ts3 As New TimeSpan(3, 4, 3, 17)
Console.WriteLine(ts3.ToString("d\.hh\:mm\:ss"))
' The example displays the following output:
'       0.04:03:17
'       3.04:03:17

Tillbaka till tabellen

De anpassade formatspecificerarna "dd"-"dddddddd"

De anpassade formatspecificerarna "ddd", "ddd", "ddddddd", "dddddddd" och "dddd" matar ut värdet TimeSpan.Days för egenskapen, som representerar antalet hela dagar i tidsintervallet.

Utdatasträngen innehåller ett minsta antal siffror som anges av antalet "d"-tecken i formatspecificeraren, och den är utfyllnad med inledande nollor efter behov. Om siffrorna i antalet dagar överskrider antalet "d"-tecken i formatspecificeraren matas det fullständiga antalet dagar ut i resultatsträngen.

I följande exempel används dessa formatspecificerare för att visa strängrepresentationen av två TimeSpan värden. Värdet för days-komponenten för det första tidsintervallet är noll. värdet för days-komponenten i den andra är 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

Tillbaka till tabellen

Den anpassade formatspecificeraren "h"

Den anpassade formatspecificeraren "h" matar ut värdet TimeSpan.Hours för egenskapen, som representerar antalet hela timmar i tidsintervallet som inte räknas som en del av dess dagskomponent. Den returnerar ett ensiffrigt strängvärde om värdet för TimeSpan.Hours egenskapen är 0 till 9 och returnerar ett tvåsiffrigt strängvärde om värdet TimeSpan.Hours för egenskapen sträcker sig från 10 till 23.

Om den anpassade formatspecificeraren "h" används ensam anger du %h så att den inte misstolkas som en standardformatsträng. I följande exempel visas en bild.

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

I en parsningsåtgärd tolkas normalt en indatasträng som bara innehåller ett enda tal som antalet dagar. Du kan använda den anpassade formatspecificeraren %h i stället för att tolka den numeriska strängen som antalet timmar. I följande exempel visas en bild.

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

I följande exempel visas användningen av den anpassade formatspecificeraren "h".

TimeSpan ts1 = new TimeSpan(14, 3, 17);
Console.WriteLine(ts1.ToString(@"d\.h\:mm\:ss"));

TimeSpan ts2 = new TimeSpan(3, 4, 3, 17);
Console.WriteLine(ts2.ToString(@"d\.h\:mm\:ss"));
// The example displays the following output:
//       0.14:03:17
//       3.4:03:17

Dim ts1 As New TimeSpan(14, 3, 17)
Console.WriteLine(ts1.ToString("d\.h\:mm\:ss"))

Dim ts2 As New TimeSpan(3, 4, 3, 17)
Console.WriteLine(ts2.ToString("d\.h\:mm\:ss"))
' The example displays the following output:
'       0.14:03:17
'       3.4:03:17

Tillbaka till tabellen

Den anpassade formatspecificeraren "hh"

Den anpassade formatspecificeraren "hh" matar ut värdet TimeSpan.Hours för egenskapen, som representerar antalet hela timmar i tidsintervallet som inte räknas som en del av dess dagkomponent. För värden mellan 0 och 9 innehåller utdatasträngen en inledande nolla.

I en parsningsåtgärd tolkas normalt en indatasträng som bara innehåller ett enda tal som antalet dagar. Du kan använda den anpassade formatspecificeraren "hh" i stället för att tolka den numeriska strängen som antalet timmar. I följande exempel visas en bild.

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

I följande exempel visas användningen av den anpassade formatspecificeraren "hh".

TimeSpan ts1 = new TimeSpan(14, 3, 17);
Console.WriteLine(ts1.ToString(@"d\.hh\:mm\:ss"));

TimeSpan ts2 = new TimeSpan(3, 4, 3, 17);
Console.WriteLine(ts2.ToString(@"d\.hh\:mm\:ss"));
// The example displays the following output:
//       0.14:03:17
//       3.04:03:17

Dim ts1 As New TimeSpan(14, 3, 17)
Console.WriteLine(ts1.ToString("d\.hh\:mm\:ss"))

Dim ts2 As New TimeSpan(3, 4, 3, 17)
Console.WriteLine(ts2.ToString("d\.hh\:mm\:ss"))
' The example displays the following output:
'       0.14:03:17
'       3.04:03:17

Tillbaka till tabellen

Den anpassade formatspecificeraren "m"

Den anpassade formatspecificeraren "m" matar ut värdet TimeSpan.Minutes för egenskapen, som representerar antalet hela minuter i tidsintervallet som inte räknas som en del av dess dagkomponent. Den returnerar ett ensiffrigt strängvärde om värdet för TimeSpan.Minutes egenskapen är 0 till 9 och returnerar ett tvåsiffrigt strängvärde om värdet för TimeSpan.Minutes egenskapen sträcker sig från 10 till 59.

Om den anpassade formatspecificeraren "m" används ensam anger du %m så att den inte misstolkas som en standardformatsträng. I följande exempel visas en bild.

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

I en parsningsåtgärd tolkas normalt en indatasträng som bara innehåller ett enda tal som antalet dagar. Du kan använda den anpassade formatspecificeraren %m i stället för att tolka den numeriska strängen som antalet minuter. I följande exempel visas en bild.

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

I följande exempel visas användningen av den anpassade formatspecificeraren "m".

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

TimeSpan ts2 = new TimeSpan(3, 4, 3, 17);
Console.WriteLine("Elapsed time: {0:m\\:ss}", ts2);
// The example displays the following output:
//       6:32 minutes
//       Elapsed time: 18:44

Dim ts1 As New TimeSpan(0, 6, 32)
Console.WriteLine("{0:m\:ss} minutes", ts1)

Dim ts2 As New TimeSpan(0, 18, 44)
Console.WriteLine("Elapsed time: {0:m\:ss}", ts2)
' The example displays the following output:
'       6:32 minutes
'       Elapsed time: 18:44

Tillbaka till tabellen

Den anpassade formatspecificeraren "mm"

Den anpassade formatspecificeraren "mm" matar ut värdet TimeSpan.Minutes för egenskapen, vilket representerar antalet hela minuter i tidsintervallet som inte ingår som en del av dess komponent för timmar eller dagar. För värden från 0 till 9 innehåller utdatasträngen en inledande nolla.

I en parsningsåtgärd tolkas vanligtvis en indatasträng som endast innehåller ett enda tal som antalet dagar. Du kan använda den anpassade formatspecificeraren "mm" i stället för att tolka den numeriska strängen som antalet minuter. I följande exempel visas en bild.

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

I följande exempel visas användningen av den anpassade formatspecificeraren "mm".

TimeSpan departTime = new TimeSpan(11, 12, 00);
TimeSpan arriveTime = new TimeSpan(16, 28, 00);
Console.WriteLine("Travel time: {0:hh\\:mm}",
                  arriveTime - departTime);
// The example displays the following output:
//       Travel time: 05:16

Dim departTime As New TimeSpan(11, 12, 00)
Dim arriveTime As New TimeSpan(16, 28, 00)
Console.WriteLine("Travel time: {0:hh\:mm}",
                  arriveTime - departTime)
' The example displays the following output:
'       Travel time: 05:16

Tillbaka till tabellen

Den anpassade formatspecificeraren "s"

Den anpassade formatspecificeraren "s" matar ut värdet för TimeSpan.Seconds egenskapen, vilket representerar antalet hela sekunder i tidsintervallet som inte ingår som en del av dess komponent för timmar, dagar eller minuter. Den returnerar ett ensiffrigt strängvärde om värdet för TimeSpan.Seconds egenskapen är 0 till 9 och returnerar ett tvåsiffrigt strängvärde om värdet för TimeSpan.Seconds egenskapen sträcker sig från 10 till 59.

Om den anpassade formatspecificeraren "s" används ensam anger du %s så att den inte misstolkas som en standardformatsträng. I följande exempel visas en bild.

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

I en parsningsåtgärd tolkas vanligtvis en indatasträng som endast innehåller ett enda tal som antalet dagar. Du kan använda den anpassade formatspecificeraren %s i stället för att tolka den numeriska strängen som antalet sekunder. I följande exempel visas en bild.

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

I följande exempel visas användningen av den anpassade formatspecificeraren "s".

TimeSpan startTime = new TimeSpan(0, 12, 30, 15, 0);
TimeSpan endTime = new TimeSpan(0, 12, 30, 21, 3);
Console.WriteLine(@"Elapsed Time: {0:s\:fff} seconds",
                  endTime - startTime);
// The example displays the following output:
//       Elapsed Time: 6:003 seconds

Dim startTime As New TimeSpan(0, 12, 30, 15, 0)
Dim endTime As New TimeSpan(0, 12, 30, 21, 3)
Console.WriteLine("Elapsed Time: {0:s\:fff} seconds",
                  endTime - startTime)
' The example displays the following output:
'       Elapsed Time: 6:003 seconds

Tillbaka till tabellen

Den anpassade formatspecificeraren för "ss"

Den anpassade formatspecificeraren "ss" matar ut värdet för TimeSpan.Seconds egenskapen, vilket representerar antalet hela sekunder i tidsintervallet som inte ingår som en del av dess komponent för timmar, dagar eller minuter. För värden från 0 till 9 innehåller utdatasträngen en inledande nolla.

I en parsningsåtgärd tolkas vanligtvis en indatasträng som endast innehåller ett enda tal som antalet dagar. Du kan använda den anpassade formatspecificeraren "ss" i stället för att tolka den numeriska strängen som antalet sekunder. I följande exempel visas en bild.

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

I följande exempel visas användningen av den anpassade formatspecificeraren "ss".

TimeSpan interval1 = TimeSpan.FromSeconds(12.60);
Console.WriteLine(interval1.ToString(@"ss\.fff"));

TimeSpan interval2 = TimeSpan.FromSeconds(6.485);
Console.WriteLine(interval2.ToString(@"ss\.fff"));
// The example displays the following output:
//       12.600
//       06.485

Dim interval1 As TimeSpan = TimeSpan.FromSeconds(12.60)
Console.WriteLine(interval1.ToString("ss\.fff"))
Dim interval2 As TimeSpan = TimeSpan.FromSeconds(6.485)
Console.WriteLine(interval2.ToString("ss\.fff"))
' The example displays the following output:
'       12.600
'       06.485

Tillbaka till tabellen

Den anpassade formatspecificeraren "f"

Den anpassade formatspecificeraren "f" matar ut tiondelar av en sekund i ett tidsintervall. I en formateringsåtgärd trunkeras eventuella återstående bråksiffror. I en parsningsåtgärd som anropar TimeSpan.ParseExact metoden eller TimeSpan.TryParseExact måste indatasträngen innehålla exakt en bråktalssiffra.

Om den anpassade formatspecificeraren "f" används ensam anger du %f så att den inte misstolkas som en standardformatsträng.

I följande exempel används den anpassade formatspecificeraren "f" för att visa tiondelar av en sekund i ett TimeSpan värde. "f" används först som den enda formatspecificeraren och kombineras sedan med "s"-specificeraren i en anpassad formatsträng.

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

Tillbaka till tabellen

Den anpassade formatspecificeraren "ff"

Den anpassade formatspecificeraren "ff" matar ut hundradelar av en sekund i ett tidsintervall. I en formateringsåtgärd trunkeras eventuella återstående bråksiffror. I en parsningsåtgärd som anropar TimeSpan.ParseExact metoden eller TimeSpan.TryParseExact måste indatasträngen innehålla exakt två bråksiffror.

I följande exempel används den anpassade formatspecificeraren "ff" för att visa hundradelar av en sekund i ett TimeSpan värde. "ff" används först som den enda formatspecificeraren och kombineras sedan med "s"-specificeraren i en anpassad formatsträng.

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

Tillbaka till tabellen

Den anpassade formatspecificeraren "fff"

Den anpassade formatspecificeraren "fff" (med tre "f"-tecken) matar ut millisekunderna i ett tidsintervall. I en formateringsåtgärd trunkeras eventuella återstående bråksiffror. I en parsningsåtgärd som anropar TimeSpan.ParseExact metoden eller TimeSpan.TryParseExact måste indatasträngen innehålla exakt tre bråksiffror.

I följande exempel används den anpassade formatspecificeraren "fff" för att visa millisekunderna i ett TimeSpan värde. "fff" används först som den enda formatspecificeraren och kombineras sedan med "s"-specificeraren i en anpassad formatsträng.

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

Tillbaka till tabellen

Den anpassade formatspecificeraren "ffff"

Den anpassade formatspecificeraren "ffff" (med fyra "f"-tecken) matar ut tio tusendelar av en sekund i ett tidsintervall. I en formateringsåtgärd trunkeras eventuella återstående bråksiffror. I en parsningsåtgärd som anropar TimeSpan.ParseExact metoden eller TimeSpan.TryParseExact måste indatasträngen innehålla exakt fyra bråksiffror.

I följande exempel används den anpassade formatspecificeraren "ffff" för att visa de tio tusendelarna av en sekund i ett TimeSpan värde. "ffff" används först som den enda formatspecificeraren och kombineras sedan med "s"-specificeraren i en anpassad formatsträng.

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

Tillbaka till tabellen

Den anpassade formatspecificeraren "fffff"

Den anpassade formatspecificeraren "fffff" (med fem "f"-tecken) matar ut hundra tusendelar av en sekund i ett tidsintervall. I en formateringsåtgärd trunkeras eventuella återstående bråksiffror. I en parsningsåtgärd som anropar TimeSpan.ParseExact metoden eller TimeSpan.TryParseExact måste indatasträngen innehålla exakt fem bråksiffror.

I följande exempel används den anpassade formatspecificeraren "fffff" för att visa hundratusendelar av en sekund i ett TimeSpan värde. "fffff" används först som den enda formatspecificeraren och kombineras sedan med "s"-specificeraren i en anpassad formatsträng.

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

Tillbaka till tabellen

Den anpassade formatspecificeraren "ffffff"

Den anpassade formatspecificeraren "ffffff" (med sex "f"-tecken) matar ut miljondelarna av en sekund i ett tidsintervall. I en formateringsåtgärd trunkeras eventuella återstående bråksiffror. I en parsningsåtgärd som anropar TimeSpan.ParseExact metoden eller TimeSpan.TryParseExact måste indatasträngen innehålla exakt sex bråksiffror.

I följande exempel används den anpassade formatspecificeraren "ffffff" för att visa miljondelarna av en sekund i ett TimeSpan värde. Den används först som den enda formatspecificeraren och kombineras sedan med "s"-specificeraren i en anpassad formatsträng.

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

Tillbaka till tabellen

Den anpassade formatspecificeraren "fffffff"

Den anpassade formatspecificeraren "fffffff" (med sju "f"-tecken) matar ut de tio miljonerdelarna av en sekund (eller det bråktal med tick) i ett tidsintervall. I en parsningsåtgärd som anropar TimeSpan.ParseExact metoden eller TimeSpan.TryParseExact måste indatasträngen innehålla exakt sju bråksiffror.

I följande exempel används den anpassade formatspecificeraren "fffffff" för att visa det bråktal med tick i ett TimeSpan värde. Den används först som den enda formatspecificeraren och kombineras sedan med "s"-specificeraren i en anpassad formatsträng.

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

Tillbaka till tabellen

Den anpassade formatspecificeraren "F"

Den anpassade formatspecificeraren "F" matar ut tiondels sekunden i ett tidsintervall. I en formateringsåtgärd trunkeras eventuella återstående bråksiffror. Om värdet för tidsintervallets tiondelar av en sekund är noll ingår det inte i resultatsträngen. I en parsningsåtgärd som anropar TimeSpan.ParseExact metoden eller TimeSpan.TryParseExact är förekomsten av tiondelar av en andra siffra valfri.

Om den anpassade formatspecificeraren "F" används ensam anger du %F så att den inte misstolkas som en standardformatsträng.

I följande exempel används den anpassade formatspecificeraren "F" för att visa tiondelar av en sekund i ett TimeSpan värde. Den använder också den här anpassade formatspecificeraren i en parsningsåtgärd.

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'.

Tillbaka till tabellen

Den anpassade formatspecificeraren "FF"

Den anpassade formatspecificeraren "FF" matar ut hundradelar av en sekund i ett tidsintervall. I en formateringsåtgärd trunkeras eventuella återstående bråksiffror. Om det finns några avslutande bråknollor ingår de inte i resultatsträngen. I en parsningsåtgärd som anropar TimeSpan.ParseExact metoden eller TimeSpan.TryParseExact är förekomsten av tiondelar och hundradelar av en andra siffra valfri.

I följande exempel används den anpassade formatspecificeraren "FF" för att visa hundradelar av en sekund i ett TimeSpan värde. Den använder också den här anpassade formatspecificeraren i en parsningsåtgärd.

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'.

Tillbaka till tabellen

Den anpassade formatspecificeraren "FFF"

Den anpassade formatspecificeraren "FFF" (med tre "F"-tecken) matar ut millisekunderna i ett tidsintervall. I en formateringsåtgärd trunkeras eventuella återstående bråksiffror. Om det finns några avslutande bråknollor ingår de inte i resultatsträngen. I en parsningsåtgärd som anropar TimeSpan.ParseExact metoden eller TimeSpan.TryParseExact är förekomsten av tiondelar, hundradelar och tusendelar av en andra siffra valfri.

I följande exempel används den anpassade formatspecificeraren "FFF" för att visa tusendelar av en sekund i ett TimeSpan värde. Den använder också den här anpassade formatspecificeraren i en parsningsåtgärd.

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'.

Tillbaka till tabellen

Den anpassade formatspecificeraren "FFFF"

Den anpassade formatspecificeraren "FFFF" (med fyra "F"-tecken) matar ut tio tusendelar av en sekund i ett tidsintervall. I en formateringsåtgärd trunkeras eventuella återstående bråksiffror. Om det finns några avslutande bråknollor ingår de inte i resultatsträngen. I en parsningsåtgärd som anropar TimeSpan.ParseExact metoden eller TimeSpan.TryParseExact är närvaron av tiondelar, hundradelar, tusendelar och tio tusendelar av en andra siffra valfri.

I följande exempel används den anpassade formatspecificeraren "FFFF" för att visa tiotusendels sekunden i ett TimeSpan värde. Den använder också den anpassade formatspecificeraren "FFFF" i en parsningsåtgärd.

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'.

Tillbaka till tabellen

Den anpassade formatspecificeraren "FFFFF"

Den anpassade formatspecificeraren "FFFFF" (med fem "F"-tecken) matar ut hundra tusendelar av en sekund i ett tidsintervall. I en formateringsåtgärd trunkeras eventuella återstående bråksiffror. Om det finns några avslutande bråknollor ingår de inte i resultatsträngen. I en parsningsåtgärd som anropar TimeSpan.ParseExact metoden eller TimeSpan.TryParseExact är närvaron av tiondelar, hundradelar, tusendelar, tio tusendelar och hundra tusendelar av en andra siffra valfri.

I följande exempel används den anpassade formatspecificeraren "FFFFF" för att visa hundratusendelar av en sekund i ett TimeSpan värde. Den använder också den anpassade formatspecificeraren "FFFFF" i en parsningsåtgärd.

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'.

Tillbaka till tabellen

Den anpassade formatspecificeraren "FFFFFF"

Den anpassade formatspecificeraren "FFFFFF" (med sex "F"-tecken) matar ut miljondelarna av en sekund i ett tidsintervall. I en formateringsåtgärd trunkeras eventuella återstående bråksiffror. Om det finns några avslutande bråknollor ingår de inte i resultatsträngen. I en parsningsåtgärd som anropar TimeSpan.ParseExact metoden eller TimeSpan.TryParseExact är närvaron av tiondelar, hundradelar, tusendelar, tio tusendelar, hundra tusendelar och miljondelar av en andra siffra valfri.

I följande exempel används den anpassade formatspecificeraren "FFFFFF" för att visa miljondelarna av en sekund i ett TimeSpan värde. Den använder också den här anpassade formatspecificeraren i en parsningsåtgärd.

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'.

Tillbaka till tabellen

Den anpassade formatspecificeraren "FFFFFFF"

Den anpassade formatspecificeraren "FFFFFFF" (med sju "F"-tecken) matar ut de tio miljonerdelarna av en sekund (eller det bråktal med tick) i ett tidsintervall. Om det finns några avslutande bråknollor ingår de inte i resultatsträngen. I en parsningsåtgärd som anropar TimeSpan.ParseExact metoden eller TimeSpan.TryParseExact är förekomsten av de sju bråktalen i indatasträngen valfri.

I följande exempel används den anpassade formatspecificeraren "FFFFFFF" för att visa bråkdelarna i en sekund i ett TimeSpan värde. Den använder också den här anpassade formatspecificeraren i en parsningsåtgärd.

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

Tillbaka till tabellen

Andra tecken

Alla andra icke-kapslade tecken i en formatsträng, inklusive ett blankstegstecken, tolkas som en anpassad formatspecificerare. I de flesta fall resulterar förekomsten av andra tecken som inte är kapslade i en FormatException.

Det finns två sätt att inkludera ett literaltecken i en formatsträng:

  • Omsluta den med enkla citattecken (den literala strängen avgränsare).

  • Föregå med ett omvänt snedstreck ("\"), som tolkas som ett escape-tecken. Det innebär att formatsträngen i C# antingen måste vara @-quoted eller så måste literaltecknet föregås av ytterligare ett omvänt snedstreck.

    I vissa fall kan du behöva använda villkorsstyrd logik för att inkludera en undantagen literal i en formatsträng. I följande exempel används villkorsstyrd logik för att inkludera en teckensymbol för negativa tidsintervall.

    using System;

public class Example
{
   public static void Main()
   {
      TimeSpan result = new DateTime(2010, 01, 01) - DateTime.Now;
      String fmt = (result < TimeSpan.Zero ?  "\\-" : "") + "dd\\.hh\\:mm";

      Console.WriteLine(result.ToString(fmt));
      Console.WriteLine("Interval: {0:" + fmt + "}", result);
   }
}
// The example displays output like the following:
//       -1291.10:54
//       Interval: -1291.10:54

    Module Example
    Public Sub Main()
        Dim result As TimeSpan = New DateTime(2010, 01, 01) - Date.Now
        Dim fmt As String = If(result < TimeSpan.Zero, "\-", "") + "dd\.hh\:mm"

        Console.WriteLine(result.ToString(fmt))
        Console.WriteLine("Interval: {0:" + fmt + "}", result)
    End Sub
End Module
' The example displays output like the following:
'       -1291.10:54
'       Interval: -1291.10:54

.NET definierar inte grammatik för avgränsare i tidsintervall. Det innebär att avgränsarna mellan dagar och timmar, timmar och minuter, minuter och sekunder samt sekunder och bråkdelar av en sekund måste behandlas som teckenliteraler i en formatsträng.

I följande exempel används både escape-tecknet och det enkla citattecknet för att definiera en anpassad formatsträng som innehåller ordet "minuter" i utdatasträngen.

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

Tillbaka till tabellen

Se även