Niestandardowe ciągi formatujące TimeSpanCustom TimeSpan format strings

TimeSpanCiąg formatu definiuje reprezentację ciągu TimeSpan wartości, która jest wynikiem operacji formatowania.A TimeSpan format string defines the string representation of a TimeSpan value that results from a formatting operation. Niestandardowy ciąg formatu składa się z co najmniej jednego TimeSpan specyfikatora formatu niestandardowego wraz z dowolną liczbą znaków literału.A custom format string consists of one or more custom TimeSpan format specifiers along with any number of literal characters. Dowolny ciąg, który nie jest standardowym ciągiem formatu TimeSpan , jest interpretowany jako TimeSpan ciąg formatu niestandardowego.Any string that isn't a Standard TimeSpan format string is interpreted as a custom TimeSpan format string.

Ważne

TimeSpanSpecyfikatory formatu niestandardowego nie zawierają symboli zastępczych separatorów, takich jak symbole oddzielające dni od godzin, godziny z minut lub sekund od ułamków sekund.The custom TimeSpan format specifiers don't include placeholder separator symbols, such as the symbols that separate days from hours, hours from minutes, or seconds from fractional seconds. Zamiast tego symbole te muszą być zawarte w ciągu formatu niestandardowego jako literały ciągu.Instead, these symbols must be included in the custom format string as string literals. Na przykład "dd\.hh\:mm" definiuje kropkę (.) jako separator między dniami a godzinami i dwukropek (:) jako separator między godzinami i minutach.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.

TimeSpanSpecyfikatory formatu niestandardowego nie zawierają również symbolu znaku, który umożliwia odróżnienie między ujemnymi i dodatnimi przedziałami czasowymi.Custom TimeSpan format specifiers also don't include a sign symbol that enables you to differentiate between negative and positive time intervals. Aby dołączyć symbol znaku, należy utworzyć ciąg formatu za pomocą logiki warunkowej.To include a sign symbol, you have to construct a format string by using conditional logic. Sekcja inne znaki zawiera przykład.The Other characters section includes an example.

Ciąg reprezentujący TimeSpan wartości są generowane przez wywołania przeciążenia TimeSpan.ToString metody i metody obsługujące formatowanie złożone, takie jak String.Format .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. Aby uzyskać więcej informacji, zobacz Typy formatowania i formatowanie złożone.For more information, see Formatting Types and Composite Formatting. Poniższy przykład ilustruje użycie niestandardowych ciągów formatu w operacjach formatowania.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

Niestandardowe TimeSpan ciągi formatujące są również używane przez TimeSpan.ParseExact TimeSpan.TryParseExact metody i do definiowania wymaganego formatu ciągów wejściowych na potrzeby analizowania operacji.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. (Analizowanie konwertuje ciąg reprezentujący wartość na tę wartość). Poniższy przykład ilustruje użycie standardowych ciągów formatu podczas analizowania operacji.(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

W poniższej tabeli opisano specyfikatory niestandardowego formatu daty i godziny.The following table describes the custom date and time format specifiers.

Specyfikator formatuFormat specifier OpisDescription PrzykładExample
"d", "% d""d", "%d" Liczba pełnych dni w przedziale czasu.The number of whole days in the time interval.

Więcej informacji: specyfikator formatu niestandardowego "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" Liczba pełnych dni w przedziale czasu, uzupełniona wiodącymi zerami, zgodnie z potrzebami.The number of whole days in the time interval, padded with leading zeros as needed.

Więcej informacji: specyfikatory formatu niestandardowego "DD"-"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" Liczba pełnych godzin w przedziale czasu, które nie są zliczane jako część dni.The number of whole hours in the time interval that aren't counted as part of days. Godziny z pojedynczą cyfrą nie mają zera wiodącego.Single-digit hours don't have a leading zero.

Więcej informacji: specyfikator formatu niestandardowego "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" Liczba pełnych godzin w przedziale czasu, które nie są zliczane jako część dni.The number of whole hours in the time interval that aren't counted as part of days. Godziny z jedną cyfrą mają zero wiodące.Single-digit hours have a leading zero.

Więcej informacji: specyfikator formatu niestandardowego "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" Liczba pełnych minut w przedziale czasu, które nie są uwzględnione w godzinach lub dniach.The number of whole minutes in the time interval that aren't included as part of hours or days. Minuty z pojedynczą cyfrą nie mają zera wiodącego.Single-digit minutes don't have a leading zero.

Więcej informacji: specyfikator formatu niestandardowego "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" Liczba pełnych minut w przedziale czasu, które nie są uwzględnione w godzinach lub dniach.The number of whole minutes in the time interval that aren't included as part of hours or days. Minuty z jedną cyfrą mają wiodące zero.Single-digit minutes have a leading zero.

Więcej informacji: specyfikator formatu niestandardowego "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" Liczba pełnych sekund w przedziale czasu, które nie są uwzględnione w godzinach, dniach lub minutach.The number of whole seconds in the time interval that aren't included as part of hours, days, or minutes. Sekundy o pojedynczej cyfrze nie mają zera wiodącego.Single-digit seconds don't have a leading zero.

Więcej informacji: specyfikator formatu niestandardowego "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" Liczba pełnych sekund w przedziale czasu, które nie są uwzględnione w godzinach, dniach lub minutach.The number of whole seconds in the time interval that aren't included as part of hours, days, or minutes. Kilka sekund ma wiodące zero.Single-digit seconds have a leading zero.

Więcej informacji: specyfikator formatu niestandardowego "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" Dziesiątki sekundy w przedziale czasu.The tenths of a second in a time interval.

Więcej informacji: specyfikator formatu niestandardowego "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" Setne części sekundy w przedziale czasu.The hundredths of a second in a time interval.

Więcej informacji: specyfikator formatu niestandardowego "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" Milisekundy w przedziale czasu.The milliseconds in a time interval.

Więcej informacji: specyfikator formatu niestandardowego "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" Dziesięć stutysięcznych sekundy w przedziale czasu.The ten-thousandths of a second in a time interval.

Więcej informacji: specyfikator formatu niestandardowego "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" Setki stutysięcznych sekund w przedziale czasu.The hundred-thousandths of a second in a time interval.

Więcej informacji: specyfikator formatu niestandardowego "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" Dziesięciomilionowych sekundy w przedziale czasu.The millionths of a second in a time interval.

Więcej informacji: specyfikator formatu niestandardowego "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" Dziesięć dziesięciomilionowych sekund (lub kresek ułamkowych) w przedziale czasu.The ten-millionths of a second (or the fractional ticks) in a time interval.

Więcej informacji: specyfikator formatu niestandardowego "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" Dziesiątki sekundy w przedziale czasu.The tenths of a second in a time interval. Nic nie jest wyświetlane, jeśli cyfra jest równa zero.Nothing is displayed if the digit is zero.

Więcej informacji: specyfikator formatu niestandardowego "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\.F3.ss\.F: 03.
„FF”"FF" Setne części sekundy w przedziale czasu.The hundredths of a second in a time interval. Nie są uwzględniane żadne zera końcowe lub dwie cyfry zerowe.Any fractional trailing zeros or two zero digits aren't included.

Więcej informacji: specyfikator formatu niestandardowego "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" Milisekundy w przedziale czasu.The milliseconds in a time interval. Wszystkie zera końcowe nie są uwzględniane.Any fractional trailing zeros aren't included.

Więcej informacji: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" Dziesięć stutysięcznych sekundy w przedziale czasu.The ten-thousandths of a second in a time interval. Wszystkie zera końcowe nie są uwzględniane.Any fractional trailing zeros aren't included.

Więcej informacji: specyfikator formatu niestandardowego "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" Setki stutysięcznych sekund w przedziale czasu.The hundred-thousandths of a second in a time interval. Wszystkie zera końcowe nie są uwzględniane.Any fractional trailing zeros aren't included.

Więcej informacji: specyfikator formatu niestandardowego "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" Dziesięciomilionowych sekundy w przedziale czasu.The millionths of a second in a time interval. Wszystkie zera końcowe nie są wyświetlane.Any fractional trailing zeros aren't displayed.

Więcej informacji: specyfikator formatu niestandardowego "FFFFFF".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" Dziesięć milionów sekund w przedziale czasu.The ten-millions of a second in a time interval. Nie są wyświetlane żadne zera końcowe lub siedem zer.Any fractional trailing zeros or seven zeros aren't displayed.

Więcej informacji: specyfikator formatu niestandardowego "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 ' Ogranicznik ciągu literału.Literal string delimiter.

Więcej informacji: inne znaki.More information: Other characters.
new TimeSpan(14, 32, 17):

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

Więcej informacji: inne znaki.More information: Other characters.
new TimeSpan(14, 32, 17):

hh\:mm\:ss --> "14:32:17"hh\:mm\:ss --> "14:32:17"
Jakikolwiek inny znakAny other character Każdy inny niezmieniony znak jest interpretowany jako specyfikator formatu niestandardowego.Any other unescaped character is interpreted as a custom format specifier.

Więcej informacji: inne znaki.More Information: Other characters.
new TimeSpan(14, 32, 17):

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

Specyfikator formatu niestandardowego "d"The "d" custom format specifier

Specyfikator formatu niestandardowego "d" wyprowadza wartość TimeSpan.Days właściwości, która reprezentuje liczbę pełnych dni w przedziale czasu.The "d" custom format specifier outputs the value of the TimeSpan.Days property, which represents the number of whole days in the time interval. Wyświetla pełną liczbę dni w TimeSpan wartości, nawet jeśli wartość ma więcej niż jedną cyfrę.It outputs the full number of days in a TimeSpan value, even if the value has more than one digit. Jeśli wartość TimeSpan.Days właściwości jest równa zero, specyfikator zwraca wartość "0".If the value of the TimeSpan.Days property is zero, the specifier outputs "0".

Jeśli specyfikator formatu niestandardowego "d" jest używany samodzielnie, określ "% d", tak aby nie był interpretowany jako ciąg formatu standardowego.If the "d" custom format specifier is used alone, specify "%d" so that it isn't misinterpreted as a standard format string. Poniższy przykład stanowi ilustrację.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   

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

Wróć do tabeliBack to table

Specyfikatory formatu niestandardowego "DD"-"dddddddd"The "dd"-"dddddddd" custom format specifiers

Specyfikatory formatu niestandardowego "DD", "ddd", "dddd", "dddd", "DDDDDD", "ddddddd" i "dddddddd" wyprowadzają wartość TimeSpan.Days właściwości, która reprezentuje liczbę pełnych dni w przedziale czasu.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.

Ciąg wyjściowy zawiera minimalną liczbę cyfr określoną przez liczbę znaków "d" w specyfikatorze formatu i jest uzupełniona wiodącymi zerami zgodnie z potrzebami.The output string includes a minimum number of digits specified by the number of "d" characters in the format specifier, and it's padded with leading zeros as needed. Jeśli cyfry w liczbie dni przekraczają liczbę znaków "d" w specyfikatorze formatu, pełna liczba dni jest wyjściowa w ciągu wynikowym.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.

W poniższym przykładzie zastosowano te specyfikatory formatu, aby wyświetlić ciąg reprezentujący dwie TimeSpan wartości.The following example uses these format specifiers to display the string representation of two TimeSpan values. Wartość składnika dni pierwszego interwału wynosi zero; wartość składnika dni sekundy to 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      

Wróć do tabeliBack to table

Specyfikator formatu niestandardowego "h"The "h" custom format specifier

Specyfikator formatu niestandardowego "h" wyprowadza wartość TimeSpan.Hours właściwości, która reprezentuje liczbę pełnych godzin w przedziale czasu, który nie jest liczony jako część jego składnika dnia.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 isn't counted as part of its day component. Zwraca wartość ciągu jednocyfrowego, jeśli wartość TimeSpan.Hours właściwości jest 0 do 9 i zwraca dwucyfrową wartość ciągu, jeśli wartość TimeSpan.Hours właściwości jest z zakresu od 10 do 23.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.

Jeśli specyfikator formatu niestandardowego "h" jest używany samodzielnie, określ wartość "% h" tak, aby nie była interpretowana jako ciąg formatu standardowego.If the "h" custom format specifier is used alone, specify "%h" so that it isn't misinterpreted as a standard format string. Poniższy przykład stanowi ilustrację.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

Zwykle w operacji analizowania ciąg wejściowy, który zawiera tylko jedną liczbę, jest interpretowany jako liczba dni.Ordinarily, in a parsing operation, an input string that includes only a single number is interpreted as the number of days. Zamiast tego można użyć specyfikatora formatu niestandardowego "% h", aby zinterpretować ciąg liczbowy jako liczbę godzin.You can use the "%h" custom format specifier instead to interpret the numeric string as the number of hours. Poniższy przykład stanowi ilustrację.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                              

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

Wróć do tabeliBack to table

Specyfikator formatu niestandardowego "HH"The "hh" custom format specifier

Specyfikator formatu niestandardowego "HH" TimeSpan.Hours zwraca wartość właściwości, która reprezentuje liczbę pełnych godzin w przedziale czasu, który nie jest liczony jako część jego składnika dnia.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 isn't counted as part of its day component. W przypadku wartości z przewidzianych od 0 do 9 ciąg wyjściowy zawiera wiodące zero.For values from 0 through 9, the output string includes a leading zero.

Zwykle w operacji analizowania ciąg wejściowy, który zawiera tylko jedną liczbę, jest interpretowany jako liczba dni.Ordinarily, in a parsing operation, an input string that includes only a single number is interpreted as the number of days. Zamiast tego można użyć specyfikatora formatu niestandardowego "HH", aby zinterpretować ciąg liczbowy jako liczbę godzin.You can use the "hh" custom format specifier instead to interpret the numeric string as the number of hours. Poniższy przykład stanowi ilustrację.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                              

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

Wróć do tabeliBack to table

Specyfikator formatu niestandardowego "m"The "m" custom format specifier

Specyfikator formatu niestandardowego "m" wyprowadza wartość TimeSpan.Minutes właściwości, która reprezentuje liczbę pełnych minut w interwale czasu, który nie jest liczony jako część jego składnika dnia.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 isn't counted as part of its day component. Zwraca wartość ciągu jednocyfrowego, jeśli wartość TimeSpan.Minutes właściwości jest 0 do 9 i zwraca dwucyfrową wartość ciągu, jeśli wartość TimeSpan.Minutes właściwości jest z zakresu od 10 do 59.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.

Jeśli specyfikator formatu niestandardowego "m" jest używany samodzielnie, określ "% m", tak aby nie był interpretowany jako ciąg formatu standardowego.If the "m" custom format specifier is used alone, specify "%m" so that it isn't misinterpreted as a standard format string. Poniższy przykład stanowi ilustrację.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

Zwykle w operacji analizowania ciąg wejściowy, który zawiera tylko jedną liczbę, jest interpretowany jako liczba dni.Ordinarily, in a parsing operation, an input string that includes only a single number is interpreted as the number of days. Zamiast tego można użyć specyfikatora formatu niestandardowego "% m", aby zinterpretować ciąg liczbowy jako liczbę minut.You can use the "%m" custom format specifier instead to interpret the numeric string as the number of minutes. Poniższy przykład stanowi ilustrację.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                              

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

Wróć do tabeliBack to table

Specyfikator formatu niestandardowego "mm"The "mm" custom format specifier

Specyfikator formatu niestandardowego "mm" wyświetla wartość TimeSpan.Minutes właściwości, która reprezentuje liczbę pełnych minut w interwale czasu, która nie jest uwzględniona w jego składniku godziny lub dni.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 isn't included as part of its hours or days component. W przypadku wartości z przewidzianych od 0 do 9 ciąg wyjściowy zawiera wiodące zero.For values from 0 through 9, the output string includes a leading zero.

Zwykle w operacji analizowania ciąg wejściowy, który zawiera tylko jedną liczbę, jest interpretowany jako liczba dni.Ordinarily, in a parsing operation, an input string that includes only a single number is interpreted as the number of days. Zamiast tego można użyć specyfikatora formatu niestandardowego "mm", aby zinterpretować ciąg liczbowy jako liczbę minut.You can use the "mm" custom format specifier instead to interpret the numeric string as the number of minutes. Poniższy przykład stanowi ilustrację.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           

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

Wróć do tabeliBack to table

Specyfikator formatu niestandardowego "s"The "s" custom format specifier

Specyfikator formatu niestandardowego "s" wyprowadza wartość TimeSpan.Seconds właściwości, która reprezentuje liczbę całych sekund w interwale czasu, która nie jest uwzględniona w godzinach, dniach lub minutach.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 isn't included as part of its hours, days, or minutes component. Zwraca wartość ciągu jednocyfrowego, jeśli wartość TimeSpan.Seconds właściwości jest 0 do 9 i zwraca dwucyfrową wartość ciągu, jeśli wartość TimeSpan.Seconds właściwości jest z zakresu od 10 do 59.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.

Jeśli specyfikator formatu niestandardowego "s" jest używany samodzielnie, określ "% s" tak, aby nie był interpretowany jako ciąg formatu standardowego.If the "s" custom format specifier is used alone, specify "%s" so that it isn't misinterpreted as a standard format string. Poniższy przykład stanowi ilustrację.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

Zwykle w operacji analizowania ciąg wejściowy, który zawiera tylko jedną liczbę, jest interpretowany jako liczba dni.Ordinarily, in a parsing operation, an input string that includes only a single number is interpreted as the number of days. Zamiast tego można użyć specyfikatora formatu niestandardowego "% s", aby zinterpretować ciąg liczbowy jako liczbę sekund.You can use the "%s" custom format specifier instead to interpret the numeric string as the number of seconds. Poniższy przykład stanowi ilustrację.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

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

Wróć do tabeliBack to table

Specyfikator formatu niestandardowego "SS"The "ss" custom format specifier

Specyfikator formatu niestandardowego "SS" wyprowadza wartość TimeSpan.Seconds właściwości, która reprezentuje liczbę całych sekund w interwale czasu, która nie jest uwzględniona w godzinach, dniach lub minutach.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 isn't included as part of its hours, days, or minutes component. W przypadku wartości z przewidzianych od 0 do 9 ciąg wyjściowy zawiera wiodące zero.For values from 0 through 9, the output string includes a leading zero.

Zwykle w operacji analizowania ciąg wejściowy, który zawiera tylko jedną liczbę, jest interpretowany jako liczba dni.Ordinarily, in a parsing operation, an input string that includes only a single number is interpreted as the number of days. Zamiast tego można użyć specyfikatora formatu niestandardowego "SS", aby zinterpretować ciąg liczbowy jako liczbę sekund.You can use the "ss" custom format specifier instead to interpret the numeric string as the number of seconds. Poniższy przykład stanowi ilustrację.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

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

Wróć do tabeliBack to table

Specyfikator formatu niestandardowego "f"The "f" custom format specifier

Specyfikator formatu niestandardowego "f" wyświetla dziesiątki sekundy w przedziale czasu.The "f" custom format specifier outputs the tenths of a second in a time interval. W operacji formatowania wszystkie pozostałe cyfry ułamkowe są obcinane.In a formatting operation, any remaining fractional digits are truncated. W operacji analizowania, która wywołuje TimeSpan.ParseExact metodę lub TimeSpan.TryParseExact , ciąg wejściowy musi zawierać dokładnie jedną cyfrę ułamkową.In a parsing operation that calls the TimeSpan.ParseExact or TimeSpan.TryParseExact method, the input string must contain exactly one fractional digit.

Jeśli specyfikator formatu niestandardowego "f" jest używany samodzielnie, określ "% f" tak, aby nie był interpretowany jako ciąg formatu standardowego.If the "f" custom format specifier is used alone, specify "%f" so that it isn't misinterpreted as a standard format string.

Poniższy przykład używa specyfikatora formatu niestandardowego "f", aby wyświetlić dziesiątki części sekundy w TimeSpan wartości.The following example uses the "f" custom format specifier to display the tenths of a second in a TimeSpan value. "f" jest używany jako pierwszy specyfikator formatu, a następnie połączony ze specyfikatorem "s" w niestandardowym ciągu formatu."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

Wróć do tabeliBack to table

Specyfikator formatu niestandardowego "FF"The "ff" custom format specifier

Specyfikator formatu niestandardowego "FF" wyprowadza setne części sekundy w przedziale czasu.The "ff" custom format specifier outputs the hundredths of a second in a time interval. W operacji formatowania wszystkie pozostałe cyfry ułamkowe są obcinane.In a formatting operation, any remaining fractional digits are truncated. W operacji analizowania, która wywołuje TimeSpan.ParseExact metodę lub TimeSpan.TryParseExact , ciąg wejściowy musi zawierać dokładnie dwie cyfry ułamkowe.In a parsing operation that calls the TimeSpan.ParseExact or TimeSpan.TryParseExact method, the input string must contain exactly two fractional digits.

W poniższym przykładzie zastosowano specyfikator formatu niestandardowego "FF" do wyświetlania setnych części sekundy w TimeSpan wartości.The following example uses the "ff" custom format specifier to display the hundredths of a second in a TimeSpan value. wartość "FF" jest używana najpierw jako jedyny specyfikator formatu, a następnie połączona ze specyfikatorem "s" w niestandardowym ciągu formatu."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

Wróć do tabeliBack to table

Specyfikator formatu niestandardowego "FFF"The "fff" custom format specifier

Specyfikator formatu niestandardowego "FFF" (z trzema znakami "f") wyświetla liczbę milisekund w przedziale czasu.The "fff" custom format specifier (with three "f" characters) outputs the milliseconds in a time interval. W operacji formatowania wszystkie pozostałe cyfry ułamkowe są obcinane.In a formatting operation, any remaining fractional digits are truncated. W operacji analizowania, która wywołuje TimeSpan.ParseExact metodę lub TimeSpan.TryParseExact , ciąg wejściowy musi zawierać dokładnie trzy cyfry ułamkowe.In a parsing operation that calls the TimeSpan.ParseExact or TimeSpan.TryParseExact method, the input string must contain exactly three fractional digits.

Poniższy przykład używa specyfikatora formatu niestandardowego "FFF", aby wyświetlić milisekundy w TimeSpan wartości.The following example uses the "fff" custom format specifier to display the milliseconds in a TimeSpan value. "FFF" jest używany jako pierwszy specyfikator formatu, a następnie połączony ze specyfikatorem "s" w niestandardowym ciągu formatu."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

Wróć do tabeliBack to table

Specyfikator formatu niestandardowego "FFFF"The "ffff" custom format specifier

Specyfikator formatu niestandardowego "FFFF" (z czterema znakami "f") wyświetla dziesięć stutysięcznych sekundy w przedziale czasu.The "ffff" custom format specifier (with four "f" characters) outputs the ten-thousandths of a second in a time interval. W operacji formatowania wszystkie pozostałe cyfry ułamkowe są obcinane.In a formatting operation, any remaining fractional digits are truncated. W operacji analizowania, która wywołuje TimeSpan.ParseExact metodę lub TimeSpan.TryParseExact , ciąg wejściowy musi zawierać dokładnie cztery cyfry ułamkowe.In a parsing operation that calls the TimeSpan.ParseExact or TimeSpan.TryParseExact method, the input string must contain exactly four fractional digits.

W poniższym przykładzie zastosowano specyfikator formatu niestandardowego "FFFF", aby wyświetlić dziesięć stutysięcznych sekundy w TimeSpan wartości.The following example uses the "ffff" custom format specifier to display the ten-thousandths of a second in a TimeSpan value. "FFFF" jest używany jako pierwszy specyfikator formatu, a następnie połączony ze specyfikatorem "s" w niestandardowym ciągu formatu."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

Wróć do tabeliBack to table

Specyfikator formatu niestandardowego "fffff"The "fffff" custom format specifier

Specyfikator formatu niestandardowego "fffff" (z pięcioma znakami "f") wyświetla liczbę setek-stutysięcznych sekundy w przedziale czasu.The "fffff" custom format specifier (with five "f" characters) outputs the hundred-thousandths of a second in a time interval. W operacji formatowania wszystkie pozostałe cyfry ułamkowe są obcinane.In a formatting operation, any remaining fractional digits are truncated. W operacji analizowania, która wywołuje TimeSpan.ParseExact metodę lub TimeSpan.TryParseExact , ciąg wejściowy musi zawierać dokładnie pięć cyfr ułamkowych.In a parsing operation that calls the TimeSpan.ParseExact or TimeSpan.TryParseExact method, the input string must contain exactly five fractional digits.

Poniższy przykład używa specyfikatora formatu niestandardowego "fffff", aby wyświetlić setki stutysięcznych sekundy w TimeSpan wartości.The following example uses the "fffff" custom format specifier to display the hundred-thousandths of a second in a TimeSpan value. "fffff" jest używany jako pierwszy specyfikator formatu, a następnie połączony ze specyfikatorem "s" w niestandardowym ciągu formatu."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

Wróć do tabeliBack to table

Specyfikator formatu niestandardowego "FFFFFF"The "ffffff" custom format specifier

Specyfikator formatu niestandardowego "FFFFFF" (z sześcioma znakami "f") wyświetla dziesięciomilionowych sekundy w przedziale czasu.The "ffffff" custom format specifier (with six "f" characters) outputs the millionths of a second in a time interval. W operacji formatowania wszystkie pozostałe cyfry ułamkowe są obcinane.In a formatting operation, any remaining fractional digits are truncated. W operacji analizowania, która wywołuje TimeSpan.ParseExact metodę lub TimeSpan.TryParseExact , ciąg wejściowy musi zawierać dokładnie sześć cyfr ułamkowych.In a parsing operation that calls the TimeSpan.ParseExact or TimeSpan.TryParseExact method, the input string must contain exactly six fractional digits.

Poniższy przykład używa specyfikatora formatu niestandardowego "FFFFFF", aby wyświetlić dziesięciomilionowych sekundy w TimeSpan wartości.The following example uses the "ffffff" custom format specifier to display the millionths of a second in a TimeSpan value. Jest używana najpierw jako jedyny specyfikator formatu, a następnie połączona ze specyfikatorem "s" w niestandardowym ciągu formatu.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

Wróć do tabeliBack to table

Specyfikator formatu niestandardowego "fffffff"The "fffffff" custom format specifier

Specyfikator formatu niestandardowego "fffffff" (z siedmiu znakami "f") wyprowadza dziesięć dziesięciomilionowych sekund (lub ułamkową liczbę znaczników) w przedziale czasu.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. W operacji analizowania, która wywołuje TimeSpan.ParseExact metodę lub TimeSpan.TryParseExact , ciąg wejściowy musi zawierać dokładnie siedem cyfr.In a parsing operation that calls the TimeSpan.ParseExact or TimeSpan.TryParseExact method, the input string must contain exactly seven fractional digits.

Poniższy przykład używa specyfikatora formatu niestandardowego "fffffff" do wyświetlania ułamkowej liczby znaczników w TimeSpan wartości.The following example uses the "fffffff" custom format specifier to display the fractional number of ticks in a TimeSpan value. Jest używana najpierw jako jedyny specyfikator formatu, a następnie połączona ze specyfikatorem "s" w niestandardowym ciągu formatu.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

Wróć do tabeliBack to table

Specyfikator formatu niestandardowego "F"The "F" custom format specifier

Specyfikator formatu niestandardowego "F" wyświetla dziesiątki sekundy w przedziale czasu.The "F" custom format specifier outputs the tenths of a second in a time interval. W operacji formatowania wszystkie pozostałe cyfry ułamkowe są obcinane.In a formatting operation, any remaining fractional digits are truncated. Jeśli wartość dziesiąty przedziału czasu jest równa zero, nie jest ona uwzględniona w ciągu wynikowym.If the value of the time interval's tenths of a second is zero, it isn't included in the result string. W operacji analizowania, która wywołuje TimeSpan.ParseExact metodę lub TimeSpan.TryParseExact , obecność dziesiątek drugiej cyfry jest opcjonalna.In a parsing operation that calls the TimeSpan.ParseExact or TimeSpan.TryParseExact method, the presence of the tenths of a second digit is optional.

Jeśli specyfikator formatu niestandardowego "F" jest używany samodzielnie, określ "% F" tak, aby nie był interpretowany jako ciąg formatu standardowego.If the "F" custom format specifier is used alone, specify "%F" so that it isn't misinterpreted as a standard format string.

Poniższy przykład używa specyfikatora formatu niestandardowego "F", aby wyświetlić dziesiątki części sekundy w TimeSpan wartości.The following example uses the "F" custom format specifier to display the tenths of a second in a TimeSpan value. Używa również tego specyfikatora formatu niestandardowego w operacji analizowania.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'.      

Wróć do tabeliBack to table

Specyfikator formatu niestandardowego "FF"The "FF" custom format specifier

Specyfikator formatu niestandardowego "FF" wyprowadza setne części sekundy w przedziale czasu.The "FF" custom format specifier outputs the hundredths of a second in a time interval. W operacji formatowania wszystkie pozostałe cyfry ułamkowe są obcinane.In a formatting operation, any remaining fractional digits are truncated. Jeśli istnieją końcowe zera, nie są one uwzględnione w ciągu wynikowym.If there are any trailing fractional zeros, they aren't included in the result string. W operacji analizowania, która wywołuje TimeSpan.ParseExact metodę lub TimeSpan.TryParseExact , obecność dziesiątek i setnych części sekundy jest opcjonalna.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.

W poniższym przykładzie zastosowano specyfikator formatu niestandardowego "FF" do wyświetlania setnych części sekundy w TimeSpan wartości.The following example uses the "FF" custom format specifier to display the hundredths of a second in a TimeSpan value. Używa również tego specyfikatora formatu niestandardowego w operacji analizowania.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'.

Wróć do tabeliBack to table

Specyfikator formatu niestandardowego "FFF"The "FFF" custom format specifier

Specyfikator formatu niestandardowego "FFF" (z trzema znakami "F") wyświetla liczbę milisekund w przedziale czasu.The "FFF" custom format specifier (with three "F" characters) outputs the milliseconds in a time interval. W operacji formatowania wszystkie pozostałe cyfry ułamkowe są obcinane.In a formatting operation, any remaining fractional digits are truncated. Jeśli istnieją końcowe zera, nie są one uwzględnione w ciągu wynikowym.If there are any trailing fractional zeros, they aren't included in the result string. W operacji analizowania, która wywołuje TimeSpan.ParseExact metodę lub TimeSpan.TryParseExact , obecność dziesiątek, setnych i stutysięcznych drugiej cyfry jest opcjonalna.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.

Poniższy przykład używa specyfikatora formatu niestandardowego "FFF", aby wyświetlić stutysięcznych sekundy w TimeSpan wartości.The following example uses the "FFF" custom format specifier to display the thousandths of a second in a TimeSpan value. Używa również tego specyfikatora formatu niestandardowego w operacji analizowania.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'.

Wróć do tabeliBack to table

Specyfikator formatu niestandardowego "FFFF"The "FFFF" custom format specifier

Specyfikator formatu niestandardowego "FFFF" (z czterema znakami "F") wyświetla dziesięć stutysięcznych sekundy w przedziale czasu.The "FFFF" custom format specifier (with four "F" characters) outputs the ten-thousandths of a second in a time interval. W operacji formatowania wszystkie pozostałe cyfry ułamkowe są obcinane.In a formatting operation, any remaining fractional digits are truncated. Jeśli istnieją końcowe zera, nie są one uwzględnione w ciągu wynikowym.If there are any trailing fractional zeros, they aren't included in the result string. W operacji analizowania, która wywołuje TimeSpan.ParseExact metodę lub TimeSpan.TryParseExact , obecność dziesiątek, setnych, stutysięcznych i dziesięciu-stutysięcznych w drugiej cyfra jest opcjonalna.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.

W poniższym przykładzie zastosowano specyfikator formatu niestandardowego "FFFF", aby wyświetlić dziesięć stutysięcznych sekundy w TimeSpan wartości.The following example uses the "FFFF" custom format specifier to display the ten-thousandths of a second in a TimeSpan value. Używa także specyfikatora formatu niestandardowego "FFFF" w operacji analizowania.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'.

Wróć do tabeliBack to table

Specyfikator formatu niestandardowego "FFFFF"The "FFFFF" custom format specifier

Specyfikator formatu niestandardowego "FFFFF" (z pięcioma znakami "F") wyświetla liczbę setek-stutysięcznych sekundy w przedziale czasu.The "FFFFF" custom format specifier (with five "F" characters) outputs the hundred-thousandths of a second in a time interval. W operacji formatowania wszystkie pozostałe cyfry ułamkowe są obcinane.In a formatting operation, any remaining fractional digits are truncated. Jeśli istnieją końcowe zera, nie są one uwzględnione w ciągu wynikowym.If there are any trailing fractional zeros, they aren't included in the result string. W operacji analizowania, która wywołuje TimeSpan.ParseExact metodę lub TimeSpan.TryParseExact , obecność dziesiątek, setnych, stutysięcznych, dziesięciu-stutysięcznych i setek-stutysięcznych w drugiej cyfra jest opcjonalna.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.

Poniższy przykład używa specyfikatora formatu niestandardowego "FFFFF", aby wyświetlić setki stutysięcznych sekundy w TimeSpan wartości.The following example uses the "FFFFF" custom format specifier to display the hundred-thousandths of a second in a TimeSpan value. Używa także specyfikatora formatu niestandardowego "FFFFF" w operacji analizowania.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'.

Wróć do tabeliBack to table

Specyfikator formatu niestandardowego "FFFFFF"The "FFFFFF" custom format specifier

Specyfikator formatu niestandardowego "FFFFFF" (z sześcioma znakami "F") wyświetla dziesięciomilionowych sekundy w przedziale czasu.The "FFFFFF" custom format specifier (with six "F" characters) outputs the millionths of a second in a time interval. W operacji formatowania wszystkie pozostałe cyfry ułamkowe są obcinane.In a formatting operation, any remaining fractional digits are truncated. Jeśli istnieją końcowe zera, nie są one uwzględnione w ciągu wynikowym.If there are any trailing fractional zeros, they aren't included in the result string. W operacji analizowania, która wywołuje TimeSpan.ParseExact metodę lub TimeSpan.TryParseExact , obecność dziesiątek, setnych, stutysięcznych, dziesięciu-stutysięcznych, setek-stutysięcznych i dziesięciomilionowych drugiej cyfry jest opcjonalna.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.

Poniższy przykład używa specyfikatora formatu niestandardowego "FFFFFF", aby wyświetlić dziesięciomilionowych sekundy w TimeSpan wartości.The following example uses the "FFFFFF" custom format specifier to display the millionths of a second in a TimeSpan value. Używa również tego specyfikatora formatu niestandardowego w operacji analizowania.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'.

Wróć do tabeliBack to table

Specyfikator formatu niestandardowego "FFFFFFF"The "FFFFFFF" custom format specifier

Specyfikator formatu niestandardowego "FFFFFFF" (z siedmiu znakami "F") wyprowadza dziesięć dziesięciomilionowych sekund (lub ułamkową liczbę znaczników) w przedziale czasu.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. Jeśli istnieją końcowe zera, nie są one uwzględnione w ciągu wynikowym.If there are any trailing fractional zeros, they aren't included in the result string. W operacji analizowania, która wywołuje TimeSpan.ParseExact metodę lub TimeSpan.TryParseExact , obecność siedmiu cyfr ułamkowych w ciągu wejściowym jest opcjonalna.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.

Poniższy przykład używa specyfikatora formatu niestandardowego "FFFFFFF", aby wyświetlić części ułamkowe sekundy w TimeSpan wartości.The following example uses the "FFFFFFF" custom format specifier to display the fractional parts of a second in a TimeSpan value. Używa również tego specyfikatora formatu niestandardowego w operacji analizowania.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     

Wróć do tabeliBack to table

Inne znakiOther characters

Każdy inny niezmieniony znak w ciągu formatu, w tym znak odstępu, jest interpretowany jako specyfikator formatu niestandardowego.Any other unescaped character in a format string, including a white-space character, is interpreted as a custom format specifier. W większości przypadków obecność dowolnego innego niezmienionego znaku skutkuje w FormatException .In most cases, the presence of any other unescaped character results in a FormatException.

Istnieją dwa sposoby dołączania znaku literału w ciągu formatu:There are two ways to include a literal character in a format string:

  • Ujmij ją w znaki pojedynczego cudzysłowu (ogranicznik ciągu literału).Enclose it in single quotation marks (the literal string delimiter).

  • Poprzedzaj go ukośnikiem odwrotnym (" \ "), który jest interpretowany jako znak ucieczki.Precede it with a backslash ("\"), which is interpreted as an escape character. Oznacza to, że w języku C# ciąg formatu musi być @-quoted lub znak literału musi być poprzedzony dodatkowym ukośnikiem odwrotnym.This means that, in C#, the format string must either be @-quoted, or the literal character must be preceded by an additional backslash.

    W niektórych przypadkach może być konieczne użycie logiki warunkowej w celu uwzględnienia literału ucieczki w ciągu formatu.In some cases, you may have to use conditional logic to include an escaped literal in a format string. Poniższy przykład używa logiki warunkowej, aby dołączyć symbol znaku dla ujemnych interwałów czasowych.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
    

Platforma .NET nie definiuje gramatyki dla separatorów w przedziałach czasu..NET doesn't define a grammar for separators in time intervals. Oznacza to, że separatory między dni i godziny, godziny i minuty, minuty i sekundy oraz sekundy i ułamki sekund muszą być traktowane jako literały znakowe w ciągu formatu.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.

Poniższy przykład używa znaku ucieczki i pojedynczego cudzysłowu do definiowania niestandardowego ciągu formatu zawierającego wyraz "minuty" w ciągu danych wyjściowych.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      

Wróć do tabeliBack to table

Zobacz takżeSee also