Benutzerdefinierte TimeSpan-FormatzeichenfolgenCustom TimeSpan Format Strings

Eine TimeSpan-Formatzeichenfolge definiert die aus einem Formatierungsvorgang resultierende Zeichenfolgendarstellung eines TimeSpan-Werts.A TimeSpan format string defines the string representation of a TimeSpan value that results from a formatting operation. Eine benutzerdefinierte Formatzeichenfolge besteht aus einem oder mehreren benutzerdefinierten TimeSpan-Formatbezeichnern und einer beliebigen Anzahl von Literalzeichen.A custom format string consists of one or more custom TimeSpan format specifiers along with any number of literal characters. Alle Zeichenfolgen, bei denen es sich nicht um standardmäßige TimeSpan-Formatzeichenfolgen handelt, werden als benutzerdefinierte TimeSpan-Formatzeichenfolgen interpretiert.Any string that is not a standard TimeSpan format string is interpreted as a custom TimeSpan format string.

Wichtig

Die benutzerdefinierten TimeSpan-Formatbezeichner enthalten keine Platzhalter für Trennzeichensymbole, z. B. die Symbole, durch die Tage von Stunden, Stunden von Minuten oder Sekunden von Sekundenbruchteilen getrennt werden.The custom TimeSpan format specifiers do not include placeholder separator symbols, such as the symbols that separate days from hours, hours from minutes, or seconds from fractional seconds. Diese Symbole müssen stattdessen als Zeichenfolgenliterale in die benutzerdefinierte Formatzeichenfolge eingeschlossen werden.Instead, these symbols must be included in the custom format string as string literals. Beispielsweise definiert "dd\.hh\:mm" einen Punkt (.) als Trennzeichen zwischen Tagen und Stunden und einen Doppelpunkt (:) als Trennzeichen zwischen Stunden und Minuten.For example, "dd\.hh\:mm" defines a period (.) as the separator between days and hours, and a colon (:) as the separator between hours and minutes.

Benutzerdefinierte TimeSpan-Formatbezeichner enthalten auch kein Vorzeichensymbol, das Ihnen ermöglicht, zwischen den negativen und positiven Zeitabständen zu unterscheiden.Custom TimeSpan format specifiers also do not include a sign symbol that enables you to differentiate between negative and positive time intervals. Um ein Vorzeichensymbol hinzuzufügen, müssen Sie eine Formatzeichenfolge mit bedingter Logik erstellen.To include a sign symbol, you have to construct a format string by using conditional logic. Der Abschnitt Andere Zeichen bietet ein Beispiel.The Other Characters section includes an example.

Die Zeichenfolgendarstellungen von TimeSpan-Werten werden durch Aufrufe der Überladungen der TimeSpan.ToString-Methode und durch Methoden, die die kombinierte Formatierung unterstützen (z. B. String.Format), erzeugt.The string representations of TimeSpan values are produced by calls to the overloads of the TimeSpan.ToString method, and by methods that support composite formatting, such as String.Format. Weitere Informationen finden Sie unter Formatieren von Typen und Zusammengesetzte Formatierung.For more information, see Formatting Types and Composite Formatting. Das folgende Beispiel veranschaulicht die Verwendung von benutzerdefinierten Formatzeichenfolgen bei Formatierungsvorgängen.The following example illustrates the use of custom format strings in formatting operations.

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

Benutzerdefinierte TimeSpan-Formatzeichenfolgen werden auch von der TimeSpan.ParseExact-Methode und TimeSpan.TryParseExact-Methode verwendet, um das erforderliche Format von Eingabezeichenfolgen für Analysevorgänge zu definieren.Custom TimeSpan format strings are also used by the TimeSpan.ParseExact and TimeSpan.TryParseExact methods to define the required format of input strings for parsing operations. (Beim Analysieren wird die Zeichenfolgendarstellung eines Werts in diesen Wert konvertiert.) Das folgende Beispiel veranschaulicht die Verwendung von Standardformatzeichenfolgen bei Analysevorgängen.(Parsing converts the string representation of a value to that value.) The following example illustrates the use of standard format strings in parsing operations.

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

In der folgenden Tabelle werden die benutzerdefinierten Formatbezeichner für Datum und Uhrzeit beschrieben.The following table describes the custom date and time format specifiers.

FormatbezeichnerFormat specifier descriptionDescription BeispielExample
"d", "%d""d", "%d" Die Anzahl ganzer Tage im Zeitintervall.The number of whole days in the time interval.

Weitere Informationen finden Sie unter Der benutzerdefinierte Formatbezeichner "d".More information: The "d" Custom Format Specifier.
new TimeSpan(6, 14, 32, 17, 685):

%d --> "6"%d --> "6"

d\.hh\:mm --> "6.14:32"d\.hh\:mm --> "6.14:32"
"dd"-"dddddddd""dd"-"dddddddd" Die Anzahl ganzer Tage im Zeitintervall, bei Bedarf mit führenden Nullen aufgefüllt.The number of whole days in the time interval, padded with leading zeros as needed.

Weitere Informationen finden Sie unter Benutzerdefinierte Formatbezeichner „dd“ bis „dddddddd“.More information: The "dd"-"dddddddd" Custom Format Specifiers.
new TimeSpan(6, 14, 32, 17, 685):

ddd --> "006"ddd --> "006"

dd\.hh\:mm --> "06.14:32"dd\.hh\:mm --> "06.14:32"
"h", "%h""h", "%h" Die Anzahl ganzer Stunden im Zeitintervall, die nicht als Teil von Tagen gezählt werden.The number of whole hours in the time interval that are not counted as part of days. Einstellige Stundenangaben weisen keine führende 0 auf.Single-digit hours do not have a leading zero.

Weitere Informationen finden Sie unter Der benutzerdefinierte Formatbezeichner "h".More information: The "h" Custom Format Specifier.
new TimeSpan(6, 14, 32, 17, 685):

%h --> "14"%h --> "14"

hh\:mm --> "14:32"hh\:mm --> "14:32"
"hh""hh" Die Anzahl ganzer Stunden im Zeitintervall, die nicht als Teil von Tagen gezählt werden.The number of whole hours in the time interval that are not counted as part of days. Einstellige Stundenangaben weisen eine führende 0 auf.Single-digit hours have a leading zero.

Weitere Informationen finden Sie unter Der benutzerdefinierte Formatbezeichner "hh".More information: The "hh" Custom Format Specifier.
new TimeSpan(6, 14, 32, 17, 685):

hh --> "14"hh --> "14"

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

hh --> 08hh --> 08
"m", "%m""m", "%m" Die Anzahl ganzer Minuten im Zeitintervall, die nicht als Teil von Stunden oder Tagen gezählt werden.The number of whole minutes in the time interval that are not included as part of hours or days. Einstellige Minutenangaben weisen keine führende 0 auf.Single-digit minutes do not have a leading zero.

Weitere Informationen finden Sie unter Der benutzerdefinierte Formatbezeichner "m".More information: The "m" Custom Format Specifier.
new TimeSpan(6, 14, 8, 17, 685):

%m --> "8"%m --> "8"

h\:m --> "14:8"h\:m --> "14:8"
"mm""mm" Die Anzahl ganzer Minuten im Zeitintervall, die nicht als Teil von Stunden oder Tagen gezählt werden.The number of whole minutes in the time interval that are not included as part of hours or days. Einstellige Minutenangaben weisen eine führende 0 auf.Single-digit minutes have a leading zero.

Weitere Informationen finden Sie unter Der benutzerdefinierte Formatbezeichner "mm".More information: The "mm" Custom Format Specifier.
new TimeSpan(6, 14, 8, 17, 685):

mm --> "08"mm --> "08"

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

d\.hh\:mm\:ss --> 6.08:05:17d\.hh\:mm\:ss --> 6.08:05:17
"s", "%s""s", "%s" Die Anzahl ganzer Sekunden im Zeitintervall, die nicht als Teil von Stunden, Tagen oder Minuten gezählt werden.The number of whole seconds in the time interval that are not included as part of hours, days, or minutes. Einstellige Sekundenangaben weisen keine führende 0 auf.Single-digit seconds do not have a leading zero.

Weitere Informationen finden Sie unter Der benutzerdefinierte Formatbezeichner "s".More information: The "s" Custom Format Specifier.
TimeSpan.FromSeconds(12.965):TimeSpan.FromSeconds(12.965):

%s --> 12%s --> 12

s\.fff --> 12.965s\.fff --> 12.965
"ss""ss" Die Anzahl ganzer Sekunden im Zeitintervall, die nicht als Teil von Stunden, Tagen oder Minuten gezählt werden.The number of whole seconds in the time interval that are not included as part of hours, days, or minutes. Einstellige Sekundenangaben weisen eine führende 0 auf.Single-digit seconds have a leading zero.

Weitere Informationen finden Sie unter Der benutzerdefinierte Formatbezeichner "ss".More information: The "ss" Custom Format Specifier.
TimeSpan.FromSeconds(6.965):TimeSpan.FromSeconds(6.965):

ss --> 06ss --> 06

ss\.fff --> 06.965ss\.fff --> 06.965
"f", "%f""f", "%f" Die Zehntelsekunden in einem Zeitintervall.The tenths of a second in a time interval.

Weitere Informationen finden Sie unter Der benutzerdefinierte Formatbezeichner "f".More information: The "f" Custom Format Specifier.
TimeSpan.FromSeconds(6.895):TimeSpan.FromSeconds(6.895):

f --> 8f --> 8

ss\.f --> 06.8ss\.f --> 06.8
"ff""ff" Die Hundertstelsekunden in einem Zeitintervall.The hundredths of a second in a time interval.

Weitere Informationen finden Sie unter Der benutzerdefinierte Formatbezeichner „ff“.More information:The "ff" Custom Format Specifier.
TimeSpan.FromSeconds(6.895):TimeSpan.FromSeconds(6.895):

ff --> 89ff --> 89

ss\.ff --> 06.89ss\.ff --> 06.89
"fff""fff" Die Millisekunden in einem Zeitintervall.The milliseconds in a time interval.

Weitere Informationen finden Sie unter Der benutzerdefinierte Formatbezeichner "fff".More information: The "fff" Custom Format Specifier.
TimeSpan.FromSeconds(6.895):TimeSpan.FromSeconds(6.895):

fff --> 895fff --> 895

ss\.fff --> 06.895ss\.fff --> 06.895
"ffff""ffff" Die Zehntausendstelsekunden in einem Zeitintervall.The ten-thousandths of a second in a time interval.

Weitere Informationen finden Sie unter Der benutzerdefinierte Formatbezeichner "ffff".More information: The "ffff" Custom Format Specifier.
TimeSpan.Parse("0:0:6.8954321"):TimeSpan.Parse("0:0:6.8954321"):

ffff --> 8954ffff --> 8954

ss\.ffff --> 06.8954ss\.ffff --> 06.8954
"fffff""fffff" Die Hunderttausendstelsekunden in einem Zeitintervall.The hundred-thousandths of a second in a time interval.

Weitere Informationen finden Sie unter Der benutzerdefinierte Formatbezeichner "fffff".More information: The "fffff" Custom Format Specifier.
TimeSpan.Parse("0:0:6.8954321"):TimeSpan.Parse("0:0:6.8954321"):

fffff --> 89543fffff --> 89543

ss\.fffff --> 06.89543ss\.fffff --> 06.89543
"ffffff""ffffff" Die Millionstelsekunden in einem Zeitintervall.The millionths of a second in a time interval.

Weitere Informationen finden Sie unter Der benutzerdefinierte Formatbezeichner "ffffff".More information: The "ffffff" Custom Format Specifier.
TimeSpan.Parse("0:0:6.8954321"):TimeSpan.Parse("0:0:6.8954321"):

ffffff --> 895432ffffff --> 895432

ss\.ffffff --> 06.895432ss\.ffffff --> 06.895432
"fffffff""fffffff" Die Zehnmillionstelsekunden (oder Sekundenbruchteile) in einem Zeitintervall.The ten-millionths of a second (or the fractional ticks) in a time interval.

Weitere Informationen finden Sie unter Der benutzerdefinierte Formatbezeichner "fffffff".More information: The "fffffff" Custom Format Specifier.
TimeSpan.Parse("0:0:6.8954321"):TimeSpan.Parse("0:0:6.8954321"):

fffffff --> 8954321fffffff --> 8954321

ss\.fffffff --> 06.8954321ss\.fffffff --> 06.8954321
"F", "%F""F", "%F" Die Zehntelsekunden in einem Zeitintervall.The tenths of a second in a time interval. Es wird nichts angezeigt, wenn die Ziffer 0 (null) ist.Nothing is displayed if the digit is zero.

Weitere Informationen finden Sie unter Der benutzerdefinierte Formatbezeichner "F".More information: The "F" Custom Format Specifier.
TimeSpan.Parse("00:00:06.32"):TimeSpan.Parse("00:00:06.32"):

%F: 3%F: 3

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

ss\.F: 03.ss\.F: 03.
"FF""FF" Die Hundertstelsekunden in einem Zeitintervall.The hundredths of a second in a time interval. Nachkommanullen oder zwei Nullstellen nach dem Komma werden nicht eingeschlossen.Any fractional trailing zeros or two zero digits are not included.

Weitere Informationen finden Sie unter Der benutzerdefinierte Formatbezeichner "FF".More information: The "FF" Custom Format Specifier.
TimeSpan.Parse("00:00:06.329"):TimeSpan.Parse("00:00:06.329"):

FF: 32FF: 32

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

ss\.FF: 03.1ss\.FF: 03.1
"FFF""FFF" Die Millisekunden in einem Zeitintervall.The milliseconds in a time interval. Nachkommanullen werden nicht eingeschlossen.Any fractional trailing zeros are not included.

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

FFF: 329FFF: 329

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

ss\.FFF: 03.1ss\.FFF: 03.1
"FFFF""FFFF" Die Zehntausendstelsekunden in einem Zeitintervall.The ten-thousandths of a second in a time interval. Nachkommanullen werden nicht eingeschlossen.Any fractional trailing zeros are not included.

Weitere Informationen finden Sie unter Der benutzerdefinierte Formatbezeichner "FFFF".More information: The "FFFF" Custom Format Specifier.
TimeSpan.Parse("00:00:06.32917"):TimeSpan.Parse("00:00:06.32917"):

FFFFF: 3291FFFFF: 3291

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

ss\.FFFF: 03.1ss\.FFFF: 03.1
"FFFFF""FFFFF" Die Hunderttausendstelsekunden in einem Zeitintervall.The hundred-thousandths of a second in a time interval. Nachkommanullen werden nicht eingeschlossen.Any fractional trailing zeros are not included.

Weitere Informationen finden Sie unter Der benutzerdefinierte Formatbezeichner "FFFFF".More information: The "FFFFF" Custom Format Specifier.
TimeSpan.Parse("00:00:06.329179"):TimeSpan.Parse("00:00:06.329179"):

FFFFF: 32917FFFFF: 32917

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

ss\.FFFFF: 03.1ss\.FFFFF: 03.1
"FFFFFF""FFFFFF" Die Millionstelsekunden in einem Zeitintervall.The millionths of a second in a time interval. Nachkommanullen werden nicht angezeigt.Any fractional trailing zeros are not displayed.

Weitere Informationen finden Sie unter Der benutzerdefinierte Formatbezeichner "FFFFFFF".More information: The "FFFFFF" Custom Format Specifier.
TimeSpan.Parse("00:00:06.3291791"):TimeSpan.Parse("00:00:06.3291791"):

FFFFFF: 329179FFFFFF: 329179

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

ss\.FFFFFF: 03.1ss\.FFFFFF: 03.1
"FFFFFFF""FFFFFFF" Die Zehnmillionstelsekunden in einem Zeitintervall.The ten-millions of a second in a time interval. Nachkommanullen oder sieben Nullstellen werden nicht angezeigt.Any fractional trailing zeros or seven zeros are not displayed.

Weitere Informationen finden Sie unter Der benutzerdefinierte Formatbezeichner "FFFFFFF".More information: The "FFFFFFF" Custom Format Specifier.
TimeSpan.Parse("00:00:06.3291791"):TimeSpan.Parse("00:00:06.3291791"):

FFFFFF: 3291791FFFFFF: 3291791

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

ss\.FFFFFF: 03.19ss\.FFFFFF: 03.19
„string“'string' Trennzeichen für Literalzeichenfolge.Literal string delimiter.

Weitere Informationen finden Sie unter Andere Zeichen.More information: Other Characters.
new TimeSpan(14, 32, 17):

hh':'mm':'ss --> "14:32:17"hh':'mm':'ss --> "14:32:17"
\|Das Escapezeichen\|The escape character.

Weitere Informationen finden Sie unter Andere Zeichen.More information:Other Characters.
new TimeSpan(14, 32, 17):

hh\:mm\:ss --> "14:32:17"hh\:mm\:ss --> "14:32:17"
Jedes andere ZeichenAny other character Alle anderen Zeichen ohne Escapezeichen werden als benutzerdefinierte Formatbezeichner interpretiert.Any other unescaped character is interpreted as a custom format specifier.

Weitere Informationen finden Sie unter Andere Zeichen.More Information: Other Characters.
new TimeSpan(14, 32, 17):

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

Der benutzerdefinierte Formatbezeichner "d"The "d" Custom Format Specifier

Der benutzerdefinierte Formatbezeichner "d" gibt den Wert der TimeSpan.Days-Eigenschaft aus, der die Anzahl ganzer Tage im Zeitintervall darstellt.The "d" custom format specifier outputs the value of the TimeSpan.Days property, which represents the number of whole days in the time interval. Er gibt auch dann die volle Anzahl von Tagen in einem TimeSpan-Wert aus, wenn der Wert aus mehreren Ziffern besteht.It outputs the full number of days in a TimeSpan value, even if the value has more than one digit. Wenn der Wert der TimeSpan.Days-Eigenschaft 0 (null) ist, gibt der Bezeichner "0" aus.If the value of the TimeSpan.Days property is zero, the specifier outputs "0".

Wenn der benutzerdefinierte Formatbezeichner "d" allein verwendet wird, geben Sie "%d" an, damit er nicht fälschlich als Standardformatzeichenfolge interpretiert wird.If the "d" custom format specifier is used alone, specify "%d" so that it is not misinterpreted as a standard format string. Dies wird im folgenden Beispiel veranschaulicht.The following example provides an illustration.

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".The following example illustrates the use of the "d" custom format specifier.

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 TabelleBack to table

Benutzerdefinierte Formatbezeichner "dd" bis "dddddddd"The "dd"-"dddddddd" Custom Format Specifiers

Die benutzerdefinierten Formatbezeichner "dd", "ddd", "dddd", "ddddd", "dddddd", "ddddddd" und "dddddddd" geben den Wert der TimeSpan.Days-Eigenschaft aus, der die Anzahl ganzer Tage im Zeitintervall darstellt.The "dd", "ddd", "dddd", "ddddd", "dddddd", "ddddddd", and "dddddddd" custom format specifiers output the value of the TimeSpan.Days property, which represents the number of whole days in the time interval.

Die Ausgabezeichenfolge enthält eine Mindestanzahl von Ziffern, die durch die Anzahl der "d"-Zeichen im Formatbezeichner angegeben wird, und wird bei Bedarf mit führenden Nullen aufgefüllt.The output string includes a minimum number of digits specified by the number of "d" characters in the format specifier, and it is padded with leading zeros as needed. Wenn die Ziffern in der Anzahl von Tagen die Anzahl der "d"-Zeichen im Formatbezeichner überschreiten, wird die volle Anzahl von Tagen in der Ergebniszeichenfolge ausgegeben.If the digits in the number of days exceed the number of "d" characters in the format specifier, the full number of days is output in the result string.

Im folgenden Beispiel werden diese Formatbezeichner verwendet, um die Zeichenfolgendarstellung von zwei TimeSpan-Werten anzuzeigen.The following example uses these format specifiers to display the string representation of two TimeSpan values. Der Wert der Tageskomponente des ersten Zeitintervalls ist 0 (null), der Wert der Tageskomponente des zweiten Zeitintervalls 365.The value of the days component of the first time interval is zero; the value of the days component of the second is 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      

Zurück zur TabelleBack to table

Der benutzerdefinierte Formatbezeichner "h"The "h" Custom Format Specifier

Der benutzerdefinierte Formatbezeichner "h" gibt den Wert der TimeSpan.Hours-Eigenschaft aus, der die Anzahl ganzer Stunden im Zeitintervall darstellt, die nicht als Teil der Tageskomponente gezählt werden.The "h" custom format specifier outputs the value of the TimeSpan.Hours property, which represents the number of whole hours in the time interval that is not counted as part of its day component. Er gibt einen einstelligen Zeichenfolgenwert zurück, wenn der Wert der TimeSpan.Hours-Eigenschaft zwischen 0 und 9 liegt, und einen zweistelligen Zeichenfolgenwert, wenn der Wert der TimeSpan.Hours-Eigenschaft zwischen 10 und 23 liegt.It returns a one-digit string value if the value of the TimeSpan.Hours property is 0 through 9, and it returns a two-digit string value if the value of the TimeSpan.Hours property ranges from 10 to 23.

Wenn der benutzerdefinierte Formatbezeichner "h" allein verwendet wird, geben Sie "%h" an, damit er nicht fälschlich als Standardformatzeichenfolge interpretiert wird.If the "h" custom format specifier is used alone, specify "%h" so that it is not misinterpreted as a standard format string. Dies wird im folgenden Beispiel veranschaulicht.The following example provides an illustration.

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

Normalerweise wird eine Eingabezeichenfolge, die nur eine Zahl enthält, bei einem Analysevorgang als Anzahl von Tagen interpretiert.Ordinarily, in a parsing operation, an input string that includes only a single number is interpreted as the number of days. Sie können stattdessen den benutzerdefinierten Formatbezeichner "%h" verwenden, wenn die numerische Zeichenfolge als Anzahl von Stunden interpretiert werden soll.You can use the "%h" custom format specifier instead to interpret the numeric string as the number of hours. Dies wird im folgenden Beispiel veranschaulicht.The following example provides an illustration.

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                              

Das folgende Beispiel veranschaulicht die Verwendung des benutzerdefinierten Formatbezeichners "h".The following example illustrates the use of the "h" custom format specifier.

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 TabelleBack to table

Der benutzerdefinierte Formatbezeichner "hh"The "hh" Custom Format Specifier

Der benutzerdefinierte Formatbezeichner "hh" gibt den Wert der TimeSpan.Hours-Eigenschaft aus, der die Anzahl ganzer Stunden im Zeitintervall darstellt, die nicht als Teil der Tageskomponente gezählt werden.The "hh" custom format specifier outputs the value of the TimeSpan.Hours property, which represents the number of whole hours in the time interval that is not counted as part of its day component. Für Werte zwischen 0 und 9 enthält die Ausgabezeichenfolge eine führende Null.For values from 0 through 9, the output string includes a leading zero.

Normalerweise wird eine Eingabezeichenfolge, die nur eine Zahl enthält, bei einem Analysevorgang als Anzahl von Tagen interpretiert.Ordinarily, in a parsing operation, an input string that includes only a single number is interpreted as the number of days. Sie können stattdessen den benutzerdefinierten Formatbezeichner "hh" verwenden, wenn die numerische Zeichenfolge als Anzahl von Stunden interpretiert werden soll.You can use the "hh" custom format specifier instead to interpret the numeric string as the number of hours. Dies wird im folgenden Beispiel veranschaulicht.The following example provides an illustration.

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                              

Das folgende Beispiel veranschaulicht die Verwendung des benutzerdefinierten Formatbezeichners "hh".The following example illustrates the use of the "hh" custom format specifier.

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 TabelleBack to table

Der benutzerdefinierte Formatbezeichner "m"The "m" Custom Format Specifier

Der benutzerdefinierte Formatbezeichner "m" gibt den Wert der TimeSpan.Minutes-Eigenschaft aus, der die Anzahl ganzer Minuten im Zeitintervall darstellt, die nicht als Teil der Tageskomponente gezählt werden.The "m" custom format specifier outputs the value of the TimeSpan.Minutes property, which represents the number of whole minutes in the time interval that is not counted as part of its day component. Er gibt einen einstelligen Zeichenfolgenwert zurück, wenn der Wert der TimeSpan.Minutes-Eigenschaft zwischen 0 und 9 liegt, und einen zweistelligen Zeichenfolgenwert, wenn der Wert der TimeSpan.Minutes-Eigenschaft zwischen 10 und 59 liegt.It returns a one-digit string value if the value of the TimeSpan.Minutes property is 0 through 9, and it returns a two-digit string value if the value of the TimeSpan.Minutes property ranges from 10 to 59.

Wenn der benutzerdefinierte Formatbezeichner "m" allein verwendet wird, geben Sie "%m" an, damit er nicht fälschlich als Standardformatzeichenfolge interpretiert wird.If the "m" custom format specifier is used alone, specify "%m" so that it is not misinterpreted as a standard format string. Dies wird im folgenden Beispiel veranschaulicht.The following example provides an illustration.

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

Normalerweise wird eine Eingabezeichenfolge, die nur eine Zahl enthält, bei einem Analysevorgang als Anzahl von Tagen interpretiert.Ordinarily, in a parsing operation, an input string that includes only a single number is interpreted as the number of days. Sie können stattdessen den benutzerdefinierten Formatbezeichner "%m" verwenden, wenn die numerische Zeichenfolge als Anzahl von Minuten interpretiert werden soll.You can use the "%m" custom format specifier instead to interpret the numeric string as the number of minutes. Dies wird im folgenden Beispiel veranschaulicht.The following example provides an illustration.

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                              

Das folgende Beispiel veranschaulicht die Verwendung des benutzerdefinierten Formatbezeichners "m".The following example illustrates the use of the "m" custom format specifier.

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

Zurück zur TabelleBack to table

Der benutzerdefinierte Formatbezeichner "mm"The "mm" Custom Format Specifier

Der benutzerdefinierte Formatbezeichner "mm" gibt den Wert der TimeSpan.Minutes-Eigenschaft aus, der die Anzahl ganzer Minuten im Zeitintervall darstellt, die nicht als Teil der Stunden- oder Tageskomponente gezählt werden.The "mm" custom format specifier outputs the value of the TimeSpan.Minutes property, which represents the number of whole minutes in the time interval that is not included as part of its hours or days component. Für Werte zwischen 0 und 9 enthält die Ausgabezeichenfolge eine führende Null.For values from 0 through 9, the output string includes a leading zero.

Normalerweise wird eine Eingabezeichenfolge, die nur eine Zahl enthält, bei einem Analysevorgang als Anzahl von Tagen interpretiert.Ordinarily, in a parsing operation, an input string that includes only a single number is interpreted as the number of days. Sie können stattdessen den benutzerdefinierten Formatbezeichner "mm" verwenden, wenn die numerische Zeichenfolge als Anzahl von Minuten interpretiert werden soll.You can use the "mm" custom format specifier instead to interpret the numeric string as the number of minutes. Dies wird im folgenden Beispiel veranschaulicht.The following example provides an illustration.

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           

Das folgende Beispiel veranschaulicht die Verwendung des benutzerdefinierten Formatbezeichners "mm".The following example illustrates the use of the "mm" custom format specifier.

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      

Zurück zur TabelleBack to table

Der benutzerdefinierte Formatbezeichner "s"The "s" Custom Format Specifier

Der benutzerdefinierte Formatbezeichner "s" gibt den Wert der TimeSpan.Seconds-Eigenschaft aus, der die Anzahl ganzer Sekunden im Zeitintervall darstellt, die nicht als Teil der Stunden-, Tages- oder Minutenkomponente gezählt werden.The "s" custom format specifier outputs the value of the TimeSpan.Seconds property, which represents the number of whole seconds in the time interval that is not included as part of its hours, days, or minutes component. Er gibt einen einstelligen Zeichenfolgenwert zurück, wenn der Wert der TimeSpan.Seconds-Eigenschaft zwischen 0 und 9 liegt, und einen zweistelligen Zeichenfolgenwert, wenn der Wert der TimeSpan.Seconds-Eigenschaft zwischen 10 und 59 liegt.It returns a one-digit string value if the value of the TimeSpan.Seconds property is 0 through 9, and it returns a two-digit string value if the value of the TimeSpan.Seconds property ranges from 10 to 59.

Wenn der benutzerdefinierte Formatbezeichner "s" allein verwendet wird, geben Sie "%s" an, damit er nicht fälschlich als Standardformatzeichenfolge interpretiert wird.If the "s" custom format specifier is used alone, specify "%s" so that it is not misinterpreted as a standard format string. Dies wird im folgenden Beispiel veranschaulicht.The following example provides an illustration.

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

Normalerweise wird eine Eingabezeichenfolge, die nur eine Zahl enthält, bei einem Analysevorgang als Anzahl von Tagen interpretiert.Ordinarily, in a parsing operation, an input string that includes only a single number is interpreted as the number of days. Sie können stattdessen den benutzerdefinierten Formatbezeichner "%s" verwenden, wenn die numerische Zeichenfolge als Anzahl von Sekunden interpretiert werden soll.You can use the "%s" custom format specifier instead to interpret the numeric string as the number of seconds. Dies wird im folgenden Beispiel veranschaulicht.The following example provides an illustration.

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

Das folgende Beispiel veranschaulicht die Verwendung des benutzerdefinierten Formatbezeichners "s".The following example illustrates the use of the "s" custom format specifier.

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 TabelleBack to table

Der benutzerdefinierte Formatbezeichner "ss"The "ss" Custom Format Specifier

Der benutzerdefinierte Formatbezeichner "ss" gibt den Wert der TimeSpan.Seconds-Eigenschaft aus, der die Anzahl ganzer Sekunden im Zeitintervall darstellt, die nicht als Teil der Stunden-, Tages- oder Minutenkomponente gezählt werden.The "ss" custom format specifier outputs the value of the TimeSpan.Seconds property, which represents the number of whole seconds in the time interval that is not included as part of its hours, days, or minutes component. Für Werte zwischen 0 und 9 enthält die Ausgabezeichenfolge eine führende Null.For values from 0 through 9, the output string includes a leading zero.

Normalerweise wird eine Eingabezeichenfolge, die nur eine Zahl enthält, bei einem Analysevorgang als Anzahl von Tagen interpretiert.Ordinarily, in a parsing operation, an input string that includes only a single number is interpreted as the number of days. Sie können stattdessen den benutzerdefinierten Formatbezeichner "ss" verwenden, wenn die numerische Zeichenfolge als Anzahl von Sekunden interpretiert werden soll.You can use the "ss" custom format specifier instead to interpret the numeric string as the number of seconds. Dies wird im folgenden Beispiel veranschaulicht.The following example provides an illustration.

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

Das folgende Beispiel veranschaulicht die Verwendung des benutzerdefinierten Formatbezeichners "ss".The following example illustrates the use of the "ss" custom format specifier.

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 TabelleBack to table

Benutzerdefinierter Formatbezeichner "f"The"f" Custom Format Specifier

Der benutzerdefinierte Formatbezeichner "f" gibt die Zehntelsekunden in einem Zeitintervall aus.The "f" custom format specifier outputs the tenths of a second in a time interval. Bei einem Formatierungsvorgang werden die restlichen Dezimalstellen abgeschnitten.In a formatting operation, any remaining fractional digits are truncated. Bei einem Analysevorgang, bei dem die TimeSpan.ParseExact- oder TimeSpan.TryParseExact-Methode aufgerufen wird, muss die Eingabezeichenfolge genau eine Dezimalstelle enthalten.In a parsing operation that calls the TimeSpan.ParseExact or TimeSpan.TryParseExact method, the input string must contain exactly one fractional digit.

Wenn der benutzerdefinierte Formatbezeichner "f" allein verwendet wird, geben Sie "%f" an, damit er nicht fälschlich als Standardformatzeichenfolge interpretiert wird.If the "f" custom format specifier is used alone, specify "%f" so that it is not misinterpreted as a standard format string.

Im folgenden Beispiel wird der benutzerdefinierte Formatbezeichner "f" verwendet, um die Zehntelsekunden in einem TimeSpan-Wert anzuzeigen.The following example uses the "f" custom format specifier to display the tenths of a second in a TimeSpan value. „f“ wird zuerst als einziger Formatbezeichner verwendet und dann in einer benutzerdefinierten Formatzeichenfolge mit dem Bezeichner „s“ kombiniert."f" is used first as the only format specifier, and then combined with the "s" specifier in a custom format string.

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

Zurück zur TabelleBack to table

Der benutzerdefinierte Formatbezeichner "ff"The "ff" Custom Format Specifier

Der benutzerdefinierte Formatbezeichner "ff" gibt die Hundertstelsekunden in einem Zeitintervall aus.The "ff" custom format specifier outputs the hundredths of a second in a time interval. Bei einem Formatierungsvorgang werden die restlichen Dezimalstellen abgeschnitten.In a formatting operation, any remaining fractional digits are truncated. Bei einem Analysevorgang, bei dem die TimeSpan.ParseExact- oder TimeSpan.TryParseExact-Methode aufgerufen wird, muss die Eingabezeichenfolge genau zwei Dezimalstellen enthalten.In a parsing operation that calls the TimeSpan.ParseExact or TimeSpan.TryParseExact method, the input string must contain exactly two fractional digits.

Im folgenden Beispiel wird der benutzerdefinierte Formatbezeichner "ff" verwendet, um die Hundertstelsekunden in einem TimeSpan-Wert anzuzeigen.The following example uses the "ff" custom format specifier to display the hundredths of a second in a TimeSpan value. „ff“ wird zuerst als einziger Formatbezeichner verwendet und dann in einer benutzerdefinierten Formatzeichenfolge mit dem Bezeichner „s“ kombiniert."ff" is used first as the only format specifier, and then combined with the "s" specifier in a custom format string.

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

Zurück zur TabelleBack to table

Der benutzerdefinierte Formatbezeichner "fff"The "fff" Custom Format Specifier

Der benutzerdefinierte Formatbezeichner "fff" (mit drei "f"-Zeichen) gibt die Millisekunden in einem Zeitintervall aus.The "fff" custom format specifier (with three "f" characters) outputs the milliseconds in a time interval. Bei einem Formatierungsvorgang werden die restlichen Dezimalstellen abgeschnitten.In a formatting operation, any remaining fractional digits are truncated. Bei einem Analysevorgang, bei dem die TimeSpan.ParseExact- oder TimeSpan.TryParseExact-Methode aufgerufen wird, muss die Eingabezeichenfolge genau drei Dezimalstellen enthalten.In a parsing operation that calls the TimeSpan.ParseExact or TimeSpan.TryParseExact method, the input string must contain exactly three fractional digits.

Im folgenden Beispiel wird der benutzerdefinierte Formatbezeichner "fff" verwendet, um die Millisekunden in einem TimeSpan-Wert anzuzeigen.The following example uses the "fff" custom format specifier to display the milliseconds in a TimeSpan value. „fff“ wird zuerst als einziger Formatbezeichner verwendet und dann in einer benutzerdefinierten Formatzeichenfolge mit dem Bezeichner „s“ kombiniert."fff" is used first as the only format specifier, and then combined with the "s" specifier in a custom format string.

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

Zurück zur TabelleBack to table

Der benutzerdefinierte Formatbezeichner "ffff"The "ffff" Custom Format Specifier

Der benutzerdefinierte Formatbezeichner "ffff" (mit vier "f"-Zeichen) gibt die Zehntausendstelsekunden in einem Zeitintervall aus.The "ffff" custom format specifier (with four "f" characters) outputs the ten-thousandths of a second in a time interval. Bei einem Formatierungsvorgang werden die restlichen Dezimalstellen abgeschnitten.In a formatting operation, any remaining fractional digits are truncated. Bei einem Analysevorgang, bei dem die TimeSpan.ParseExact- oder TimeSpan.TryParseExact-Methode aufgerufen wird, muss die Eingabezeichenfolge genau vier Dezimalstellen enthalten.In a parsing operation that calls the TimeSpan.ParseExact or TimeSpan.TryParseExact method, the input string must contain exactly four fractional digits.

Im folgenden Beispiel wird der benutzerdefinierte Formatbezeichner "ffff" verwendet, um die Zehntausendstelsekunden in einem TimeSpan-Wert anzuzeigen.The following example uses the "ffff" custom format specifier to display the ten-thousandths of a second in a TimeSpan value. „ffff“ wird zuerst als einziger Formatbezeichner verwendet und dann in einer benutzerdefinierten Formatzeichenfolge mit dem Bezeichner „s“ kombiniert."ffff" is used first as the only format specifier, and then combined with the "s" specifier in a custom format string.

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

Zurück zur TabelleBack to table

Der benutzerdefinierte Formatbezeichner "fffff"The "fffff" Custom Format Specifier

Der benutzerdefinierte Formatbezeichner "fffff" (mit fünf "f"-Zeichen) gibt die Hunderttausendstelsekunden in einem Zeitintervall aus.The "fffff" custom format specifier (with five "f" characters) outputs the hundred-thousandths of a second in a time interval. Bei einem Formatierungsvorgang werden die restlichen Dezimalstellen abgeschnitten.In a formatting operation, any remaining fractional digits are truncated. Bei einem Analysevorgang, bei dem die TimeSpan.ParseExact- oder TimeSpan.TryParseExact-Methode aufgerufen wird, muss die Eingabezeichenfolge genau fünf Dezimalstellen enthalten.In a parsing operation that calls the TimeSpan.ParseExact or TimeSpan.TryParseExact method, the input string must contain exactly five fractional digits.

Im folgenden Beispiel wird der benutzerdefinierte Formatbezeichner "ffff" verwendet, um die Hunderttausendstelsekunden in einem TimeSpan-Wert anzuzeigen.The following example uses the "fffff" custom format specifier to display the hundred-thousandths of a second in a TimeSpan value. „fffff“ wird zuerst als einziger Formatbezeichner verwendet und dann in einer benutzerdefinierten Formatzeichenfolge mit dem Bezeichner „s“ kombiniert."fffff" is used first as the only format specifier, and then combined with the "s" specifier in a custom format string.

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

Zurück zur TabelleBack to table

Der benutzerdefinierte Formatbezeichner "ffffff"The "ffffff" Custom Format Specifier

Der benutzerdefinierte Formatbezeichner "ffffff" (mit sechs "f"-Zeichen) gibt die Millionstelsekunden in einem Zeitintervall aus.The "ffffff" custom format specifier (with six "f" characters) outputs the millionths of a second in a time interval. Bei einem Formatierungsvorgang werden die restlichen Dezimalstellen abgeschnitten.In a formatting operation, any remaining fractional digits are truncated. Bei einem Analysevorgang, bei dem die TimeSpan.ParseExact- oder TimeSpan.TryParseExact-Methode aufgerufen wird, muss die Eingabezeichenfolge genau sechs Dezimalstellen enthalten.In a parsing operation that calls the TimeSpan.ParseExact or TimeSpan.TryParseExact method, the input string must contain exactly six fractional digits.

Im folgenden Beispiel wird der benutzerdefinierte Formatbezeichner "ffffff" verwendet, um die Millionstelsekunden in einem TimeSpan-Wert anzuzeigen.The following example uses the "ffffff" custom format specifier to display the millionths of a second in a TimeSpan value. Er wird zuerst als einziger Formatbezeichner verwendet und dann in einer benutzerdefinierten Formatzeichenfolge mit dem Bezeichner "s" kombiniert.It is used first as the only format specifier, and then combined with the "s" specifier in a custom format string.

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

Zurück zur TabelleBack to table

Der benutzerdefinierte Formatbezeichner "fffffff"The "fffffff" Custom Format Specifier

Der benutzerdefinierte Formatbezeichner "fffffff" (mit sieben "f"-Zeichen) gibt die Zehnmillionstelsekunden (oder Sekundenbruchteile) in einem Zeitintervall aus.The "fffffff" custom format specifier (with seven "f" characters) outputs the ten-millionths of a second (or the fractional number of ticks) in a time interval. Bei einem Analysevorgang, bei dem die TimeSpan.ParseExact- oder TimeSpan.TryParseExact-Methode aufgerufen wird, muss die Eingabezeichenfolge genau sieben Dezimalstellen enthalten.In a parsing operation that calls the TimeSpan.ParseExact or TimeSpan.TryParseExact method, the input string must contain exactly seven fractional digits.

Im folgenden Beispiel wird der benutzerdefinierte Formatbezeichner "fffffff" verwendet, um die Sekundenbruchteile in einem TimeSpan-Wert anzuzeigen.The following example uses the "fffffff" custom format specifier to display the fractional number of ticks in a TimeSpan value. Er wird zuerst als einziger Formatbezeichner verwendet und dann in einer benutzerdefinierten Formatzeichenfolge mit dem Bezeichner "s" kombiniert.It is used first as the only format specifier, and then combined with the "s" specifier in a custom format string.

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

Zurück zur TabelleBack to table

Der benutzerdefinierte Formatbezeichner "F"The "F" Custom Format Specifier

Der benutzerdefinierte Formatbezeichner "F" gibt die Zehntelsekunden in einem Zeitintervall aus.The "F" custom format specifier outputs the tenths of a second in a time interval. Bei einem Formatierungsvorgang werden die restlichen Dezimalstellen abgeschnitten.In a formatting operation, any remaining fractional digits are truncated. Wenn der Wert der Zehntelsekunden des Zeitintervalls 0 (null) ist, wird er nicht in die Ergebniszeichenfolge eingeschlossen.If the value of the time interval's tenths of a second is zero, it is not included in the result string. Bei einem Analysevorgang, bei dem die TimeSpan.ParseExact- oder TimeSpan.TryParseExact-Methode aufgerufen wird, ist das Vorhandensein der Zehntelsekundenstelle optional.In a parsing operation that calls the TimeSpan.ParseExact or TimeSpan.TryParseExact method, the presence of the tenths of a second digit is optional.

Wenn der benutzerdefinierte Formatbezeichner "F" allein verwendet wird, geben Sie "%F" an, damit er nicht fälschlich als Standardformatzeichenfolge interpretiert wird.If the "F" custom format specifier is used alone, specify "%F" so that it is not misinterpreted as a standard format string.

Im folgenden Beispiel wird der benutzerdefinierte Formatbezeichner "F" verwendet, um die Zehntelsekunden in einem TimeSpan-Wert anzuzeigen.The following example uses the "F" custom format specifier to display the tenths of a second in a TimeSpan value. Dieser benutzerdefinierte Formatbezeichner wird auch für einen Analysevorgang verwendet.It also uses this custom format specifier in a parsing operation.

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

Zurück zur TabelleBack to table

Der benutzerdefinierte Formatbezeichner "FF"The "FF" Custom Format Specifier

Der benutzerdefinierte Formatbezeichner "FF" gibt die Hundertstelsekunden in einem Zeitintervall aus.The "FF" custom format specifier outputs the hundredths of a second in a time interval. Bei einem Formatierungsvorgang werden die restlichen Dezimalstellen abgeschnitten.In a formatting operation, any remaining fractional digits are truncated. Wenn Nachkommanullen vorhanden sind, werden sie nicht in die Ergebniszeichenfolge eingeschlossen.If there are any trailing fractional zeros, they are not included in the result string. Bei einem Analysevorgang, bei dem die TimeSpan.ParseExact- oder TimeSpan.TryParseExact-Methode aufgerufen wird, ist das Vorhandensein der Zehntel- und Hundertstelsekundenstelle optional.In a parsing operation that calls the TimeSpan.ParseExact or TimeSpan.TryParseExact method, the presence of the tenths and hundredths of a second digit is optional.

Im folgenden Beispiel wird der benutzerdefinierte Formatbezeichner "FF" verwendet, um die Hundertstelsekunden in einem TimeSpan-Wert anzuzeigen.The following example uses the "FF" custom format specifier to display the hundredths of a second in a TimeSpan value. Dieser benutzerdefinierte Formatbezeichner wird auch für einen Analysevorgang verwendet.It also uses this custom format specifier in a parsing operation.

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

Zurück zur TabelleBack to table

Der benutzerdefinierte Formatbezeichner "FFF"The "FFF" Custom Format Specifier

Der benutzerdefinierte Formatbezeichner "FFF" (mit drei "F"-Zeichen) gibt die Millisekunden in einem Zeitintervall aus.The "FFF" custom format specifier (with three "F" characters) outputs the milliseconds in a time interval. Bei einem Formatierungsvorgang werden die restlichen Dezimalstellen abgeschnitten.In a formatting operation, any remaining fractional digits are truncated. Wenn Nachkommanullen vorhanden sind, werden sie nicht in die Ergebniszeichenfolge eingeschlossen.If there are any trailing fractional zeros, they are not included in the result string. Bei einem Analysevorgang, bei dem die TimeSpan.ParseExact- oder TimeSpan.TryParseExact-Methode aufgerufen wird, ist das Vorhandensein der Zehntel-, Hundertstel- und Tausendstelsekundenstelle optional.In a parsing operation that calls the TimeSpan.ParseExact or TimeSpan.TryParseExact method, the presence of the tenths, hundredths, and thousandths of a second digit is optional.

Im folgenden Beispiel wird der benutzerdefinierte Formatbezeichner "FFF" verwendet, um die Tausendstelsekunden in einem TimeSpan-Wert anzuzeigen.The following example uses the "FFF" custom format specifier to display the thousandths of a second in a TimeSpan value. Dieser benutzerdefinierte Formatbezeichner wird auch für einen Analysevorgang verwendet.It also uses this custom format specifier in a parsing operation.

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

Zurück zur TabelleBack to table

Der benutzerdefinierte Formatbezeichner "FFFF"The "FFFF" Custom Format Specifier

Der benutzerdefinierte Formatbezeichner "FFFF" (mit vier "F"-Zeichen) gibt die Zehntausendstelsekunden in einem Zeitintervall aus.The "FFFF" custom format specifier (with four "F" characters) outputs the ten-thousandths of a second in a time interval. Bei einem Formatierungsvorgang werden die restlichen Dezimalstellen abgeschnitten.In a formatting operation, any remaining fractional digits are truncated. Wenn Nachkommanullen vorhanden sind, werden sie nicht in die Ergebniszeichenfolge eingeschlossen.If there are any trailing fractional zeros, they are not included in the result string. Bei einem Analysevorgang, bei dem die TimeSpan.ParseExact- oder TimeSpan.TryParseExact-Methode aufgerufen wird, ist das Vorhandensein der Zehntel-, Hundertstel-, Tausendstel- und Zehntausendstelsekundenstelle optional.In a parsing operation that calls the TimeSpan.ParseExact or TimeSpan.TryParseExact method, the presence of the tenths, hundredths, thousandths, and ten-thousandths of a second digit is optional.

Im folgenden Beispiel wird der benutzerdefinierte Formatbezeichner "FFFF" verwendet, um die Zehntausendstelsekunden in einem TimeSpan-Wert anzuzeigen.The following example uses the "FFFF" custom format specifier to display the ten-thousandths of a second in a TimeSpan value. Der benutzerdefinierte Formatbezeichner "FFFF" wird auch für einen Analysevorgang verwendet.It also uses the "FFFF" custom format specifier in a parsing operation.

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

Zurück zur TabelleBack to table

Der benutzerdefinierte Formatbezeichner "FFFFF"The "FFFFF" Custom Format Specifier

Der benutzerdefinierte Formatbezeichner "FFFFF" (mit fünf "F"-Zeichen) gibt die Hunderttausendstelsekunden in einem Zeitintervall aus.The "FFFFF" custom format specifier (with five "F" characters) outputs the hundred-thousandths of a second in a time interval. Bei einem Formatierungsvorgang werden die restlichen Dezimalstellen abgeschnitten.In a formatting operation, any remaining fractional digits are truncated. Wenn Nachkommanullen vorhanden sind, werden sie nicht in die Ergebniszeichenfolge eingeschlossen.If there are any trailing fractional zeros, they are not included in the result string. Bei einem Analysevorgang, bei dem die TimeSpan.ParseExact- oder TimeSpan.TryParseExact-Methode aufgerufen wird, ist das Vorhandensein der Zehntel-, Hundertstel-, Tausendstel-, Zehntausendstel- und Hunderttausendstelsekundenstelle optional.In a parsing operation that calls the TimeSpan.ParseExact or TimeSpan.TryParseExact method, the presence of the tenths, hundredths, thousandths, ten-thousandths, and hundred-thousandths of a second digit is optional.

Im folgenden Beispiel wird der benutzerdefinierte Formatbezeichner "FFFFF" verwendet, um die Hunderttausendstelsekunden in einem TimeSpan-Wert anzuzeigen.The following example uses the "FFFFF" custom format specifier to display the hundred-thousandths of a second in a TimeSpan value. Der benutzerdefinierte Formatbezeichner "FFFFF" wird auch für einen Analysevorgang verwendet.It also uses the "FFFFF" custom format specifier in a parsing operation.

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

Zurück zur TabelleBack to table

Der benutzerdefinierte Formatbezeichner "FFFFFF"The "FFFFFF" Custom Format Specifier

Der benutzerdefinierte Formatbezeichner "FFFFFF" (mit sechs "F"-Zeichen) gibt die Millionstelsekunden in einem Zeitintervall aus.The "FFFFFF" custom format specifier (with six "F" characters) outputs the millionths of a second in a time interval. Bei einem Formatierungsvorgang werden die restlichen Dezimalstellen abgeschnitten.In a formatting operation, any remaining fractional digits are truncated. Wenn Nachkommanullen vorhanden sind, werden sie nicht in die Ergebniszeichenfolge eingeschlossen.If there are any trailing fractional zeros, they are not included in the result string. Bei einem Analysevorgang, bei dem die TimeSpan.ParseExact- oder TimeSpan.TryParseExact-Methode aufgerufen wird, ist das Vorhandensein der Zehntel-, Hundertstel-, Tausendstel-, Zehntausendstel-, Hunderttausendstel- und Millionstelsekundenstelle optional.In a parsing operation that calls the TimeSpan.ParseExact or TimeSpan.TryParseExact method, the presence of the tenths, hundredths, thousandths, ten-thousandths, hundred-thousandths, and millionths of a second digit is optional.

Im folgenden Beispiel wird der benutzerdefinierte Formatbezeichner "FFFFFF" verwendet, um die Millionstelsekunden in einem TimeSpan-Wert anzuzeigen.The following example uses the "FFFFFF" custom format specifier to display the millionths of a second in a TimeSpan value. Dieser benutzerdefinierte Formatbezeichner wird auch für einen Analysevorgang verwendet.It also uses this custom format specifier in a parsing operation.

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

Zurück zur TabelleBack to table

Benutzerdefinierte Formatbezeichner "FFFFFFF"The "FFFFFFF" Custom Format Specifier

Der benutzerdefinierte Formatbezeichner "FFFFFFF" (mit sieben "F"-Zeichen) gibt die Zehnmillionstelsekunden (oder Sekundenbruchteile) in einem Zeitintervall aus.The "FFFFFFF" custom format specifier (with seven "F" characters) outputs the ten-millionths of a second (or the fractional number of ticks) in a time interval. Wenn Nachkommanullen vorhanden sind, werden sie nicht in die Ergebniszeichenfolge eingeschlossen.If there are any trailing fractional zeros, they are not included in the result string. Bei einem Analysevorgang, bei dem die TimeSpan.ParseExact- oder TimeSpan.TryParseExact-Methode aufgerufen wird, ist das Vorhandensein der sieben Dezimalstellen in der Eingabezeichenfolge optional.In a parsing operation that calls the TimeSpan.ParseExact or TimeSpan.TryParseExact method, the presence of the seven fractional digits in the input string is optional.

Im folgenden Beispiel wird der benutzerdefinierte Formatbezeichner "FFFFFFF" verwendet, um die Sekundenbruchteile in einem TimeSpan-Wert anzuzeigen.The following example uses the "FFFFFFF" custom format specifier to display the fractional parts of a second in a TimeSpan value. Dieser benutzerdefinierte Formatbezeichner wird auch für einen Analysevorgang verwendet.It also uses this custom format specifier in a parsing operation.

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     

Zurück zur TabelleBack to table

Andere ZeichenOther Characters

Alle anderen Zeichen ohne Escapezeichen in einer Formatzeichenfolge (einschließlich Leerzeichen) werden als benutzerdefinierte Formatbezeichner interpretiert.Any other unescaped character in a format string, including a white-space character, is interpreted as a custom format specifier. In den meisten Fällen führt das Vorhandensein eines anderen Zeichens ohne Escapezeichen zu einer FormatException.In most cases, the presence of any other unescaped character results in a FormatException.

Zum Einschließen von Literalzeichen in eine Formatzeichenfolge stehen zwei Methoden zur Verfügung:There are two ways to include a literal character in a format string:

  • Schließen Sie das Literalzeichen in einfache Anführungszeichen ein (Trennzeichen für Literalzeichenfolgen).Enclose it in single quotation marks (the literal string delimiter).

  • Stellen Sie dem Literalzeichen einen umgekehrten Schrägstrich („\“) voran, der als Escapezeichen interpretiert wird.Precede it with a backslash ("\"), which is interpreted as an escape character. In C# muss die Formatzeichenfolge folglich @-quoted entsprechen, oder dem Literalzeichen muss ein zusätzlicher umgekehrter Schrägstrich vorangestellt werden.This means that, in C#, the format string must either be @-quoted, or the literal character must be preceded by an additional backslash.

    In einigen Fällen müssen Sie möglicherweise bedingte Logik verwenden, um ein Literal mit Escapezeichen einer Formatzeichenfolge hinzuzufügen.In some cases, you may have to use conditional logic to include an escaped literal in a format string. Im folgenden Beispiel wird bedingte Logik verwendet, um ein Vorzeichensymbol für negative Zeitintervalle hinzuzufügen.The following example uses conditional logic to include a sign symbol for negative time intervals.

    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 definiert keine Grammatik für Trennzeichen in Zeitintervallen..NET does not define a grammar for separators in time intervals. Dies bedeutet, dass die Trennzeichen zwischen Tagen und Stunden, Stunden und Minuten, Minuten und Sekunden und Sekunden und Sekundenbruchteilen in einer Formatzeichenfolge als Zeichenliterale behandelt werden müssen.This means that the separators between days and hours, hours and minutes, minutes and seconds, and seconds and fractions of a second must all be treated as character literals in a format string.

Im folgenden Beispiel werden sowohl das Escapezeichen als auch einfache Anführungszeichen verwendet, um eine benutzerdefinierte Formatzeichenfolge mit dem Wort "Minuten" in der Ausgabezeichenfolge zu definieren.The following example uses both the escape character and the single quote to define a custom format string that includes the word "minutes" in the output string.

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 TabelleBack to table

Siehe auchSee Also

Formatierung von TypenFormatting Types
TimeSpan-StandardformatzeichenfolgenStandard TimeSpan Format Strings