Freigeben über

Benutzerdefinierte TimeSpan-Formatzeichenfolgen

Eine TimeSpan Formatzeichenfolge definiert die Zeichenfolgendarstellung eines TimeSpan Werts, der aus einem Formatierungsvorgang resultiert. Eine benutzerdefinierte Formatzeichenfolge besteht aus einem oder mehreren benutzerdefinierten TimeSpan Formatbezeichnern zusammen mit einer beliebigen Anzahl von Literalzeichen. Jede Zeichenfolge, die keine StandardtimeSpan-Formatzeichenfolge ist, wird als benutzerdefinierte TimeSpan Formatzeichenfolge interpretiert.

Wichtig

Die benutzerdefinierten TimeSpan Formatbezeichner enthalten keine Platzhaltertrennzeichensymbole, z. B. die Symbole, die Tage von Stunden, Stunden von Minuten oder Sekunden von Bruch sekunden trennen. Stattdessen müssen diese Symbole in die benutzerdefinierte Formatzeichenfolge als Zeichenfolgenliterale eingeschlossen werden. Beispielsweise definiert "dd\.hh\:mm" einen Punkt (.) als Trennzeichen zwischen Tagen und Stunden und einen Doppelpunkt (:) als Trennzeichen zwischen Stunden und Minuten).

Benutzerdefinierte TimeSpan Formatbezeichner enthalten auch kein Zeichensymbol, mit dem Sie zwischen negativen und positiven Zeitintervallen unterscheiden können. Um ein Zeichensymbol einzuschließen, müssen Sie eine Formatzeichenfolge mit bedingter Logik erstellen. Der Abschnitt Andere Zeichen enthält ein Beispiel.

Die Zeichenfolgendarstellungen von TimeSpan Werten werden durch Aufrufe der Überladungen der TimeSpan.ToString-Methode und durch Methoden erzeugt, die zusammengesetzte Formatierungen unterstützen, z. B. String.Format. Weitere Informationen finden Sie unter Formatierungstypen und zusammengesetzten Formatierungen. Im folgenden Beispiel wird die Verwendung von benutzerdefinierten Formatzeichenfolgen in Formatierungsvorgängen veranschaulicht.

using System;

public class Example
{
   public static void Main()
   {
      TimeSpan duration = new TimeSpan(1, 12, 23, 62);

      string output = null;
      output = "Time of Travel: " + duration.ToString("%d") + " days";
      Console.WriteLine(output);
      output = "Time of Travel: " + duration.ToString(@"dd\.hh\:mm\:ss");
      Console.WriteLine(output);

      Console.WriteLine($"Time of Travel: {duration:%d} day(s)");
      Console.WriteLine($"Time of Travel: {duration:dd\\.hh\\:mm\\:ss} days");
   }
}
// The example displays the following output:
//       Time of Travel: 1 days
//       Time of Travel: 01.12:24:02
//       Time of Travel: 1 day(s)
//       Time of Travel: 01.12:24:02 days

Module Example
    Public Sub Main()
        Dim duration As New TimeSpan(1, 12, 23, 62)

        Dim output As String = Nothing
        output = "Time of Travel: " + duration.ToString("%d") + " days"
        Console.WriteLine(output)
        output = "Time of Travel: " + duration.ToString("dd\.hh\:mm\:ss")
        Console.WriteLine(output)

        Console.WriteLine("Time of Travel: {0:%d} day(s)", duration)
        Console.WriteLine("Time of Travel: {0:dd\.hh\:mm\:ss} days", duration)
    End Sub
End Module
' The example displays the following output:
'       Time of Travel: 1 days
'       Time of Travel: 01.12:24:02
'       Time of Travel: 1 day(s)
'       Time of Travel: 01.12:24:02 days

Benutzerdefinierte TimeSpan Formatzeichenfolgen werden auch von den methoden TimeSpan.ParseExact und TimeSpan.TryParseExact verwendet, um das erforderliche Format von Eingabezeichenfolgen für Analysevorgänge zu definieren. (Die Analyse konvertiert die Zeichenfolgendarstellung eines Werts in diesen Wert.) Im folgenden Beispiel wird die Verwendung von Standardformatzeichenfolgen in Analysevorgängen veranschaulicht.

using System;

public class Example
{
   public static void Main()
   {
      string value = null;
      TimeSpan interval;

      value = "6";
      if (TimeSpan.TryParseExact(value, "%d", null, out interval))
         Console.WriteLine($"{value} --> {interval.ToString("c")}");
      else
         Console.WriteLine($"Unable to parse '{value}'");

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

      value= "12.035";
      if (TimeSpan.TryParseExact(value, "ss\\.fff", null, out interval))
         Console.WriteLine($"{value} --> {interval.ToString("c")}");
      else
         Console.WriteLine($"Unable to parse '{value}'");
   }
}
// The example displays the following output:
//       6 --> 6.00:00:00
//       16:32.05 --> 00:16:32.0500000
//       12.035 --> 00:00:12.0350000

Module Example
    Public Sub Main()
        Dim value As String = Nothing
        Dim interval As TimeSpan

        value = "6"
        If TimeSpan.TryParseExact(value, "%d", Nothing, interval) Then
            Console.WriteLine("{0} --> {1}", value, interval.ToString("c"))
        Else
            Console.WriteLine("Unable to parse '{0}'", value)
        End If

        value = "16:32.05"
        If TimeSpan.TryParseExact(value, "mm\:ss\.ff", Nothing, interval) Then
            Console.WriteLine("{0} --> {1}", value, interval.ToString("c"))
        Else
            Console.WriteLine("Unable to parse '{0}'", value)
        End If

        value = "12.035"
        If TimeSpan.TryParseExact(value, "ss\.fff", Nothing, interval) Then
            Console.WriteLine("{0} --> {1}", value, interval.ToString("c"))
        Else
            Console.WriteLine("Unable to parse '{0}'", value)
        End If
    End Sub
End Module
' The example displays the following output:
'       6 --> 6.00:00:00
'       16:32.05 --> 00:16:32.0500000
'       12.035 --> 00:00:12.0350000

In der folgenden Tabelle werden die benutzerdefinierten Datums- und Uhrzeitformatbezeichner beschrieben.

Formatbezeichner BESCHREIBUNG Beispiel
"d", "%d" Die Anzahl der ganzen Tage im Zeitintervall.

Weitere Informationen finden Sie unter: Der benutzerdefinierte Formatbezeichner „d“.		 new TimeSpan(6, 14, 32, 17, 685):

%d -> "6"

d\.hh\:mm --> "6.14:32"
"dd"-"dddddd" Die Anzahl der ganzen Tage im Zeitintervall, aufgefüllt mit führenden Nullen nach Bedarf.

Weitere Informationen: Die benutzerdefinierten Formatbezeichner "dd"-"d".		 new TimeSpan(6, 14, 32, 17, 685):

ddd --> "006"

dd\.hh\:mm -> "06.14:32"
"h", "%h" Die Anzahl der ganzen Stunden im Zeitintervall, die nicht als Teil von Tagen gezählt werden. Einstellige Stunden haben keine führende Null.

Weitere Informationen finden Sie unter: Der benutzerdefinierte Formatbezeichner „h“.		 new TimeSpan(6, 14, 32, 17, 685):

%h -> "14"

hh\:mm --> "14:32"
"Hh" Die Anzahl der ganzen Stunden im Zeitintervall, die nicht als Teil von Tagen gezählt werden. Einstellige Stunden haben eine führende Null.

Weitere Informationen finden Sie unter: Der benutzerdefinierte Formatbezeichner „hh“.		 new TimeSpan(6, 14, 32, 17, 685):

hh -> "14"

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

hh -> 08
"m", "%m" Die Anzahl der gesamten Minuten im Zeitintervall, die nicht als Teil von Stunden oder Tagen enthalten sind. Einstellige Minuten haben keine führende Null.

Weitere Informationen finden Sie unter: Der benutzerdefinierte Formatbezeichner „m“.		 new TimeSpan(6, 14, 8, 17, 685):

%m --> "8"

h\:m --> "14:8"
"mm" Die Anzahl der gesamten Minuten im Zeitintervall, die nicht als Teil von Stunden oder Tagen enthalten sind. Einstellige Minuten haben eine führende Null.

Weitere Informationen finden Sie unter: Der benutzerdefinierte Formatbezeichner „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" Die Anzahl der ganzen Sekunden im Zeitintervall, die nicht als Teil von Stunden, Tagen oder Minuten enthalten sind. Einstellige Sekunden haben keine führende Null.

Weitere Informationen finden Sie unter: Der benutzerdefinierte Formatbezeichner „s“.		 TimeSpan.FromSeconds(12.965):

%s --> 12

s\.fff --> 12.965 kg
"ss" Die Anzahl der ganzen Sekunden im Zeitintervall, die nicht als Teil von Stunden, Tagen oder Minuten enthalten sind. Einstellige Sekunden haben eine führende Null.

Weitere Informationen finden Sie unter: Der benutzerdefinierte Formatbezeichner „ss“.		 TimeSpan.FromSeconds(6.965):

ss -> 06

ss\.fff --> 06.965 kg
"f", "%f" Die Zehntel einer Sekunde in einem Zeitintervall.

Weitere Informationen finden Sie unter: Der benutzerdefinierte Formatbezeichner „f“.		 TimeSpan.FromSeconds(6.895):

f -> 8

ss\.f -> 06.8
ff Die Hundertstel einer Sekunde in einem Zeitintervall.

Weitere Informationen finden Sie unter: Der benutzerdefinierte Formatbezeichner „ff“.		 TimeSpan.FromSeconds(6.895):

ff --> 89

ss\.ff -> 06.89
"fff" Die Millisekunden in einem Zeitintervall.

Weitere Informationen finden Sie unter: Der benutzerdefinierte Formatbezeichner „fff“.		 TimeSpan.FromSeconds(6.895):

fff --> 895

ss\.fff -> 06.895
"ffff" Die Zehntausendstel einer Sekunde in einem Zeitintervall.

Weitere Informationen finden Sie unter: Der benutzerdefinierte Formatbezeichner „ffff“.		 TimeSpan.Parse("0:0:6.8954321"):

ffff --> 8954

ss\.ffff -> 06.8954
"fffff" Die Hunderttausendstel einer Sekunde in einem Zeitintervall.

Weitere Informationen finden Sie unter: Der benutzerdefinierte Formatbezeichner „fffff“.		 TimeSpan.Parse("0:0:6.8954321"):

fffff -> 89543

ss\.fffff --> 06.89543 kg
"ffffff" Die Millionstel einer Sekunde in einem Zeitintervall.

Weitere Informationen finden Sie unter: Der benutzerdefinierte Formatbezeichner „ffffff“.		 TimeSpan.Parse("0:0:6.8954321"):

ffffff -> 895432

ss\.ffffff -> 06.895432
"fffffff" Die zehn Millionenstel einer Sekunde (oder der Bruchstriche) in einem Zeitintervall.

Weitere Informationen finden Sie unter: Der benutzerdefinierte Formatbezeichner „fffffff“.		 TimeSpan.Parse("0:0:6.8954321"):

fffffff -> 8954321

ss\.fffffff --> 06.8954321 kg
"F", "%F" Die Zehntel einer Sekunde in einem Zeitintervall. Nichts wird angezeigt, wenn die Ziffer null ist.

Weitere Informationen finden Sie unter: Der benutzerdefinierte Formatbezeichner „F“.		 TimeSpan.Parse("00:00:06.32"):

%F: 3

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

ss\.F: 03.
"FF" Die Hundertstel einer Sekunde in einem Zeitintervall. Alle nachgestellten Nullen oder zwei Nullziffern sind nicht enthalten.

Weitere Informationen finden Sie unter: Der benutzerdefinierte Formatbezeichner „FF“.		 TimeSpan.Parse("00:00:06.329"):

FF: 32

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

ss\.FF: 03.1
"FFF" Die Millisekunden in einem Zeitintervall. Alle nachgestellten Nullen sind nicht enthalten.

Weitere Informationen:		 TimeSpan.Parse("00:00:06.3291"):

FFF: 329

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

ss\.FFF: 03.1
"FFFF" Die Zehntausendstel einer Sekunde in einem Zeitintervall. Alle nachgestellten Nullen sind nicht enthalten.

Weitere Informationen finden Sie unter: Der benutzerdefinierte Formatbezeichner „FFFF“.		 TimeSpan.Parse("00:00:06.32917"):

FFFFF: 3291

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

ss\.FFFF: 03.1
FFFFF Die Hunderttausendstel einer Sekunde in einem Zeitintervall. Alle nachgestellten Nullen sind nicht enthalten.

Weitere Informationen finden Sie unter: Der benutzerdefinierte Formatbezeichner „FFFFF“.		 TimeSpan.Parse("00:00:06.329179"):

FFFFF: 32917

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

ss\.FFFFF: 03.1
FFFFFF Die Millionstel einer Sekunde in einem Zeitintervall. Alle nachgestellten Nullen werden nicht angezeigt.

Weitere Informationen finden Sie unter: Der benutzerdefinierte Formatbezeichner „FFFFFF“.		 TimeSpan.Parse("00:00:06.3291791"):

FFFFFF: 329179

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

ss\.FFFFFF: 03.1
"FFFFFFF" Die zehn Millionen einer Sekunde in einem Zeitintervall. Alle nachgestellten Nullen oder sieben Nullen werden nicht angezeigt.

Weitere Informationen finden Sie unter: Der benutzerdefinierte Formatbezeichner „FFFFFFF“.		 TimeSpan.Parse("00:00:06.3291791"):

FFFFFF: 3291791

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

ss\.FFFFFF: 03.19
'Zeichenfolge' Trennzeichen für Literalzeichenfolge.

Weitere Informationen: Andere Zeichen.		 new TimeSpan(14, 32, 17):

hh':'mm':'ss --> "14:32:17"
\ Das Escapezeichen.

Weitere Informationen: Andere Zeichen.		 new TimeSpan(14, 32, 17):

hh\:mm\:ss --> "14:32:17"
Jedes andere Zeichen Alle anderen nicht gescapeten Zeichen werden als benutzerdefinierter Formatbezeichner interpretiert.

Weitere Informationen: Andere Zeichen.		 new TimeSpan(14, 32, 17):

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

Der benutzerdefinierte Formatbezeichner „d“

Der benutzerdefinierte Formatbezeichner "d" gibt den Wert der TimeSpan.Days-Eigenschaft aus, die die Anzahl der ganzen Tage im Zeitintervall darstellt. Er gibt die vollständige Anzahl von Tagen in einem TimeSpan-Wert aus, auch wenn der Wert mehr als eine Ziffer aufweist. Wenn der Wert der TimeSpan.Days-Eigenschaft null ist, gibt der Bezeichner "0" aus.

Wenn der benutzerdefinierte Formatbezeichner "d" allein verwendet wird, geben Sie "%d" an, damit er nicht als Standardformatzeichenfolge interpretiert wird. Dies wird im folgenden Beispiel veranschaulicht.

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

Das folgende Beispiel veranschaulicht die Verwendung des benutzerdefinierten Formatbezeichners "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

Zurück zur Tabelle

Die benutzerdefinierten Formatbezeichner "dd"-"ddddddd"

Die benutzerdefinierten Formatbezeichner "d", "d", "ddd", "dd", "dd" und "ddddd" geben den Wert der TimeSpan.Days-Eigenschaft aus, die die Anzahl der ganzen Tage im Zeitintervall darstellt.

Die Ausgabezeichenfolge enthält eine Mindestanzahl von Ziffern, die durch die Anzahl der "d"-Zeichen im Formatbezeichner angegeben werden, und sie wird bei Bedarf mit führenden Nullen aufgefüllt. Wenn die Ziffern in der Anzahl der Tage die Anzahl von "d" Zeichen im Formatbezeichner überschreiten, wird die vollständige Anzahl von Tagen in der Ergebniszeichenfolge ausgegeben.

Im folgenden Beispiel werden diese Formatbezeichner verwendet, um die Zeichenfolgendarstellung von zwei TimeSpan Werten anzuzeigen. Der Wert der Tagekomponente des ersten Zeitintervalls ist Null; der Wert der Tagekomponente der zweiten ist 365.

TimeSpan ts1 = new TimeSpan(0, 23, 17, 47);
TimeSpan ts2 = new TimeSpan(365, 21, 19, 45);

for (int ctr = 2; ctr <= 8; ctr++)
{
   string fmt = new String('d', ctr) + @"\.hh\:mm\:ss";
   Console.WriteLine($"{fmt} --> {ts1.ToString(fmt)}");
   Console.WriteLine($"{fmt} --> {ts2.ToString(fmt)}");
   Console.WriteLine();
}
// The example displays the following output:
//       dd\.hh\:mm\:ss --> 00.23:17:47
//       dd\.hh\:mm\:ss --> 365.21:19:45
//
//       ddd\.hh\:mm\:ss --> 000.23:17:47
//       ddd\.hh\:mm\:ss --> 365.21:19:45
//
//       dddd\.hh\:mm\:ss --> 0000.23:17:47
//       dddd\.hh\:mm\:ss --> 0365.21:19:45
//
//       ddddd\.hh\:mm\:ss --> 00000.23:17:47
//       ddddd\.hh\:mm\:ss --> 00365.21:19:45
//
//       dddddd\.hh\:mm\:ss --> 000000.23:17:47
//       dddddd\.hh\:mm\:ss --> 000365.21:19:45
//
//       ddddddd\.hh\:mm\:ss --> 0000000.23:17:47
//       ddddddd\.hh\:mm\:ss --> 0000365.21:19:45
//
//       dddddddd\.hh\:mm\:ss --> 00000000.23:17:47
//       dddddddd\.hh\:mm\:ss --> 00000365.21:19:45

Dim ts1 As New TimeSpan(0, 23, 17, 47)
Dim ts2 As New TimeSpan(365, 21, 19, 45)

For ctr As Integer = 2 To 8
    Dim fmt As String = New String("d"c, ctr) + "\.hh\:mm\:ss"
    Console.WriteLine("{0} --> {1:" + fmt + "}", fmt, ts1)
    Console.WriteLine("{0} --> {1:" + fmt + "}", fmt, ts2)
    Console.WriteLine()
Next
' The example displays the following output:
'       dd\.hh\:mm\:ss --> 00.23:17:47
'       dd\.hh\:mm\:ss --> 365.21:19:45
'       
'       ddd\.hh\:mm\:ss --> 000.23:17:47
'       ddd\.hh\:mm\:ss --> 365.21:19:45
'       
'       dddd\.hh\:mm\:ss --> 0000.23:17:47
'       dddd\.hh\:mm\:ss --> 0365.21:19:45
'       
'       ddddd\.hh\:mm\:ss --> 00000.23:17:47
'       ddddd\.hh\:mm\:ss --> 00365.21:19:45
'       
'       dddddd\.hh\:mm\:ss --> 000000.23:17:47
'       dddddd\.hh\:mm\:ss --> 000365.21:19:45
'       
'       ddddddd\.hh\:mm\:ss --> 0000000.23:17:47
'       ddddddd\.hh\:mm\:ss --> 0000365.21:19:45
'       
'       dddddddd\.hh\:mm\:ss --> 00000000.23:17:47
'       dddddddd\.hh\:mm\:ss --> 00000365.21:19:45

Zurück zur Tabelle

Der benutzerdefinierte Formatbezeichner „h“

Der benutzerdefinierte Formatbezeichner "h" gibt den Wert der TimeSpan.Hours-Eigenschaft aus, die die Anzahl der ganzen Stunden im Zeitintervall darstellt, das nicht als Teil der Tagkomponente gezählt wird. Es gibt einen einstelligen Zeichenfolgenwert zurück, wenn der Wert der eigenschaft TimeSpan.Hours 0 bis 9 ist, und es wird ein zweistelliger Zeichenfolgenwert zurückgegeben, wenn der Wert der TimeSpan.Hours-Eigenschaft zwischen 10 und 23 liegt.

Wenn der benutzerdefinierte Formatbezeichner "h" allein verwendet wird, geben Sie "%h" an, damit er nicht als Standardformatzeichenfolge interpretiert wird. Dies wird im folgenden Beispiel veranschaulicht.

TimeSpan ts = new TimeSpan(3, 42, 0);
Console.WriteLine($"{ts:%h} hours {ts:%m} minutes");
// The example displays the following output:
//       3 hours 42 minutes

Dim ts As New TimeSpan(3, 42, 0)
Console.WriteLine("{0:%h} hours {0:%m} minutes", ts)
' The example displays the following output:
'       3 hours 42 minutes

In einem Analysevorgang wird in einem Analysevorgang eine Eingabezeichenfolge, die nur eine einzelne Zahl enthält, als Die Anzahl der Tage interpretiert. Sie können stattdessen den benutzerdefinierten Formatbezeichner "%h" verwenden, um die numerische Zeichenfolge als Die Anzahl der Stunden zu interpretieren. Dies wird im folgenden Beispiel veranschaulicht.

string value = "8";
TimeSpan interval;
if (TimeSpan.TryParseExact(value, "%h", null, out interval))
   Console.WriteLine(interval.ToString("c"));
else
   Console.WriteLine($"Unable to convert '{value}' to a time interval");
// The example displays the following output:
//       08:00:00

Dim value As String = "8"
Dim interval As TimeSpan
If TimeSpan.TryParseExact(value, "%h", Nothing, interval) Then
    Console.WriteLine(interval.ToString("c"))
Else
    Console.WriteLine("Unable to convert '{0}' to a time interval",
                      value)
End If
' The example displays the following output:
'       08:00:00

Das folgende Beispiel veranschaulicht die Verwendung des benutzerdefinierten Formatbezeichners "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

Zurück zur Tabelle

Der benutzerdefinierte Formatbezeichner „hh“

Der benutzerdefinierte Formatbezeichner "hh" gibt den Wert der TimeSpan.Hours-Eigenschaft aus, die die Anzahl der ganzen Stunden im Zeitintervall darstellt, das nicht als Teil der Tageskomponente gezählt wird. Bei Werten zwischen 0 und 9 enthält die Ausgabezeichenfolge eine führende Null.

In einem Analysevorgang wird in einem Analysevorgang eine Eingabezeichenfolge, die nur eine einzelne Zahl enthält, als Die Anzahl der Tage interpretiert. Sie können stattdessen den benutzerdefinierten Formatbezeichner "hh" verwenden, um die numerische Zeichenfolge als Die Anzahl der Stunden zu interpretieren. Dies wird im folgenden Beispiel veranschaulicht.

string value = "08";
TimeSpan interval;
if (TimeSpan.TryParseExact(value, "hh", null, out interval))
   Console.WriteLine(interval.ToString("c"));
else
   Console.WriteLine($"Unable to convert '{value}' to a time interval");
// The example displays the following output:
//       08:00:00

Dim value As String = "08"
Dim interval As TimeSpan
If TimeSpan.TryParseExact(value, "hh", Nothing, interval) Then
    Console.WriteLine(interval.ToString("c"))
Else
    Console.WriteLine("Unable to convert '{0}' to a time interval",
                      value)
End If
' The example displays the following output:
'       08:00:00

Das folgende Beispiel veranschaulicht die Verwendung des benutzerdefinierten Formatbezeichners "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

Zurück zur Tabelle

Der benutzerdefinierte Formatbezeichner „m“

Der benutzerdefinierte Formatbezeichner "m" gibt den Wert der TimeSpan.Minutes-Eigenschaft aus, die die Anzahl der gesamten Minuten im Zeitintervall darstellt, das nicht als Teil der Tageskomponente gezählt wird. Es gibt einen einstelligen Zeichenfolgenwert zurück, wenn der Wert der eigenschaft TimeSpan.Minutes 0 bis 9 ist, und es wird ein zweistelliger Zeichenfolgenwert zurückgegeben, wenn der Wert der TimeSpan.Minutes-Eigenschaft zwischen 10 und 59 liegt.

Wenn der benutzerdefinierte Formatbezeichner "m" allein verwendet wird, geben Sie "%m" an, damit er nicht als Standardformatzeichenfolge interpretiert wird. Dies wird im folgenden Beispiel veranschaulicht.

TimeSpan ts = new TimeSpan(3, 42, 0);
Console.WriteLine($"{ts:%h} hours {ts:%m} minutes");
// The example displays the following output:
//       3 hours 42 minutes

Dim ts As New TimeSpan(3, 42, 0)
Console.WriteLine("{0:%h} hours {0:%m} minutes", ts)
' The example displays the following output:
'       3 hours 42 minutes

In einem Analysevorgang wird in einem Analysevorgang eine Eingabezeichenfolge, die nur eine einzelne Zahl enthält, als Die Anzahl der Tage interpretiert. Sie können stattdessen den benutzerdefinierten Formatbezeichner "%m" verwenden, um die numerische Zeichenfolge als Anzahl von Minuten zu interpretieren. Dies wird im folgenden Beispiel veranschaulicht.

string value = "3";
TimeSpan interval;
if (TimeSpan.TryParseExact(value, "%m", null, out interval))
   Console.WriteLine(interval.ToString("c"));
else
   Console.WriteLine($"Unable to convert '{value}' to a time interval");
// The example displays the following output:
//       00:03:00

Dim value As String = "3"
Dim interval As TimeSpan
If TimeSpan.TryParseExact(value, "%m", Nothing, interval) Then
    Console.WriteLine(interval.ToString("c"))
Else
    Console.WriteLine("Unable to convert '{0}' to a time interval",
                      value)
End If
' The example displays the following output:
'       00:03:00

Das folgende Beispiel veranschaulicht die Verwendung des benutzerdefinierten Formatbezeichners "m".

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

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

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

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

Zurück zur Tabelle

Der benutzerdefinierte Formatbezeichner „mm“

Der benutzerdefinierte Formatbezeichner "mm" gibt den Wert der TimeSpan.Minutes-Eigenschaft aus, die die Anzahl der gesamten Minuten im Zeitintervall darstellt, das nicht als Teil der Komponente "Stunden" oder "Tage" enthalten ist. Bei Werten zwischen 0 und 9 enthält die Ausgabezeichenfolge eine führende Null.

In einem Analysevorgang wird in einem Analysevorgang eine Eingabezeichenfolge, die nur eine einzelne Zahl enthält, als Die Anzahl der Tage interpretiert. Sie können stattdessen den benutzerdefinierten Formatbezeichner "mm" verwenden, um die numerische Zeichenfolge als Anzahl von Minuten zu interpretieren. Dies wird im folgenden Beispiel veranschaulicht.

string value = "07";
TimeSpan interval;
if (TimeSpan.TryParseExact(value, "mm", null, out interval))
   Console.WriteLine(interval.ToString("c"));
else
   Console.WriteLine($"Unable to convert '{value}' to a time interval");
// The example displays the following output:
//       00:07:00

Dim value As String = "05"
Dim interval As TimeSpan
If TimeSpan.TryParseExact(value, "mm", Nothing, interval) Then
    Console.WriteLine(interval.ToString("c"))
Else
    Console.WriteLine("Unable to convert '{0}' to a time interval",
                      value)
End If
' The example displays the following output:
'       00:05:00

Im folgenden Beispiel wird die Verwendung des benutzerdefinierten Formatbezeichners "mm" veranschaulicht.

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

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

Zurück zur Tabelle

Der benutzerdefinierte Formatbezeichner „s“

Der benutzerdefinierte Formatbezeichner "s" gibt den Wert der TimeSpan.Seconds-Eigenschaft aus, die die Anzahl der ganzen Sekunden im Zeitintervall darstellt, das nicht als Teil der Komponente "Stunden", "Tage" oder "Minuten" enthalten ist. Es gibt einen einstelligen Zeichenfolgenwert zurück, wenn der Wert der eigenschaft TimeSpan.Seconds 0 bis 9 ist, und es wird ein zweistelliger Zeichenfolgenwert zurückgegeben, wenn der Wert der TimeSpan.Seconds-Eigenschaft zwischen 10 und 59 liegt.

Wenn der benutzerdefinierte Formatbezeichner "s" allein verwendet wird, geben Sie "%s" an, damit er nicht als Standardformatzeichenfolge interpretiert wird. Dies wird im folgenden Beispiel veranschaulicht.

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

In einem Analysevorgang wird in einem Analysevorgang eine Eingabezeichenfolge, die nur eine einzelne Zahl enthält, als Die Anzahl der Tage interpretiert. Sie können stattdessen den benutzerdefinierten Formatbezeichner "%s" verwenden, um die numerische Zeichenfolge als Anzahl von Sekunden zu interpretieren. Dies wird im folgenden Beispiel veranschaulicht.

string value = "9";
TimeSpan interval;
if (TimeSpan.TryParseExact(value, "%s", null, out interval))
   Console.WriteLine(interval.ToString("c"));
else
   Console.WriteLine($"Unable to convert '{value}' to a time interval");
// The example displays the following output:
//       00:00:09

Dim value As String = "9"
Dim interval As TimeSpan
If TimeSpan.TryParseExact(value, "%s", Nothing, interval) Then
    Console.WriteLine(interval.ToString("c"))
Else
    Console.WriteLine("Unable to convert '{0}' to a time interval",
                      value)
End If
' The example displays the following output:
'       00:00:09

Das folgende Beispiel veranschaulicht die Verwendung des benutzerdefinierten Formatbezeichners "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

Zurück zur Tabelle

Der benutzerdefinierte Formatbezeichner „ss“

Der benutzerdefinierte Formatbezeichner "ss" gibt den Wert der TimeSpan.Seconds-Eigenschaft aus, die die Anzahl der ganzen Sekunden im Zeitintervall darstellt, das nicht als Teil der Komponente "Stunden", "Tage" oder "Minuten" enthalten ist. Bei Werten zwischen 0 und 9 enthält die Ausgabezeichenfolge eine führende Null.

In einem Analysevorgang wird in einem Analysevorgang eine Eingabezeichenfolge, die nur eine einzelne Zahl enthält, als Die Anzahl der Tage interpretiert. Sie können stattdessen den benutzerdefinierten Formatbezeichner "ss" verwenden, um die numerische Zeichenfolge als Anzahl von Sekunden zu interpretieren. Dies wird im folgenden Beispiel veranschaulicht.

string[] values = { "49", "9", "06" };
TimeSpan interval;
foreach (string value in values)
{
   if (TimeSpan.TryParseExact(value, "ss", null, out interval))
      Console.WriteLine(interval.ToString("c"));
   else
      Console.WriteLine($"Unable to convert '{value}' to a time interval");
}
// The example displays the following output:
//       00:00:49
//       Unable to convert '9' to a time interval
//       00:00:06

Dim values() As String = {"49", "9", "06"}
Dim interval As TimeSpan
For Each value As String In values
    If TimeSpan.TryParseExact(value, "ss", Nothing, interval) Then
        Console.WriteLine(interval.ToString("c"))
    Else
        Console.WriteLine("Unable to convert '{0}' to a time interval",
                          value)
    End If
Next
' The example displays the following output:
'       00:00:49
'       Unable to convert '9' to a time interval
'       00:00:06

Das folgende Beispiel veranschaulicht die Verwendung des benutzerdefinierten Formatbezeichners "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

Zurück zur Tabelle

Der benutzerdefinierte Formatbezeichner „f“

Der benutzerdefinierte Formatbezeichner "f" gibt die Zehntel einer Sekunde in einem Zeitintervall aus. In einem Formatierungsvorgang werden alle verbleibenden Bruchziffern abgeschnitten. In einem Analysevorgang, der die TimeSpan.ParseExact- oder TimeSpan.TryParseExact-Methode aufruft, muss die Eingabezeichenfolge genau eine Bruchzahl enthalten.

Wenn der benutzerdefinierte Formatbezeichner "f" allein verwendet wird, geben Sie "%f" an, sodass er nicht als Standardformatzeichenfolge interpretiert wird.

Im folgenden Beispiel wird der benutzerdefinierte Formatbezeichner "f" verwendet, um die Zehntel einer Sekunde in einem TimeSpan Wert anzuzeigen. "f" wird zuerst als einziger Formatbezeichner verwendet und dann mit dem Bezeichner "s" in einer benutzerdefinierten Formatzeichenfolge kombiniert.

TimeSpan ts = new TimeSpan(1003498765432);
string fmt;
Console.WriteLine(ts.ToString("c"));
Console.WriteLine();

for (int ctr = 1; ctr <= 7; ctr++) {
   fmt = new string('f', ctr);
   if (fmt.Length == 1) fmt = "%" + fmt;
   Console.WriteLine($"{fmt,10}: {ts.ToString(fmt)}");
}
Console.WriteLine();

for (int ctr = 1; ctr <= 7; ctr++) {
   fmt = $"s\\.{new string('f', ctr)}";
   Console.WriteLine($"{fmt,10}: {ts.ToString(fmt)}");
}
// The example displays the following output:
//               %f: 8
//               ff: 87
//              fff: 876
//             ffff: 8765
//            fffff: 87654
//           ffffff: 876543
//          fffffff: 8765432
//
//              s\.f: 29.8
//             s\.ff: 29.87
//            s\.fff: 29.876
//           s\.ffff: 29.8765
//          s\.fffff: 29.87654
//         s\.ffffff: 29.876543
//        s\.fffffff: 29.8765432

Dim ts As New TimeSpan(1003498765432)
Dim fmt As String
Console.WriteLine(ts.ToString("c"))
Console.WriteLine()

For ctr = 1 To 7
    fmt = New String("f"c, ctr)
    If fmt.Length = 1 Then fmt = "%" + fmt
    Console.WriteLine("{0,10}: {1:" + fmt + "}", fmt, ts)
Next
Console.WriteLine()

For ctr = 1 To 7
    fmt = New String("f"c, ctr)
    Console.WriteLine("{0,10}: {1:s\." + fmt + "}", "s\." + fmt, ts)
Next
' The example displays the following output:
'            %f: 8
'            ff: 87
'           fff: 876
'          ffff: 8765
'         fffff: 87654
'        ffffff: 876543
'       fffffff: 8765432
'    
'           s\.f: 29.8
'          s\.ff: 29.87
'         s\.fff: 29.876
'        s\.ffff: 29.8765
'       s\.fffff: 29.87654
'      s\.ffffff: 29.876543
'     s\.fffffff: 29.8765432

Zurück zur Tabelle

Der benutzerdefinierte Formatbezeichner „ff“

Der benutzerdefinierte Formatbezeichner "ff" gibt die Hundertstel einer Sekunde in einem Zeitintervall aus. In einem Formatierungsvorgang werden alle verbleibenden Bruchziffern abgeschnitten. In einem Analysevorgang, der die TimeSpan.ParseExact- oder TimeSpan.TryParseExact-Methode aufruft, muss die Eingabezeichenfolge genau zwei Bruchstellen enthalten.

Im folgenden Beispiel wird der benutzerdefinierte Formatbezeichner "ff" verwendet, um die Hundertstel einer Sekunde in einem TimeSpan Wert anzuzeigen. "ff" wird zuerst als einziger Formatbezeichner verwendet und dann mit dem Bezeichner "s" in einer benutzerdefinierten Formatzeichenfolge kombiniert.

TimeSpan ts = new TimeSpan(1003498765432);
string fmt;
Console.WriteLine(ts.ToString("c"));
Console.WriteLine();

for (int ctr = 1; ctr <= 7; ctr++) {
   fmt = new string('f', ctr);
   if (fmt.Length == 1) fmt = "%" + fmt;
   Console.WriteLine($"{fmt,10}: {ts.ToString(fmt)}");
}
Console.WriteLine();

for (int ctr = 1; ctr <= 7; ctr++) {
   fmt = $"s\\.{new string('f', ctr)}";
   Console.WriteLine($"{fmt,10}: {ts.ToString(fmt)}");
}
// The example displays the following output:
//               %f: 8
//               ff: 87
//              fff: 876
//             ffff: 8765
//            fffff: 87654
//           ffffff: 876543
//          fffffff: 8765432
//
//              s\.f: 29.8
//             s\.ff: 29.87
//            s\.fff: 29.876
//           s\.ffff: 29.8765
//          s\.fffff: 29.87654
//         s\.ffffff: 29.876543
//        s\.fffffff: 29.8765432

Dim ts As New TimeSpan(1003498765432)
Dim fmt As String
Console.WriteLine(ts.ToString("c"))
Console.WriteLine()

For ctr = 1 To 7
    fmt = New String("f"c, ctr)
    If fmt.Length = 1 Then fmt = "%" + fmt
    Console.WriteLine("{0,10}: {1:" + fmt + "}", fmt, ts)
Next
Console.WriteLine()

For ctr = 1 To 7
    fmt = New String("f"c, ctr)
    Console.WriteLine("{0,10}: {1:s\." + fmt + "}", "s\." + fmt, ts)
Next
' The example displays the following output:
'            %f: 8
'            ff: 87
'           fff: 876
'          ffff: 8765
'         fffff: 87654
'        ffffff: 876543
'       fffffff: 8765432
'    
'           s\.f: 29.8
'          s\.ff: 29.87
'         s\.fff: 29.876
'        s\.ffff: 29.8765
'       s\.fffff: 29.87654
'      s\.ffffff: 29.876543
'     s\.fffffff: 29.8765432

Zurück zur Tabelle

Der benutzerdefinierte Formatbezeichner „fff“

Der benutzerdefinierte Formatbezeichner "fff" (mit drei "f"-Zeichen) gibt die Millisekunden in einem Zeitintervall aus. In einem Formatierungsvorgang werden alle verbleibenden Bruchziffern abgeschnitten. In einem Analysevorgang, der die TimeSpan.ParseExact- oder TimeSpan.TryParseExact-Methode aufruft, muss die Eingabezeichenfolge genau drei Dezimalstellen enthalten.

Im folgenden Beispiel wird der benutzerdefinierte Formatbezeichner "fff" verwendet, um die Millisekunden in einem TimeSpan Wert anzuzeigen. "fff" wird zuerst als einziger Formatbezeichner verwendet und dann mit dem Bezeichner "s" in einer benutzerdefinierten Formatzeichenfolge kombiniert.

TimeSpan ts = new TimeSpan(1003498765432);
string fmt;
Console.WriteLine(ts.ToString("c"));
Console.WriteLine();

for (int ctr = 1; ctr <= 7; ctr++) {
   fmt = new string('f', ctr);
   if (fmt.Length == 1) fmt = "%" + fmt;
   Console.WriteLine($"{fmt,10}: {ts.ToString(fmt)}");
}
Console.WriteLine();

for (int ctr = 1; ctr <= 7; ctr++) {
   fmt = $"s\\.{new string('f', ctr)}";
   Console.WriteLine($"{fmt,10}: {ts.ToString(fmt)}");
}
// The example displays the following output:
//               %f: 8
//               ff: 87
//              fff: 876
//             ffff: 8765
//            fffff: 87654
//           ffffff: 876543
//          fffffff: 8765432
//
//              s\.f: 29.8
//             s\.ff: 29.87
//            s\.fff: 29.876
//           s\.ffff: 29.8765
//          s\.fffff: 29.87654
//         s\.ffffff: 29.876543
//        s\.fffffff: 29.8765432

Dim ts As New TimeSpan(1003498765432)
Dim fmt As String
Console.WriteLine(ts.ToString("c"))
Console.WriteLine()

For ctr = 1 To 7
    fmt = New String("f"c, ctr)
    If fmt.Length = 1 Then fmt = "%" + fmt
    Console.WriteLine("{0,10}: {1:" + fmt + "}", fmt, ts)
Next
Console.WriteLine()

For ctr = 1 To 7
    fmt = New String("f"c, ctr)
    Console.WriteLine("{0,10}: {1:s\." + fmt + "}", "s\." + fmt, ts)
Next
' The example displays the following output:
'            %f: 8
'            ff: 87
'           fff: 876
'          ffff: 8765
'         fffff: 87654
'        ffffff: 876543
'       fffffff: 8765432
'    
'           s\.f: 29.8
'          s\.ff: 29.87
'         s\.fff: 29.876
'        s\.ffff: 29.8765
'       s\.fffff: 29.87654
'      s\.ffffff: 29.876543
'     s\.fffffff: 29.8765432

Zurück zur Tabelle

Der benutzerdefinierte Formatbezeichner „ffff“

Der benutzerdefinierte Formatbezeichner "ffff" (mit vier "f"-Zeichen) gibt die Zehntausendstel einer Sekunde in einem Zeitintervall aus. In einem Formatierungsvorgang werden alle verbleibenden Bruchziffern abgeschnitten. In einem Analysevorgang, der die TimeSpan.ParseExact- oder TimeSpan.TryParseExact-Methode aufruft, muss die Eingabezeichenfolge genau vier Dezimalstellen enthalten.

Im folgenden Beispiel wird der benutzerdefinierte Formatbezeichner "ffff" verwendet, um die Zehntausendstel einer Sekunde in einem TimeSpan Wert anzuzeigen. "ffff" wird zuerst als einziger Formatbezeichner verwendet und dann mit dem Bezeichner "s" in einer benutzerdefinierten Formatzeichenfolge kombiniert.

TimeSpan ts = new TimeSpan(1003498765432);
string fmt;
Console.WriteLine(ts.ToString("c"));
Console.WriteLine();

for (int ctr = 1; ctr <= 7; ctr++) {
   fmt = new string('f', ctr);
   if (fmt.Length == 1) fmt = "%" + fmt;
   Console.WriteLine($"{fmt,10}: {ts.ToString(fmt)}");
}
Console.WriteLine();

for (int ctr = 1; ctr <= 7; ctr++) {
   fmt = $"s\\.{new string('f', ctr)}";
   Console.WriteLine($"{fmt,10}: {ts.ToString(fmt)}");
}
// The example displays the following output:
//               %f: 8
//               ff: 87
//              fff: 876
//             ffff: 8765
//            fffff: 87654
//           ffffff: 876543
//          fffffff: 8765432
//
//              s\.f: 29.8
//             s\.ff: 29.87
//            s\.fff: 29.876
//           s\.ffff: 29.8765
//          s\.fffff: 29.87654
//         s\.ffffff: 29.876543
//        s\.fffffff: 29.8765432

Dim ts As New TimeSpan(1003498765432)
Dim fmt As String
Console.WriteLine(ts.ToString("c"))
Console.WriteLine()

For ctr = 1 To 7
    fmt = New String("f"c, ctr)
    If fmt.Length = 1 Then fmt = "%" + fmt
    Console.WriteLine("{0,10}: {1:" + fmt + "}", fmt, ts)
Next
Console.WriteLine()

For ctr = 1 To 7
    fmt = New String("f"c, ctr)
    Console.WriteLine("{0,10}: {1:s\." + fmt + "}", "s\." + fmt, ts)
Next
' The example displays the following output:
'            %f: 8
'            ff: 87
'           fff: 876
'          ffff: 8765
'         fffff: 87654
'        ffffff: 876543
'       fffffff: 8765432
'    
'           s\.f: 29.8
'          s\.ff: 29.87
'         s\.fff: 29.876
'        s\.ffff: 29.8765
'       s\.fffff: 29.87654
'      s\.ffffff: 29.876543
'     s\.fffffff: 29.8765432

Zurück zur Tabelle

Der benutzerdefinierte Formatbezeichner „fffff“

Der benutzerdefinierte Formatbezeichner "fffff" (mit fünf "f"-Zeichen) gibt die Hunderttausendstel einer Sekunde in einem Zeitintervall aus. In einem Formatierungsvorgang werden alle verbleibenden Bruchziffern abgeschnitten. In einem Analysevorgang, der die TimeSpan.ParseExact- oder TimeSpan.TryParseExact-Methode aufruft, muss die Eingabezeichenfolge genau fünf Bruchstellen enthalten.

Im folgenden Beispiel wird der benutzerdefinierte Formatbezeichner "fffff" verwendet, um die Hunderttausendstel einer Sekunde in einem TimeSpan Wert anzuzeigen. "fffff" wird zuerst als einziger Formatbezeichner verwendet und dann mit dem Bezeichner "s" in einer benutzerdefinierten Formatzeichenfolge kombiniert.

TimeSpan ts = new TimeSpan(1003498765432);
string fmt;
Console.WriteLine(ts.ToString("c"));
Console.WriteLine();

for (int ctr = 1; ctr <= 7; ctr++) {
   fmt = new string('f', ctr);
   if (fmt.Length == 1) fmt = "%" + fmt;
   Console.WriteLine($"{fmt,10}: {ts.ToString(fmt)}");
}
Console.WriteLine();

for (int ctr = 1; ctr <= 7; ctr++) {
   fmt = $"s\\.{new string('f', ctr)}";
   Console.WriteLine($"{fmt,10}: {ts.ToString(fmt)}");
}
// The example displays the following output:
//               %f: 8
//               ff: 87
//              fff: 876
//             ffff: 8765
//            fffff: 87654
//           ffffff: 876543
//          fffffff: 8765432
//
//              s\.f: 29.8
//             s\.ff: 29.87
//            s\.fff: 29.876
//           s\.ffff: 29.8765
//          s\.fffff: 29.87654
//         s\.ffffff: 29.876543
//        s\.fffffff: 29.8765432

Dim ts As New TimeSpan(1003498765432)
Dim fmt As String
Console.WriteLine(ts.ToString("c"))
Console.WriteLine()

For ctr = 1 To 7
    fmt = New String("f"c, ctr)
    If fmt.Length = 1 Then fmt = "%" + fmt
    Console.WriteLine("{0,10}: {1:" + fmt + "}", fmt, ts)
Next
Console.WriteLine()

For ctr = 1 To 7
    fmt = New String("f"c, ctr)
    Console.WriteLine("{0,10}: {1:s\." + fmt + "}", "s\." + fmt, ts)
Next
' The example displays the following output:
'            %f: 8
'            ff: 87
'           fff: 876
'          ffff: 8765
'         fffff: 87654
'        ffffff: 876543
'       fffffff: 8765432
'    
'           s\.f: 29.8
'          s\.ff: 29.87
'         s\.fff: 29.876
'        s\.ffff: 29.8765
'       s\.fffff: 29.87654
'      s\.ffffff: 29.876543
'     s\.fffffff: 29.8765432

Zurück zur Tabelle

Der benutzerdefinierte Formatbezeichner „ffffff“

Der benutzerdefinierte Formatbezeichner "ffffff" (mit sechs "f"-Zeichen) gibt die Millionstel einer Sekunde in einem Zeitintervall aus. In einem Formatierungsvorgang werden alle verbleibenden Bruchziffern abgeschnitten. In einem Analysevorgang, der die TimeSpan.ParseExact- oder TimeSpan.TryParseExact-Methode aufruft, muss die Eingabezeichenfolge genau sechs Bruchstellen enthalten.

Im folgenden Beispiel wird der benutzerdefinierte Formatbezeichner "ffffff" verwendet, um die Millionstel einer Sekunde in einem TimeSpan Wert anzuzeigen. Sie wird zuerst als einziger Formatbezeichner verwendet und dann mit dem Bezeichner "s" in einer benutzerdefinierten Formatzeichenfolge kombiniert.

TimeSpan ts = new TimeSpan(1003498765432);
string fmt;
Console.WriteLine(ts.ToString("c"));
Console.WriteLine();

for (int ctr = 1; ctr <= 7; ctr++) {
   fmt = new string('f', ctr);
   if (fmt.Length == 1) fmt = "%" + fmt;
   Console.WriteLine($"{fmt,10}: {ts.ToString(fmt)}");
}
Console.WriteLine();

for (int ctr = 1; ctr <= 7; ctr++) {
   fmt = $"s\\.{new string('f', ctr)}";
   Console.WriteLine($"{fmt,10}: {ts.ToString(fmt)}");
}
// The example displays the following output:
//               %f: 8
//               ff: 87
//              fff: 876
//             ffff: 8765
//            fffff: 87654
//           ffffff: 876543
//          fffffff: 8765432
//
//              s\.f: 29.8
//             s\.ff: 29.87
//            s\.fff: 29.876
//           s\.ffff: 29.8765
//          s\.fffff: 29.87654
//         s\.ffffff: 29.876543
//        s\.fffffff: 29.8765432

Dim ts As New TimeSpan(1003498765432)
Dim fmt As String
Console.WriteLine(ts.ToString("c"))
Console.WriteLine()

For ctr = 1 To 7
    fmt = New String("f"c, ctr)
    If fmt.Length = 1 Then fmt = "%" + fmt
    Console.WriteLine("{0,10}: {1:" + fmt + "}", fmt, ts)
Next
Console.WriteLine()

For ctr = 1 To 7
    fmt = New String("f"c, ctr)
    Console.WriteLine("{0,10}: {1:s\." + fmt + "}", "s\." + fmt, ts)
Next
' The example displays the following output:
'            %f: 8
'            ff: 87
'           fff: 876
'          ffff: 8765
'         fffff: 87654
'        ffffff: 876543
'       fffffff: 8765432
'    
'           s\.f: 29.8
'          s\.ff: 29.87
'         s\.fff: 29.876
'        s\.ffff: 29.8765
'       s\.fffff: 29.87654
'      s\.ffffff: 29.876543
'     s\.fffffff: 29.8765432

Zurück zur Tabelle

Benutzerdefinierte Formatbezeichner „fffffff“

Der benutzerdefinierte Formatbezeichner "fffffff" (mit sieben "f"-Zeichen) gibt die zehn Millionenstel einer Sekunde (oder die Bruchzahl der Teilstriche) in einem Zeitintervall aus. In einem Analysevorgang, der die TimeSpan.ParseExact- oder TimeSpan.TryParseExact-Methode aufruft, muss die Eingabezeichenfolge genau sieben Dezimalstellen enthalten.

Im folgenden Beispiel wird der benutzerdefinierte Formatbezeichner "fffffff" verwendet, um die Bruchzahl der Teilstriche in einem TimeSpan Wert anzuzeigen. Sie wird zuerst als einziger Formatbezeichner verwendet und dann mit dem Bezeichner "s" in einer benutzerdefinierten Formatzeichenfolge kombiniert.

TimeSpan ts = new TimeSpan(1003498765432);
string fmt;
Console.WriteLine(ts.ToString("c"));
Console.WriteLine();

for (int ctr = 1; ctr <= 7; ctr++) {
   fmt = new string('f', ctr);
   if (fmt.Length == 1) fmt = "%" + fmt;
   Console.WriteLine($"{fmt,10}: {ts.ToString(fmt)}");
}
Console.WriteLine();

for (int ctr = 1; ctr <= 7; ctr++) {
   fmt = $"s\\.{new string('f', ctr)}";
   Console.WriteLine($"{fmt,10}: {ts.ToString(fmt)}");
}
// The example displays the following output:
//               %f: 8
//               ff: 87
//              fff: 876
//             ffff: 8765
//            fffff: 87654
//           ffffff: 876543
//          fffffff: 8765432
//
//              s\.f: 29.8
//             s\.ff: 29.87
//            s\.fff: 29.876
//           s\.ffff: 29.8765
//          s\.fffff: 29.87654
//         s\.ffffff: 29.876543
//        s\.fffffff: 29.8765432

Dim ts As New TimeSpan(1003498765432)
Dim fmt As String
Console.WriteLine(ts.ToString("c"))
Console.WriteLine()

For ctr = 1 To 7
    fmt = New String("f"c, ctr)
    If fmt.Length = 1 Then fmt = "%" + fmt
    Console.WriteLine("{0,10}: {1:" + fmt + "}", fmt, ts)
Next
Console.WriteLine()

For ctr = 1 To 7
    fmt = New String("f"c, ctr)
    Console.WriteLine("{0,10}: {1:s\." + fmt + "}", "s\." + fmt, ts)
Next
' The example displays the following output:
'            %f: 8
'            ff: 87
'           fff: 876
'          ffff: 8765
'         fffff: 87654
'        ffffff: 876543
'       fffffff: 8765432
'    
'           s\.f: 29.8
'          s\.ff: 29.87
'         s\.fff: 29.876
'        s\.ffff: 29.8765
'       s\.fffff: 29.87654
'      s\.ffffff: 29.876543
'     s\.fffffff: 29.8765432

Zurück zur Tabelle

Der benutzerdefinierte Formatbezeichner „F“

Der benutzerdefinierte F-Formatbezeichner gibt die Zehntel einer Sekunde in einem Zeitintervall aus. In einem Formatierungsvorgang werden alle verbleibenden Bruchziffern abgeschnitten. Wenn der Wert der Zehntel einer Sekunde des Zeitintervalls null ist, ist er nicht in der Ergebniszeichenfolge enthalten. Bei einem Analysevorgang, der die TimeSpan.ParseExact- oder TimeSpan.TryParseExact-Methode aufruft, ist das Vorhandensein der Zehntel einer zweiten Ziffer optional.

Wenn der benutzerdefinierte F-Formatbezeichner allein verwendet wird, geben Sie "%F" an, damit er nicht als Standardformatzeichenfolge interpretiert wird.

Im folgenden Beispiel wird der benutzerdefinierte F-Formatbezeichner verwendet, um die Zehntel einer Sekunde in einem TimeSpan Wert anzuzeigen. Außerdem wird dieser benutzerdefinierte Formatbezeichner in einem Analysevorgang verwendet.

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

TimeSpan ts2 = TimeSpan.Parse("0:0:3.091");
Console.WriteLine($"{ts2} ('ss\\.F') --> {ts2:ss\\.F}");
Console.WriteLine();

Console.WriteLine("Parsing:");
string[] inputs = { "0:0:03.", "0:0:03.1", "0:0:03.12" };
string fmt = @"h\:m\:ss\.F";
TimeSpan ts3;

foreach (string input in inputs) {
   if (TimeSpan.TryParseExact(input, fmt, null, out ts3))
      Console.WriteLine($"{input} ('{fmt}') --> {ts3}");
   else
      Console.WriteLine($"Cannot parse {input} with '{fmt}'.");
}
// The example displays the following output:
//       Formatting:
//       00:00:03.6690000 ('%F') --> 6
//       00:00:03.0910000 ('ss\.F') --> 03.
//
//       Parsing:
//       0:0:03. ('h\:m\:ss\.F') --> 00:00:03
//       0:0:03.1 ('h\:m\:ss\.F') --> 00:00:03.1000000
//       Cannot parse 0:0:03.12 with 'h\:m\:ss\.F'.

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

Dim ts2 As TimeSpan = TimeSpan.Parse("0:0:3.091")
Console.WriteLine("{0} ('ss\.F') --> {0:ss\.F}", ts2)
Console.WriteLine()

Console.WriteLine("Parsing:")
Dim inputs() As String = {"0:0:03.", "0:0:03.1", "0:0:03.12"}
Dim fmt As String = "h\:m\:ss\.F"
Dim ts3 As TimeSpan

For Each input As String In inputs
    If TimeSpan.TryParseExact(input, fmt, Nothing, ts3)
        Console.WriteLine("{0} ('{1}') --> {2}", input, fmt, ts3)
    Else
        Console.WriteLine("Cannot parse {0} with '{1}'.",
                          input, fmt)
    End If
Next
' The example displays the following output:
'       Formatting:
'       00:00:03.6690000 ('%F') --> 6
'       00:00:03.0910000 ('ss\.F') --> 03.
'       
'       Parsing:
'       0:0:03. ('h\:m\:ss\.F') --> 00:00:03
'       0:0:03.1 ('h\:m\:ss\.F') --> 00:00:03.1000000
'       Cannot parse 0:0:03.12 with 'h\:m\:ss\.F'.

Zurück zur Tabelle

Der benutzerdefinierte Formatbezeichner „FF“

Der benutzerdefinierte Formatbezeichner "FF" gibt die Hundertstel einer Sekunde in einem Zeitintervall aus. In einem Formatierungsvorgang werden alle verbleibenden Bruchziffern abgeschnitten. Wenn nachgestellte Bruchzahlen vorhanden sind, sind sie nicht in der Ergebniszeichenfolge enthalten. Bei einem Analysevorgang, der die TimeSpan.ParseExact- oder TimeSpan.TryParseExact-Methode aufruft, ist das Vorhandensein der Zehntel und Hundertstel einer zweiten Ziffer optional.

Im folgenden Beispiel wird der benutzerdefinierte Formatbezeichner "FF" verwendet, um die Hundertstel einer Sekunde in einem TimeSpan Wert anzuzeigen. Außerdem wird dieser benutzerdefinierte Formatbezeichner in einem Analysevorgang verwendet.

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

TimeSpan ts2 = TimeSpan.Parse("0:0:3.809");
Console.WriteLine($"{ts2} ('ss\\.FF') --> {ts2:ss\\.FF}");
Console.WriteLine();

Console.WriteLine("Parsing:");
string[] inputs = { "0:0:03.", "0:0:03.1", "0:0:03.127" };
string fmt = @"h\:m\:ss\.FF";
TimeSpan ts3;

foreach (string input in inputs) {
   if (TimeSpan.TryParseExact(input, fmt, null, out ts3))
      Console.WriteLine($"{input} ('{fmt}') --> {ts3}");
   else
      Console.WriteLine($"Cannot parse {input} with '{fmt}'.");
}
// The example displays the following output:
//       Formatting:
//       00:00:03.6970000 ('FF') --> 69
//       00:00:03.8090000 ('ss\.FF') --> 03.8
//
//       Parsing:
//       0:0:03. ('h\:m\:ss\.FF') --> 00:00:03
//       0:0:03.1 ('h\:m\:ss\.FF') --> 00:00:03.1000000
//       Cannot parse 0:0:03.127 with 'h\:m\:ss\.FF'.

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

Dim ts2 As TimeSpan = TimeSpan.Parse("0:0:3.809")
Console.WriteLine("{0} ('ss\.FF') --> {0:ss\.FF}", ts2)
Console.WriteLine()

Console.WriteLine("Parsing:")
Dim inputs() As String = {"0:0:03.", "0:0:03.1", "0:0:03.127"}
Dim fmt As String = "h\:m\:ss\.FF"
Dim ts3 As TimeSpan

For Each input As String In inputs
    If TimeSpan.TryParseExact(input, fmt, Nothing, ts3)
        Console.WriteLine("{0} ('{1}') --> {2}", input, fmt, ts3)
    Else
        Console.WriteLine("Cannot parse {0} with '{1}'.",
                          input, fmt)
    End If
Next
' The example displays the following output:
'       Formatting:
'       00:00:03.6970000 ('FF') --> 69
'       00:00:03.8090000 ('ss\.FF') --> 03.8
'       
'       Parsing:
'       0:0:03. ('h\:m\:ss\.FF') --> 00:00:03
'       0:0:03.1 ('h\:m\:ss\.FF') --> 00:00:03.1000000
'       Cannot parse 0:0:03.127 with 'h\:m\:ss\.FF'.

Zurück zur Tabelle

Der benutzerdefinierte Formatbezeichner „FFF“

Der benutzerdefinierte FFF-Formatbezeichner (mit drei "F"-Zeichen) gibt die Millisekunden in einem Zeitintervall aus. In einem Formatierungsvorgang werden alle verbleibenden Bruchziffern abgeschnitten. Wenn nachgestellte Bruchzahlen vorhanden sind, sind sie nicht in der Ergebniszeichenfolge enthalten. In einem Analysevorgang, der die TimeSpan.ParseExact- oder TimeSpan.TryParseExact-Methode aufruft, ist das Vorhandensein der Zehntel, Hundertstel und Tausendstel einer zweiten Ziffer optional.

Im folgenden Beispiel wird der benutzerdefinierte FFF-Formatbezeichner verwendet, um die Tausendstel einer Sekunde in einem TimeSpan Wert anzuzeigen. Außerdem wird dieser benutzerdefinierte Formatbezeichner in einem Analysevorgang verwendet.

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

TimeSpan ts2 = TimeSpan.Parse("0:0:3.8009");
Console.WriteLine($"{ts2} ('ss\\.FFF') --> {ts2:ss\\.FFF}");
Console.WriteLine();

Console.WriteLine("Parsing:");
string[] inputs = { "0:0:03.", "0:0:03.12", "0:0:03.1279" };
string fmt = @"h\:m\:ss\.FFF";
TimeSpan ts3;

foreach (string input in inputs) {
   if (TimeSpan.TryParseExact(input, fmt, null, out ts3))
      Console.WriteLine($"{input} ('{fmt}') --> {ts3}");
   else
      Console.WriteLine($"Cannot parse {input} with '{fmt}'.");
}
// The example displays the following output:
//       Formatting:
//       00:00:03.6974000 ('FFF') --> 697
//       00:00:03.8009000 ('ss\.FFF') --> 03.8
//
//       Parsing:
//       0:0:03. ('h\:m\:ss\.FFF') --> 00:00:03
//       0:0:03.12 ('h\:m\:ss\.FFF') --> 00:00:03.1200000
//       Cannot parse 0:0:03.1279 with 'h\:m\:ss\.FFF'.

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

Dim ts2 As TimeSpan = TimeSpan.Parse("0:0:3.8009")
Console.WriteLine("{0} ('ss\.FFF') --> {0:ss\.FFF}", ts2)
Console.WriteLine()

Console.WriteLine("Parsing:")
Dim inputs() As String = {"0:0:03.", "0:0:03.12", "0:0:03.1279"}
Dim fmt As String = "h\:m\:ss\.FFF"
Dim ts3 As TimeSpan

For Each input As String In inputs
    If TimeSpan.TryParseExact(input, fmt, Nothing, ts3)
        Console.WriteLine("{0} ('{1}') --> {2}", input, fmt, ts3)
    Else
        Console.WriteLine("Cannot parse {0} with '{1}'.",
                          input, fmt)
    End If
Next
' The example displays the following output:
'       Formatting:
'       00:00:03.6974000 ('FFF') --> 697
'       00:00:03.8009000 ('ss\.FFF') --> 03.8
'       
'       Parsing:
'       0:0:03. ('h\:m\:ss\.FFF') --> 00:00:03
'       0:0:03.12 ('h\:m\:ss\.FFF') --> 00:00:03.1200000
'       Cannot parse 0:0:03.1279 with 'h\:m\:ss\.FFF'.

Zurück zur Tabelle

Der benutzerdefinierte Formatbezeichner „FFFF“

Der benutzerdefinierte Formatbezeichner "FFFF" (mit vier "F"-Zeichen) gibt die Zehntausendstel einer Sekunde in einem Zeitintervall aus. In einem Formatierungsvorgang werden alle verbleibenden Bruchziffern abgeschnitten. Wenn nachgestellte Bruchzahlen vorhanden sind, sind sie nicht in der Ergebniszeichenfolge enthalten. In einem Analysevorgang, der die TimeSpan.ParseExact- oder TimeSpan.TryParseExact-Methode aufruft, ist das Vorhandensein der Zehntel, Hundertstel, Tausendstel und zehntausendstel einer zweiten Ziffer optional.

Im folgenden Beispiel wird der benutzerdefinierte Formatbezeichner "FFFF" verwendet, um die Zehntausendstel einer Sekunde in einem TimeSpan-Wert anzuzeigen. Außerdem wird der benutzerdefinierte FfFF-Formatbezeichner in einem Analysevorgang verwendet.

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

TimeSpan ts2 = TimeSpan.Parse("0:0:3.80009");
Console.WriteLine($"{ts2} ('ss\\.FFFF') --> {ts2:ss\\.FFFF}");
Console.WriteLine();

Console.WriteLine("Parsing:");
string[] inputs = { "0:0:03.", "0:0:03.12", "0:0:03.12795" };
string fmt = @"h\:m\:ss\.FFFF";
TimeSpan ts3;

foreach (string input in inputs) {
   if (TimeSpan.TryParseExact(input, fmt, null, out ts3))
      Console.WriteLine($"{input} ('{fmt}') --> {ts3}");
   else
      Console.WriteLine($"Cannot parse {input} with '{fmt}'.");
}
// The example displays the following output:
//       Formatting:
//       00:00:03.6974900 ('FFFF') --> 6974
//       00:00:03.8000900 ('ss\.FFFF') --> 03.8
//
//       Parsing:
//       0:0:03. ('h\:m\:ss\.FFFF') --> 00:00:03
//       0:0:03.12 ('h\:m\:ss\.FFFF') --> 00:00:03.1200000
//       Cannot parse 0:0:03.12795 with 'h\:m\:ss\.FFFF'.

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

Dim ts2 As TimeSpan = TimeSpan.Parse("0:0:3.80009")
Console.WriteLine("{0} ('ss\.FFFF') --> {0:ss\.FFFF}", ts2)
Console.WriteLine()

Console.WriteLine("Parsing:")
Dim inputs() As String = {"0:0:03.", "0:0:03.12", "0:0:03.12795"}
Dim fmt As String = "h\:m\:ss\.FFFF"
Dim ts3 As TimeSpan

For Each input As String In inputs
    If TimeSpan.TryParseExact(input, fmt, Nothing, ts3)
        Console.WriteLine("{0} ('{1}') --> {2}", input, fmt, ts3)
    Else
        Console.WriteLine("Cannot parse {0} with '{1}'.",
                          input, fmt)
    End If
Next
' The example displays the following output:
'       Formatting:
'       00:00:03.6974900 ('FFFF') --> 6974
'       00:00:03.8000900 ('ss\.FFFF') --> 03.8
'       
'       Parsing:
'       0:0:03. ('h\:m\:ss\.FFFF') --> 00:00:03
'       0:0:03.12 ('h\:m\:ss\.FFFF') --> 00:00:03.1200000
'       Cannot parse 0:0:03.12795 with 'h\:m\:ss\.FFFF'.

Zurück zur Tabelle

Der benutzerdefinierte Formatbezeichner „FFFFF“

Der benutzerdefinierte FFFFF-Formatbezeichner (mit fünf "F"-Zeichen) gibt die Hunderttausendstel einer Sekunde in einem Zeitintervall aus. In einem Formatierungsvorgang werden alle verbleibenden Bruchziffern abgeschnitten. Wenn nachgestellte Bruchzahlen vorhanden sind, sind sie nicht in der Ergebniszeichenfolge enthalten. In einem Analysevorgang, der die TimeSpan.ParseExact- oder TimeSpan.TryParseExact-Methode aufruft, ist das Vorhandensein der Zehntel, Hundertstel, Tausendstel, Zehntausendstel und Hunderttausendstel einer zweiten Ziffer optional.

Im folgenden Beispiel wird der benutzerdefinierte FFFFF-Formatbezeichner verwendet, um die Hunderttausendstel einer Sekunde in einem TimeSpan Wert anzuzeigen. Außerdem wird der benutzerdefinierte FFFFF-Formatbezeichner in einem Analysevorgang verwendet.

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

TimeSpan ts2 = TimeSpan.Parse("0:0:3.800009");
Console.WriteLine($"{ts2} ('ss\\.FFFFF') --> {ts2:ss\\.FFFFF}");
Console.WriteLine();

Console.WriteLine("Parsing:");
string[] inputs = { "0:0:03.", "0:0:03.12", "0:0:03.127956" };
string fmt = @"h\:m\:ss\.FFFFF";
TimeSpan ts3;

foreach (string input in inputs) {
   if (TimeSpan.TryParseExact(input, fmt, null, out ts3))
      Console.WriteLine($"{input} ('{fmt}') --> {ts3}");
   else
      Console.WriteLine($"Cannot parse {input} with '{fmt}'.");
}
// The example displays the following output:
//       Formatting:
//       00:00:03.6974970 ('FFFFF') --> 69749
//       00:00:03.8000090 ('ss\.FFFFF') --> 03.8
//
//       Parsing:
//       0:0:03. ('h\:m\:ss\.FFFF') --> 00:00:03
//       0:0:03.12 ('h\:m\:ss\.FFFF') --> 00:00:03.1200000
//       Cannot parse 0:0:03.127956 with 'h\:m\:ss\.FFFF'.

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

Dim ts2 As TimeSpan = TimeSpan.Parse("0:0:3.800009")
Console.WriteLine("{0} ('ss\.FFFFF') --> {0:ss\.FFFFF}", ts2)
Console.WriteLine()

Console.WriteLine("Parsing:")
Dim inputs() As String = {"0:0:03.", "0:0:03.12", "0:0:03.127956"}
Dim fmt As String = "h\:m\:ss\.FFFFF"
Dim ts3 As TimeSpan

For Each input As String In inputs
    If TimeSpan.TryParseExact(input, fmt, Nothing, ts3)
        Console.WriteLine("{0} ('{1}') --> {2}", input, fmt, ts3)
    Else
        Console.WriteLine("Cannot parse {0} with '{1}'.",
                          input, fmt)
    End If
Next
' The example displays the following output:
'       Formatting:
'       00:00:03.6974970 ('FFFFF') --> 69749
'       00:00:03.8000090 ('ss\.FFFFF') --> 03.8
'       
'       Parsing:
'       0:0:03. ('h\:m\:ss\.FFFF') --> 00:00:03
'       0:0:03.12 ('h\:m\:ss\.FFFF') --> 00:00:03.1200000
'       Cannot parse 0:0:03.127956 with 'h\:m\:ss\.FFFF'.

Zurück zur Tabelle

Der benutzerdefinierte Formatbezeichner „FFFFFF“

Der benutzerdefinierte Formatbezeichner "FFFFFF" (mit sechs "F"-Zeichen) gibt die Millionstel einer Sekunde in einem Zeitintervall aus. In einem Formatierungsvorgang werden alle verbleibenden Bruchziffern abgeschnitten. Wenn nachgestellte Bruchzahlen vorhanden sind, sind sie nicht in der Ergebniszeichenfolge enthalten. In einem Analysevorgang, der die TimeSpan.ParseExact- oder TimeSpan.TryParseExact-Methode aufruft, ist das Vorhandensein der Zehntel, Hundertstel, Tausendstel, Zehntausendstel, Hunderttausendstel und Millionstel einer zweiten Ziffer optional.

Im folgenden Beispiel wird der benutzerdefinierte Formatbezeichner "FFFFFF" verwendet, um die Millionstel einer Sekunde in einem TimeSpan Wert anzuzeigen. Außerdem wird dieser benutzerdefinierte Formatbezeichner in einem Analysevorgang verwendet.

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

TimeSpan ts2 = TimeSpan.Parse("0:0:3.8000009");
Console.WriteLine($"{ts2} ('ss\\.FFFFFF') --> {ts2:ss\\.FFFFFF}");
Console.WriteLine();

Console.WriteLine("Parsing:");
string[] inputs = { "0:0:03.", "0:0:03.12", "0:0:03.1279569" };
string fmt = @"h\:m\:ss\.FFFFFF";
TimeSpan ts3;

foreach (string input in inputs) {
   if (TimeSpan.TryParseExact(input, fmt, null, out ts3))
      Console.WriteLine($"{input} ('{fmt}') --> {ts3}");
   else
      Console.WriteLine($"Cannot parse {input} with '{fmt}'.");
}
// The example displays the following output:
//       Formatting:
//       00:00:03.6974974 ('FFFFFF') --> 697497
//       00:00:03.8000009 ('ss\.FFFFFF') --> 03.8
//
//       Parsing:
//       0:0:03. ('h\:m\:ss\.FFFFFF') --> 00:00:03
//       0:0:03.12 ('h\:m\:ss\.FFFFFF') --> 00:00:03.1200000
//       Cannot parse 0:0:03.1279569 with 'h\:m\:ss\.FFFFFF'.

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

Dim ts2 As TimeSpan = TimeSpan.Parse("0:0:3.8000009")
Console.WriteLine("{0} ('ss\.FFFFFF') --> {0:ss\.FFFFFF}", ts2)
Console.WriteLine()

Console.WriteLine("Parsing:")
Dim inputs() As String = {"0:0:03.", "0:0:03.12", "0:0:03.1279569"}
Dim fmt As String = "h\:m\:ss\.FFFFFF"
Dim ts3 As TimeSpan

For Each input As String In inputs
    If TimeSpan.TryParseExact(input, fmt, Nothing, ts3)
        Console.WriteLine("{0} ('{1}') --> {2}", input, fmt, ts3)
    Else
        Console.WriteLine("Cannot parse {0} with '{1}'.",
                          input, fmt)
    End If
Next
' The example displays the following output:
'       Formatting:
'       00:00:03.6974974 ('FFFFFF') --> 697497
'       00:00:03.8000009 ('ss\.FFFFFF') --> 03.8
'       
'       Parsing:
'       0:0:03. ('h\:m\:ss\.FFFFFF') --> 00:00:03
'       0:0:03.12 ('h\:m\:ss\.FFFFFF') --> 00:00:03.1200000
'       Cannot parse 0:0:03.1279569 with 'h\:m\:ss\.FFFFFF'.

Zurück zur Tabelle

Benutzerdefinierte Formatbezeichner „FFFFFFF“

Der benutzerdefinierte FFFFFFF-Formatbezeichner (mit sieben "F"-Zeichen) gibt die zehn Millionenstel einer Sekunde (oder die Bruchzahl der Teilstriche) in einem Zeitintervall aus. Wenn nachgestellte Bruchzahlen vorhanden sind, sind sie nicht in der Ergebniszeichenfolge enthalten. In einem Analysevorgang, der die TimeSpan.ParseExact- oder TimeSpan.TryParseExact-Methode aufruft, ist das Vorhandensein der sieben Bruchstellen in der Eingabezeichenfolge optional.

Im folgenden Beispiel wird der benutzerdefinierte FFFFFFF-Bezeichner verwendet, um die Bruchteile einer Sekunde in einem TimeSpan Wert anzuzeigen. Außerdem wird dieser benutzerdefinierte Formatbezeichner in einem Analysevorgang verwendet.

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

TimeSpan ts2 = TimeSpan.Parse("0:0:3.9500000");
Console.WriteLine($"{ts2} ('ss\\.FFFFFFF') --> {ts2:ss\\.FFFFFFF}");
Console.WriteLine();

Console.WriteLine("Parsing:");
string[] inputs = { "0:0:03.", "0:0:03.12", "0:0:03.1279569" };
string fmt = @"h\:m\:ss\.FFFFFFF";
TimeSpan ts3;

foreach (string input in inputs) {
   if (TimeSpan.TryParseExact(input, fmt, null, out ts3))
      Console.WriteLine($"{input} ('{fmt}') --> {ts3}");
   else
      Console.WriteLine($"Cannot parse {input} with '{fmt}'.");
}
// The example displays the following output:
//    Formatting:
//    00:00:03.6974974 ('FFFFFFF') --> 6974974
//    00:00:03.9500000 ('ss\.FFFFFFF') --> 03.95
//
//    Parsing:
//    0:0:03. ('h\:m\:ss\.FFFFFFF') --> 00:00:03
//    0:0:03.12 ('h\:m\:ss\.FFFFFFF') --> 00:00:03.1200000
//    0:0:03.1279569 ('h\:m\:ss\.FFFFFFF') --> 00:00:03.1279569

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

Dim ts2 As TimeSpan = TimeSpan.Parse("0:0:3.9500000")
Console.WriteLine("{0} ('ss\.FFFFFFF') --> {0:ss\.FFFFFFF}", ts2)
Console.WriteLine()

Console.WriteLine("Parsing:")
Dim inputs() As String = {"0:0:03.", "0:0:03.12", "0:0:03.1279569"}
Dim fmt As String = "h\:m\:ss\.FFFFFFF"
Dim ts3 As TimeSpan

For Each input As String In inputs
    If TimeSpan.TryParseExact(input, fmt, Nothing, ts3)
        Console.WriteLine("{0} ('{1}') --> {2}", input, fmt, ts3)
    Else
        Console.WriteLine("Cannot parse {0} with '{1}'.",
                          input, fmt)
    End If
Next
' The example displays the following output:
'    Formatting:
'    00:00:03.6974974 ('FFFFFFF') --> 6974974
'    00:00:03.9500000 ('ss\.FFFFFFF') --> 03.95
'    
'    Parsing:
'    0:0:03. ('h\:m\:ss\.FFFFFFF') --> 00:00:03
'    0:0:03.12 ('h\:m\:ss\.FFFFFFF') --> 00:00:03.1200000
'    0:0:03.1279569 ('h\:m\:ss\.FFFFFFF') --> 00:00:03.1279569

Zurück zur Tabelle

Andere Zeichen

Alle anderen nicht gescapeten Zeichen in einer Formatzeichenfolge, einschließlich eines Leerzeichens, werden als benutzerdefinierter Formatbezeichner interpretiert. In den meisten Fällen führt das Vorhandensein eines anderen unescaped-Zeichens zu einem FormatException.

Es gibt zwei Möglichkeiten, ein Literalzeichen in eine Formatzeichenfolge einzuschließen:

  • Schließen Sie sie in einfache Anführungszeichen ein (das Literalzeichenfolgentrennzeichen).

  • Stellen Sie ihm einen umgekehrten Schrägstrich ("\") voran, der als Escapezeichen interpretiert wird. Dies bedeutet, dass in C# die Formatzeichenfolge entweder @-zitiert sein muss, oder dem Literalzeichen muss ein zusätzlicher umgekehrter Schrägstrich vorangestellt werden.

    In einigen Fällen müssen Sie möglicherweise bedingte Logik verwenden, um ein Escapeliteral in eine Formatzeichenfolge einzuschließen. Im folgenden Beispiel wird eine bedingte Logik verwendet, um ein Zeichensymbol für negative Zeitintervalle einzuschließen.

    using System;

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

      Console.WriteLine(result.ToString(fmt));
      Console.WriteLine($"Interval: {result.ToString(fmt)}");
   }
}
// The example displays output like the following:
//       -5582.12:21
//       Interval: -5582.12:21

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

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

.NET definiert keine Grammatik für Trennzeichen in Zeitintervallen. Dies bedeutet, dass die Trennzeichen zwischen Tagen und Stunden, Stunden und Minuten, Minuten und Sekunden sowie Sekunden und Bruchzahlen einer Sekunde als Zeichenliterale in einer Formatzeichenfolge behandelt werden müssen.

Im folgenden Beispiel werden sowohl das Escapezeichen als auch das einfache Anführungszeichen verwendet, um eine benutzerdefinierte Formatzeichenfolge zu definieren, die das Wort "Minuten" in der Ausgabezeichenfolge enthält.

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

Zurück zur Tabelle

Siehe auch