Niestandardowe ciągi formatujące TimeSpan

Ciąg TimeSpan formatu definiuje reprezentację ciągu wartości TimeSpan , która jest skutkiem operacji formatowania. Ciąg formatu niestandardowego składa się z co najmniej jednego specyfikatora TimeSpan formatu niestandardowego wraz z dowolną liczbą znaków literału. Każdy ciąg, który nie jest ciągiem standardowego formatu TimeSpan , jest interpretowany jako ciąg formatu niestandardowego TimeSpan .

Ważne

Specyfikatory TimeSpan formatu niestandardowego nie zawierają symboli separatora symboli zastępczych, takich jak symbole, które oddzielają dni od godzin, godzin od minut lub sekund od ułamkowych sekund. Zamiast tego te symbole muszą być zawarte w ciągu formatu niestandardowego jako literały ciągu. Na przykład definiuje "dd\.hh\:mm" okres (.) jako separator między dniami i godzinami oraz dwukropek (:) jako separator między godzinami i minutami.

Specyfikatory TimeSpan formatu niestandardowego nie zawierają również symbolu znaku, który umożliwia rozróżnienie ujemnych i dodatnich interwałów czasu. Aby dołączyć symbol znaku, należy skonstruować ciąg formatu przy użyciu logiki warunkowej. Przykład znajduje się w sekcji Inne znaki.

Reprezentacje ciągów TimeSpan wartości są produkowane przez TimeSpan.ToString wywołania przeciążeń metody oraz metody, które obsługują formatowanie złożone, takie jak String.Format. Aby uzyskać więcej informacji, zobacz Formatowanie typów iformatowanie złożone. Poniższy przykład ilustruje użycie ciągów formatu niestandardowego w operacjach formatowania.

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

Niestandardowe TimeSpan ciągi formatu są również używane przez metody TimeSpan.ParseExact i TimeSpan.TryParseExact do definiowania wymaganego formatu ciągów wejściowych na potrzeby operacji analizowania. (Analizowanie konwertuje reprezentację ciągu wartości na wartość). Poniższy przykład ilustruje użycie ciągów formatu standardowego w operacjach analizowania.

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

W poniższej tabeli opisano specyfikatory niestandardowego formatu daty i czasu.

Specyfikator formatu Opis Przykład
"d", "%d" Liczba całych dni w przedziale czasu.

Więcej informacji: Specyfikator formatu niestandardowego "d".
new TimeSpan(6, 14, 32, 17, 685):

%d> — "6"

d\.hh\:mm> — "6.14:32"
"dd"-"dddddddd" Liczba całych dni w przedziale czasu z zerami wiodącymi w razie potrzeby.

Więcej informacji: Specyfikatory formatu niestandardowego "dd"-"ddddddd".
new TimeSpan(6, 14, 32, 17, 685):

ddd> — "006"

dd\.hh\:mm> — "06.14:32"
"h", "%h" Liczba godzin w przedziale czasu, które nie są liczone jako część dni. Godziny z jedną cyfrą nie mają zera wiodącego.

Więcej informacji: Specyfikator formatu niestandardowego "h".
new TimeSpan(6, 14, 32, 17, 685):

%h> — "14"

hh\:mm> — "14:32"
„hh” Liczba godzin w przedziale czasu, które nie są liczone jako część dni. Godziny z jedną cyfrą mają zerem wiodącym.

Więcej informacji: Specyfikator formatu niestandardowego "hh".
new TimeSpan(6, 14, 32, 17, 685):

hh> — "14"

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

hh --> 08
"m", "%m" Liczba całych minut w przedziale czasu, które nie są uwzględnione jako część godzin lub dni. Minuty z jedną cyfrą nie mają zera wiodącego.

Więcej informacji: Specyfikator formatu niestandardowego "m".
new TimeSpan(6, 14, 8, 17, 685):

%m> — "8"

h\:m> — "14:8"
„mm” Liczba całych minut w przedziale czasu, które nie są uwzględnione jako część godzin lub dni. Minuty z jedną cyfrą mają zerem wiodącym.

Więcej informacji: Specyfikator formatu niestandardowego "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" Liczba całych sekund w przedziale czasu, które nie są uwzględnione jako część godzin, dni lub minut. Sekundy z jedną cyfrą nie mają zera wiodącego.

Więcej informacji: Specyfikator formatu niestandardowego "s".
TimeSpan.FromSeconds(12.965):

%s>— 12

s\.fff>— 12,965
„ss” Liczba całych sekund w przedziale czasu, które nie są uwzględnione jako część godzin, dni lub minut. Sekundy z jedną cyfrą mają zeru wiodącego.

Więcej informacji: Specyfikator formatu niestandardowego "ss".
TimeSpan.FromSeconds(6.965):

ss>— 06

ss\.fff>— 06,965
"f", "%f" Dziesiąte części sekundy w przedziale czasu.

Więcej informacji: Specyfikator formatu niestandardowego "f".
TimeSpan.FromSeconds(6.895):

f>— 8

ss\.f>— 06,8
„ff” Setne części sekundy w przedziale czasu.

Więcej informacji: Specyfikator formatu niestandardowego "ff".
TimeSpan.FromSeconds(6.895):

ff>— 89

ss\.ff>— 06,89
„fff” Milisekundy w przedziale czasu.

Więcej informacji: Specyfikator formatu niestandardowego "fff".
TimeSpan.FromSeconds(6.895):

fff>— 895

ss\.fff>— 06,895
„ffff” Dziesięciotysięczniki sekundy w przedziale czasu.

Więcej informacji: Specyfikator formatu niestandardowego "ffff".
TimeSpan.Parse("0:0:6.8954321"):

ffff>— 8954

ss\.ffff>— 06,8954
„fffff” Stutysięczniki sekundy w przedziale czasu.

Więcej informacji: Specyfikator formatu niestandardowego "fffff".
TimeSpan.Parse("0:0:6.8954321"):

fffff>— 89543

ss\.fffff --> 06.89543
„ffffff” Milionowe części sekundy w przedziale czasu.

Więcej informacji: Specyfikator formatu niestandardowego "ffffff".
TimeSpan.Parse("0:0:6.8954321"):

ffffff>— 895432

ss\.ffffff --> 06.895432
„fffffff” Liczba dziesięciomień milionowych części sekundy (lub takt ułamkowych) w przedziale czasu.

Więcej informacji: Specyfikator formatu niestandardowego "fffffff".
TimeSpan.Parse("0:0:6.8954321"):

fffffff>— 8954321

ss\.fffffff --> 06.8954321
"F", "%F" Dziesiąte części sekundy w przedziale czasu. Nic nie jest wyświetlane, jeśli cyfra jest równa zero.

Więcej informacji: Specyfikator formatu niestandardowego "F".
TimeSpan.Parse("00:00:06.32"):

%F: 3

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

ss\.F: 03.
„FF” Setne części sekundy w przedziale czasu. Nie są uwzględniane żadne końcowe zera ułamkowe lub dwie cyfry zerowe.

Więcej informacji: Specyfikator formatu niestandardowego "FF".
TimeSpan.Parse("00:00:06.329"):

FF: 32

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

ss\.FF: 03.1
„FFF” Milisekundy w interwale czasu. Nie są uwzględniane żadne końcowe zera ułamkowe.

Więcej informacji:
TimeSpan.Parse("00:00:06.3291"):

FFF: 329

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

ss\.FFF: 03.1
„FFFF” Dziesięciotysięczniki sekundy w przedziale czasu. Nie są uwzględniane żadne końcowe zera ułamkowe.

Więcej informacji: Specyfikator formatu niestandardowego "FFFF".
TimeSpan.Parse("00:00:06.32917"):

FFFFF: 3291

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

ss\.FFFF: 03.1
„FFFFF” Stutysięczniki sekundy w przedziale czasu. Nie są uwzględniane żadne końcowe zera ułamkowe.

Więcej informacji: Specyfikator formatu niestandardowego "FFFFF".
TimeSpan.Parse("00:00:06.329179"):

FFFFF: 32917

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

ss\.FFFFF: 03.1
„FFFFFF” Milionowe części sekundy w przedziale czasu. Końcowe zera ułamkowe nie są wyświetlane.

Więcej informacji: Specyfikator formatu niestandardowego "FFFFFF".
TimeSpan.Parse("00:00:06.3291791"):

FFFFFF: 329179

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

ss\.FFFFFF: 03.1
„FFFFFFF” 10 milionów sekund w przedziale czasu. Nie są wyświetlane żadne końcowe zera ułamkowe lub siedem zer.

Więcej informacji: Specyfikator formatu niestandardowego "FFFFFFF".
TimeSpan.Parse("00:00:06.3291791"):

FFFFFF: 3291791

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

ss\.FFFFFF: 03.19
'string' Ogranicznik ciągu literału.

Więcej informacji: Inne znaki.
new TimeSpan(14, 32, 17):

hh':'mm':'ss --> "14:32:17"
\ Znak ucieczki.

Więcej informacji: Inne znaki.
new TimeSpan(14, 32, 17):

hh\:mm\:ss --> "14:32:17"
Jakikolwiek inny znak Każdy inny znak bezbłędny jest interpretowany jako specyfikator formatu niestandardowego.

Więcej informacji: Inne znaki.
new TimeSpan(14, 32, 17):

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

Specyfikator formatu niestandardowego "d"

Specyfikator formatu niestandardowego "d" TimeSpan.Days wyprowadza wartość właściwości , która reprezentuje liczbę całych dni w przedziale czasu. Dane wyjściowe pełnej liczby dni w wartości TimeSpan , nawet jeśli wartość ma więcej niż jedną cyfrę. Jeśli wartość właściwości wynosi TimeSpan.Days zero, specyfikator wyprowadza wartość "0".

Jeśli używany jest sam specyfikator formatu niestandardowego "d", określ wartość "%d", aby nie został on błędnie zinterpretowany jako ciąg formatu standardowego. Poniższy przykład stanowi ilustrację.

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   

Poniższy przykład ilustruje użycie specyfikatora formatu niestandardowego "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      

Powrót do tabeli

Specyfikatory formatu niestandardowego "dd"-"ddddddd"

Specyfikatory formatu niestandardowego "dd", "dddd", "ddddd", "dddddd", "dddd" i "ddddddd" TimeSpan.Days wyprowadzą wartość właściwości, która reprezentuje liczbę całych dni w przedziale czasu.

Ciąg wyjściowy zawiera minimalną liczbę cyfr określoną przez liczbę znaków "d" w specyfikatorze formatu i w razie potrzeby jest dokańczany wiodącymi zerami. Jeśli cyfry w liczbie dni przekraczają liczbę znaków "d" w specyfikatorze formatu, pełna liczba dni jest wynikiem w ciągu wynikowym.

W poniższym przykładzie użyto tych specyfikatorów formatu, aby wyświetlić reprezentację ciągu dwóch TimeSpan wartości. Wartość składnika dni pierwszego interwału czasu wynosi zero; Wartość składnika dni sekundy to 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      

Powrót do tabeli

Specyfikator formatu niestandardowego "h"

Specyfikator formatu niestandardowego "h" TimeSpan.Hours wyprowadza wartość właściwości , która reprezentuje liczbę godzin w przedziale czasu, które nie są liczone jako część składnika dnia. Zwraca jednocyfrową TimeSpan.Hours wartość ciągu, jeśli wartość właściwości wynosi od 0 do 9, a TimeSpan.Hours wartość ciągu dwucyfrowego, jeśli wartość właściwości mieści się w zakresie od 10 do 23.

Jeśli używany jest sam specyfikator formatu niestandardowego "h", określ wartość "%h", aby nie został on błędnie zinterpretowany jako ciąg formatu standardowego. Poniższy przykład stanowi ilustrację.

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

Zwykle w operacji analizowania ciąg wejściowy, który zawiera tylko jedną liczbę, jest interpretowany jako liczba dni. Zamiast tego można użyć specyfikatora formatu niestandardowego "%h", aby zinterpretować ciąg liczbowy jako liczbę godzin. Poniższy przykład stanowi ilustrację.

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                              

Poniższy przykład ilustruje użycie specyfikatora formatu niestandardowego "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

Powrót do tabeli

Specyfikator formatu niestandardowego "hh"

Specyfikator formatu niestandardowego "hh" TimeSpan.Hours wyprowadza wartość właściwości , która reprezentuje liczbę godzin w przedziale czasu, które nie są liczone jako część składnika dnia. W przypadku wartości od 0 do 9 ciąg wyjściowy zawiera zero wiodące.

Zwykle w operacji analizowania ciąg wejściowy, który zawiera tylko jedną liczbę, jest interpretowany jako liczba dni. Zamiast tego można użyć specyfikatora formatu niestandardowego "hh", aby zinterpretować ciąg liczbowy jako liczbę godzin. Poniższy przykład stanowi ilustrację.

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                              

Poniższy przykład ilustruje użycie specyfikatora formatu niestandardowego "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

Powrót do tabeli

Specyfikator formatu niestandardowego "m"

Specyfikator formatu niestandardowego "m" TimeSpan.Minutes wyprowadza wartość właściwości , która reprezentuje liczbę całych minut w przedziale czasu, który nie jest liczony jako część składnika dnia. Zwraca jednocyfrową TimeSpan.Minutes wartość ciągu, jeśli wartość właściwości wynosi od 0 do 9, a TimeSpan.Minutes wartość ciągu dwucyfrowego, jeśli wartość właściwości mieści się w zakresie od 10 do 59.

Jeśli używany jest sam specyfikator formatu niestandardowego "m", określ wartość "%m", aby nie został on błędnie zinterpretowany jako ciąg formatu standardowego. Poniższy przykład stanowi ilustrację.

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

Zwykle w operacji analizowania ciąg wejściowy, który zawiera tylko jedną liczbę, jest interpretowany jako liczba dni. Zamiast tego można użyć specyfikatora formatu niestandardowego "%m", aby zinterpretować ciąg liczbowy jako liczbę minut. Poniższy przykład stanowi ilustrację.

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                              

Poniższy przykład ilustruje użycie specyfikatora formatu niestandardowego "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

Powrót do tabeli

Specyfikator formatu niestandardowego "mm"

Specyfikator formatu niestandardowego "mm" TimeSpan.Minutes wyprowadza wartość właściwości , która reprezentuje liczbę całych minut w przedziale czasu, który nie jest uwzględniony jako część składnika godziny lub dni. W przypadku wartości od 0 do 9 ciąg wyjściowy zawiera zero wiodące.

Zwykle w operacji analizowania ciąg wejściowy, który zawiera tylko jedną liczbę, jest interpretowany jako liczba dni. Zamiast tego można użyć specyfikatora formatu niestandardowego "mm", aby zinterpretować ciąg liczbowy jako liczbę minut. Poniższy przykład stanowi ilustrację.

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           

Poniższy przykład ilustruje użycie specyfikatora formatu niestandardowego "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      

Powrót do tabeli

Specyfikator formatu niestandardowego "s"

Specyfikator formatu niestandardowego "s" TimeSpan.Seconds wyprowadza wartość właściwości , która reprezentuje liczbę całych sekund w przedziale czasu, który nie jest uwzględniony jako część jego składnika godzin, dni lub minut. Zwraca jednocyfrową TimeSpan.Seconds wartość ciągu, jeśli wartość właściwości wynosi od 0 do 9, a TimeSpan.Seconds wartość ciągu dwucyfrowego, jeśli wartość właściwości mieści się w zakresie od 10 do 59.

Jeśli używany jest sam specyfikator formatu niestandardowego "s", określ wartość "%s", aby nie został błędnie zinterpretowany jako ciąg formatu standardowego. Poniższy przykład stanowi ilustrację.

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

Zwykle w operacji analizowania ciąg wejściowy, który zawiera tylko jedną liczbę, jest interpretowany jako liczba dni. Zamiast tego można użyć specyfikatora formatu niestandardowego "%s", aby zinterpretować ciąg liczbowy jako liczbę sekund. Poniższy przykład stanowi ilustrację.

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

Poniższy przykład ilustruje użycie specyfikatora formatu niestandardowego "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      

Powrót do tabeli

Specyfikator formatu niestandardowego "ss"

Specyfikator formatu niestandardowego "ss" TimeSpan.Seconds wyprowadza wartość właściwości , która reprezentuje liczbę całych sekund w przedziale czasu, który nie jest uwzględniony jako część jego składnika godzin, dni lub minut. W przypadku wartości od 0 do 9 ciąg wyjściowy zawiera zero wiodące.

Zwykle w operacji analizowania ciąg wejściowy, który zawiera tylko jedną liczbę, jest interpretowany jako liczba dni. Zamiast tego można użyć specyfikatora formatu niestandardowego "ss", aby zinterpretować ciąg liczbowy jako liczbę sekund. Poniższy przykład stanowi ilustrację.

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

Poniższy przykład ilustruje użycie specyfikatora formatu niestandardowego "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

Powrót do tabeli

Specyfikator formatu niestandardowego "f"

Specyfikator formatu niestandardowego "f" wyprowadza dziesiąte części sekundy w przedziale czasu. W operacji formatowania wszystkie pozostałe cyfry ułamkowe są obcinane. W operacji analizowania, która wywołuje metodę TimeSpan.ParseExact lub TimeSpan.TryParseExact , ciąg wejściowy musi zawierać dokładnie jedną cyfrę ułamkową.

Jeśli używany jest sam specyfikator formatu niestandardowego "f", określ wartość "%f", aby nie został błędnie zinterpretowany jako ciąg formatu standardowego.

W poniższym przykładzie użyto specyfikatora formatu niestandardowego "f", aby wyświetlić dziesiąte części sekundy w wartości TimeSpan . "f" jest używany jako pierwszy specyfikator formatu, a następnie połączony ze specyfikatorem "s" w ciągu formatu niestandardowego.

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

Powrót do tabeli

Specyfikator formatu niestandardowego "ff"

Specyfikator formatu niestandardowego "ff" wyprowadza setne części sekundy w przedziale czasu. W operacji formatowania wszystkie pozostałe cyfry ułamkowe są obcinane. W operacji analizowania, która wywołuje metodę TimeSpan.ParseExact lub TimeSpan.TryParseExact , ciąg wejściowy musi zawierać dokładnie dwie cyfry ułamkowe.

W poniższym przykładzie użyto specyfikatora formatu niestandardowego "ff", aby wyświetlić setne części sekundy w wartości TimeSpan . "ff" jest używany jako pierwszy specyfikator formatu, a następnie połączony ze specyfikatorem "s" w ciągu formatu niestandardowego.

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

Powrót do tabeli

Specyfikator formatu niestandardowego "fff"

Specyfikator formatu niestandardowego "fff" (z trzema znakami "f") wyprowadza milisekundy w interwale czasu. W operacji formatowania wszystkie pozostałe cyfry ułamkowe są obcinane. W operacji analizowania, która wywołuje metodę TimeSpan.ParseExact lub TimeSpan.TryParseExact , ciąg wejściowy musi zawierać dokładnie trzy cyfry ułamkowe.

W poniższym przykładzie użyto specyfikatora formatu niestandardowego "fff", aby wyświetlić milisekundy w wartości TimeSpan . "fff" jest używany jako pierwszy specyfikator formatu, a następnie połączony ze specyfikatorem "s" w ciągu formatu niestandardowego.

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

Powrót do tabeli

Specyfikator formatu niestandardowego "ffff"

Specyfikator formatu niestandardowego "ffff" (z czterema znakami "f") wyprowadza dziesięciotysięcznych części sekundy w przedziale czasu. W operacji formatowania wszystkie pozostałe cyfry ułamkowe są obcinane. W operacji analizowania, która wywołuje metodę TimeSpan.ParseExact lub TimeSpan.TryParseExact , ciąg wejściowy musi zawierać dokładnie cztery cyfry ułamkowe.

W poniższym przykładzie użyto specyfikatora formatu niestandardowego "ffff", aby wyświetlić dziesięciotysięczniki sekundy w wartości TimeSpan . "ffff" jest używany jako jedyny specyfikator formatu, a następnie połączony ze specyfikatorem "s" w ciągu formatu niestandardowego.

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

Powrót do tabeli

Specyfikator formatu niestandardowego "fffff"

Specyfikator formatu niestandardowego "fffff" (z pięcioma znakami "f") wyprowadza stutysięcznych części sekundy w przedziale czasu. W operacji formatowania wszystkie pozostałe cyfry ułamkowe są obcinane. W operacji analizowania, która wywołuje metodę TimeSpan.ParseExact lub TimeSpan.TryParseExact , ciąg wejściowy musi zawierać dokładnie pięć cyfr ułamkowych.

W poniższym przykładzie użyto specyfikatora formatu niestandardowego "fffff" w celu wyświetlenia setnych tysięcy części sekundy w wartości TimeSpan . "fffff" jest używany jako pierwszy specyfikator formatu, a następnie połączony ze specyfikatorem "s" w ciągu formatu niestandardowego.

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

Powrót do tabeli

Specyfikator formatu niestandardowego "ffffff"

Specyfikator formatu niestandardowego "ffffff" (z sześcioma znakami "f") wyprowadza milionowe części sekundy w przedziale czasu. W operacji formatowania wszystkie pozostałe cyfry ułamkowe są obcinane. W operacji analizowania, która wywołuje metodę TimeSpan.ParseExact lub TimeSpan.TryParseExact , ciąg wejściowy musi zawierać dokładnie sześć cyfr ułamkowych.

W poniższym przykładzie użyto specyfikatora formatu niestandardowego "ffffff", aby wyświetlić milionowe części sekundy w wartości TimeSpan . Najpierw jest używany jako jedyny specyfikator formatu, a następnie połączony ze specyfikatorem "s" w ciągu formatu niestandardowego.

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

Powrót do tabeli

Specyfikator formatu niestandardowego "fffffff"

Specyfikator formatu niestandardowego "fffffff" (z siedmiu znaków "f") wyprowadza dziesięciomiesięcznych części sekundy (lub ułamkową liczbę takt) w interwale czasu. W operacji analizowania, która wywołuje metodę TimeSpan.ParseExact lub TimeSpan.TryParseExact , ciąg wejściowy musi zawierać dokładnie siedem cyfr ułamkowych.

W poniższym przykładzie użyto specyfikatora formatu niestandardowego "fffffff", aby wyświetlić liczbę ułamkową takt w wartości TimeSpan . Najpierw jest używany jako jedyny specyfikator formatu, a następnie połączony ze specyfikatorem "s" w ciągu formatu niestandardowego.

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

Powrót do tabeli

Specyfikator formatu niestandardowego "F"

Specyfikator formatu niestandardowego "F" wyprowadza dziesiąte części sekundy w przedziale czasu. W operacji formatowania wszystkie pozostałe cyfry ułamkowe są obcinane. Jeśli wartość dziesiątych części sekundy interwału czasu wynosi zero, nie zostanie uwzględniona w ciągu wynikowym. W operacji analizowania, która wywołuje TimeSpan.ParseExact metodę lub TimeSpan.TryParseExact , obecność dziesiątych części drugiej cyfry jest opcjonalna.

Jeśli używany jest sam specyfikator formatu niestandardowego "F", określ wartość "%F", aby nie został błędnie zinterpretowany jako ciąg formatu standardowego.

W poniższym przykładzie użyto specyfikatora formatu niestandardowego "F", aby wyświetlić dziesiąte części sekundy w wartości TimeSpan . Używa on również tego specyfikatora formatu niestandardowego w operacji analizowania.

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

Powrót do tabeli

Specyfikator formatu niestandardowego "FF"

Specyfikator formatu niestandardowego "FF" wyprowadza setne części sekundy w przedziale czasu. W operacji formatowania wszystkie pozostałe cyfry ułamkowe są obcinane. Jeśli istnieją jakiekolwiek końcowe zera ułamkowe, nie są one uwzględniane w ciągu wynikowym. W operacji analizowania, która TimeSpan.ParseExact wywołuje metodę lub TimeSpan.TryParseExact , obecność dziesiątych i setnych części drugiej cyfry jest opcjonalna.

W poniższym przykładzie użyto specyfikatora formatu niestandardowego "FF", aby wyświetlić setne części sekundy w wartości TimeSpan . Używa on również tego specyfikatora formatu niestandardowego w operacji analizowania.

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

Powrót do tabeli

Specyfikator formatu niestandardowego "FFF"

Specyfikator formatu niestandardowego "FFF" (z trzema znakami "F") wyprowadza milisekundy w interwale czasu. W operacji formatowania wszystkie pozostałe cyfry ułamkowe są obcinane. Jeśli istnieją jakiekolwiek końcowe zera ułamkowe, nie są one uwzględniane w ciągu wynikowym. W operacji analizowania TimeSpan.ParseExact , która wywołuje metodę lub TimeSpan.TryParseExact , obecność dziesiątych, setnych i tysięczych części drugiej cyfry jest opcjonalna.

W poniższym przykładzie użyto specyfikatora formatu niestandardowego "FFF", aby wyświetlić tysięcze części sekundy w wartości TimeSpan . Używa on również tego specyfikatora formatu niestandardowego w operacji analizowania.

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

Powrót do tabeli

Specyfikator formatu niestandardowego "FFFF"

Specyfikator formatu niestandardowego "FFFF" (z czterema znakami "F") wyprowadza dziesięciotysięcznych części sekundy w przedziale czasu. W operacji formatowania wszystkie pozostałe cyfry ułamkowe są obcinane. Jeśli istnieją końcowe zera ułamkowe, nie są one uwzględniane w ciągu wynikowym. W operacji analizowania TimeSpan.ParseExact , która wywołuje metodę lub TimeSpan.TryParseExact , obecność dziesiątych, setnych, tysięowych i dziesiątych części drugiej cyfry jest opcjonalna.

W poniższym przykładzie użyto specyfikatora formatu niestandardowego "FFFF", aby wyświetlić dziesięciotysięcze części sekundy w wartości TimeSpan . Używa również specyfikatora formatu niestandardowego "FFFF" w operacji analizy.

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

Powrót do tabeli

Specyfikator formatu niestandardowego "FFFFF"

Specyfikator formatu niestandardowego "FFFFF" (z pięcioma znakami "F") wyprowadza stutysięcznych części sekundy w przedziale czasu. W operacji formatowania wszystkie pozostałe cyfry ułamkowe są obcinane. Jeśli istnieją końcowe zera ułamkowe, nie są one uwzględniane w ciągu wynikowym. TimeSpan.ParseExact W operacji analizowania, która wywołuje metodę lubTimeSpan.TryParseExact, obecność dziesiątych, setnych, tysięczych, dziesiątych i setnych części drugiej cyfry jest opcjonalna.

W poniższym przykładzie użyto specyfikatora formatu niestandardowego "FFFFF", aby wyświetlić stutysięcze części sekundy w wartości TimeSpan . Używa również specyfikatora formatu niestandardowego "FFFFF" w operacji analizy.

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

Powrót do tabeli

Specyfikator formatu niestandardowego "FFFFFF"

Specyfikator formatu niestandardowego "FFFFFF" (z sześcioma znakami "F") wyprowadza milionowe części sekundy w przedziale czasu. W operacji formatowania wszystkie pozostałe cyfry ułamkowe są obcinane. Jeśli istnieją końcowe zera ułamkowe, nie są one uwzględniane w ciągu wynikowym. TimeSpan.ParseExact W operacji analizowania, która wywołuje metodę lubTimeSpan.TryParseExact, obecność dziesiątych, setnych, tysięczych, dziesiątych, setnych, setnych i milionowych części drugiej cyfry jest opcjonalna.

W poniższym przykładzie użyto specyfikatora formatu niestandardowego "FFFFFF", aby wyświetlić milionowe części sekundy w wartości TimeSpan . Używa on również tego specyfikatora formatu niestandardowego w operacji analizowania.

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

Powrót do tabeli

Specyfikator formatu niestandardowego "FFFFFFF"

Specyfikator formatu niestandardowego "FFFFFFF" (z siedmiu znaków "F") wyprowadza dziesięciomiesięcznych części sekundy (lub ułamkową liczbę takt) w przedziale czasu. Jeśli istnieją końcowe zera ułamkowe, nie są one uwzględniane w ciągu wynikowym. W operacji analizowania, która wywołuje TimeSpan.ParseExact metodę lub TimeSpan.TryParseExact , obecność siedmiu cyfr ułamkowych w ciągu wejściowym jest opcjonalna.

W poniższym przykładzie użyto specyfikatora formatu niestandardowego "FFFFFFF", aby wyświetlić części ułamkowe sekundy w wartości TimeSpan . Używa on również tego specyfikatora formatu niestandardowego w operacji analizowania.

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     

Powrót do tabeli

Inne znaki

Każdy inny znak bezbłędny w ciągu formatu, w tym znak odstępu, jest interpretowany jako specyfikator formatu niestandardowego. W większości przypadków obecność dowolnego innego znaku bez żadnych efektów powoduje .FormatException

Istnieją dwa sposoby dołączania znaku literału do ciągu formatu:

  • Ujmij ją w pojedyncze cudzysłowy (ogranicznik ciągu literału).

  • Poprzedzi go ukośnikiem odwrotnym ("\"), który jest interpretowany jako znak ucieczki. Oznacza to, że w języku C# ciąg formatu musi być @-quoted lub znak literału musi być poprzedzony dodatkowym ukośnikiem odwrotnym.

    W niektórych przypadkach może być trzeba użyć logiki warunkowej, aby dołączyć literał ze znakem ucieczki do ciągu formatu. W poniższym przykładzie użyto logiki warunkowej, aby uwzględnić symbol znaku w negatywnych odstępach czasu.

    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 nie definiuje gramatyki dla separatorów w odstępach czasu. Oznacza to, że separatory między dniami i godzinami, godzinami i minutami, minutami i sekundami oraz sekundami i ułamkami sekundy muszą być traktowane jako literały znaków w ciągu formatu.

W poniższym przykładzie użyto zarówno znaku ucieczki, jak i pojedynczego cudzysłowu do zdefiniowania ciągu formatu niestandardowego, który zawiera wyraz "minutes" w ciągu wyjściowym.

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      

Powrót do tabeli

Zobacz też