Özel TimeSpan Biçim dizeleriCustom TimeSpan format strings

TimeSpan biçim dizesi, biçimlendirme işleminden kaynaklanan bir TimeSpan değerin dize gösterimini tanımlar.A TimeSpan format string defines the string representation of a TimeSpan value that results from a formatting operation. Özel biçim dizesi, bir veya daha fazla özel TimeSpan biçim belirticisinden ve herhangi bir sayıda değişmez karakterle oluşur.A custom format string consists of one or more custom TimeSpan format specifiers along with any number of literal characters. Standart TimeSpan Biçim dizesi olmayan herhangi bir dize, özel bir TimeSpan biçim dizesi olarak yorumlanır.Any string that isn't a Standard TimeSpan format string is interpreted as a custom TimeSpan format string.

Önemli

Özel TimeSpan biçim belirticileri, günleri saat, saat, dakika veya kesirli saniyeden saniye olarak ayıran semboller gibi yer tutucu ayırıcı sembolleri içermez.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. Bunun yerine, bu simgelerin dize sabit değerleri olarak özel biçim dizesine dahil olması gerekir.Instead, these symbols must be included in the custom format string as string literals. Örneğin, "dd\.hh\:mm" günler ve saatler arasındaki ayırıcı olarak bir nokta (.) ve iki nokta üst üste (:) Saat ve dakika arasında ayırıcı olarak.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.

Özel TimeSpan biçim belirticileri ayrıca negatif ve pozitif zaman aralıklarını ayırt etmenizi sağlayan bir işaret simgesi de içermez.Custom TimeSpan format specifiers also don't include a sign symbol that enables you to differentiate between negative and positive time intervals. Bir işaret simgesi eklemek için, koşullu mantığı kullanarak bir biçim dizesi oluşturmanız gerekir.To include a sign symbol, you have to construct a format string by using conditional logic. Diğer karakterler bölümü bir örnek içerir.The Other characters section includes an example.

TimeSpan değerlerinin dize temsilleri, TimeSpan.ToString yönteminin aşırı yüklerini ve String.Formatgibi bileşik biçimlendirmeyi destekleyen yöntemleri tarafından üretilir.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. Daha fazla bilgi için bkz. biçimlendirme türleri ve Bileşik biçimlendirme.For more information, see Formatting Types and Composite Formatting. Aşağıdaki örnek biçimlendirme işlemlerinde özel biçim dizelerinin kullanımını gösterir.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

Özel TimeSpan biçim dizeleri, TimeSpan.ParseExact ve TimeSpan.TryParseExact yöntemleri tarafından, ayrıştırma işlemleri için gereken giriş dizeleri biçimini tanımlamak için de kullanılır.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. (Ayrıştırma bir değerin dize temsilini bu değere dönüştürür.) Aşağıdaki örnek, ayrıştırma işlemlerinde standart biçim dizelerinin kullanımını gösterir.(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

Aşağıdaki tabloda özel tarih ve saat biçimi belirticileri açıklanmaktadır.The following table describes the custom date and time format specifiers.

Biçim belirteciFormat specifier AçıklamaDescription ÖrnekExample
"d", "% d""d", "%d" Zaman aralığındaki tüm gün sayısı.The number of whole days in the time interval.

Daha fazla bilgi: "d" Özel Biçim belirleyicisi.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"
"gg"-"dddddddd""dd"-"dddddddd" Zaman aralığındaki tüm gün sayısı, gerektiği şekilde önde sıfır ile doldurulmuştur.The number of whole days in the time interval, padded with leading zeros as needed.

Daha fazla bilgi: "gg"-"dddddddd" özel biçim belirticileri.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" Zaman aralığındaki, günlerin bir parçası olarak sayılmayan tüm saatlerin sayısı.The number of whole hours in the time interval that aren't counted as part of days. Tek basamaklı saatlerin önünde sıfır yok.Single-digit hours don't have a leading zero.

Daha fazla bilgi: "h" Özel Biçim belirleyicisi.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" Zaman aralığındaki, günlerin bir parçası olarak sayılmayan tüm saatlerin sayısı.The number of whole hours in the time interval that aren't counted as part of days. Tek basamaklı saatlerin önünde sıfır vardır.Single-digit hours have a leading zero.

Daha fazla bilgi: "hh" Özel Biçim belirleyicisi.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
"a", "% d""m", "%m" Zaman aralığındaki saatlerin veya günlerin bir parçası olarak dahil olmayan tam dakika sayısı.The number of whole minutes in the time interval that aren't included as part of hours or days. Tek basamaklı dakikalar önünde sıfır yok.Single-digit minutes don't have a leading zero.

Daha fazla bilgi: "d" Özel Biçim belirleyicisi.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" Zaman aralığındaki saatlerin veya günlerin bir parçası olarak dahil olmayan tam dakika sayısı.The number of whole minutes in the time interval that aren't included as part of hours or days. Tek basamaklı dakikalar önünde sıfır vardır.Single-digit minutes have a leading zero.

Daha fazla bilgi: "mm" Özel Biçim belirleyicisi.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" Zaman aralığındaki saat, gün veya dakika parçası olarak dahil olmayan tüm saniye sayısı.The number of whole seconds in the time interval that aren't included as part of hours, days, or minutes. Tek basamaklı saniyeler önünde sıfır yok.Single-digit seconds don't have a leading zero.

Daha fazla bilgi: "s" Özel Biçim belirleyicisi.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" Zaman aralığındaki saat, gün veya dakika parçası olarak dahil olmayan tüm saniye sayısı.The number of whole seconds in the time interval that aren't included as part of hours, days, or minutes. Tek basamaklı saniyeler önünde sıfır vardır.Single-digit seconds have a leading zero.

Daha fazla bilgi: "ss" Özel Biçim belirleyicisi.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" Bir zaman aralığında saniyenin onda biri.The tenths of a second in a time interval.

Daha fazla bilgi: "f" Özel Biçim belirleyicisi.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" Bir zaman aralığında saniyenin yüzde biri.The hundredths of a second in a time interval.

Daha fazla bilgi: "FF" Özel Biçim belirleyicisi.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" Bir zaman aralığındaki milisaniyedir.The milliseconds in a time interval.

Daha fazla bilgi: "fff" Özel Biçim belirleyicisi.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" İkinci bir zaman aralığında on-binde.The ten-thousandths of a second in a time interval.

Daha fazla bilgi: "ffff" Özel Biçim belirleyicisi.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" Bir zaman aralığı içinde saniyenin yüz binde.The hundred-thousandths of a second in a time interval.

Daha fazla bilgi: "fffff" Özel Biçim belirleyicisi.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" Saniyenin bir zaman aralığı içinde milionaltı.The millionths of a second in a time interval.

Daha fazla bilgi: "FFFFFF" Özel Biçim belirleyicisi.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" Bir saniye (veya kesirli Ticks) bir zaman aralığında On milimetre onda.The ten-millionths of a second (or the fractional ticks) in a time interval.

Daha fazla bilgi: "fffffff" Özel Biçim belirleyicisi.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" Bir zaman aralığında saniyenin onda biri.The tenths of a second in a time interval. Basamak sıfırsa hiçbir şey görüntülenmez.Nothing is displayed if the digit is zero.

Daha fazla bilgi: "F" Özel Biçim belirleyicisi.More information: The "F" custom format specifier.
TimeSpan.Parse("00:00:06.32"):TimeSpan.Parse("00:00:06.32"):

%F: 3%F: 3

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

ss\.F: 03.ss\.F: 03.
"FF""FF" Bir zaman aralığında saniyenin yüzde biri.The hundredths of a second in a time interval. Tüm kesirli sondaki sıfırlar veya iki sıfır basamak dahil değildir.Any fractional trailing zeros or two zero digits aren't included.

Daha fazla bilgi: "FF" Özel Biçim belirleyicisi.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" Bir zaman aralığındaki milisaniyedir.The milliseconds in a time interval. Tüm kesirli sondaki sıfırlar dahil edilmez.Any fractional trailing zeros aren't included.

Ek bilgi: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" İkinci bir zaman aralığında on-binde.The ten-thousandths of a second in a time interval. Tüm kesirli sondaki sıfırlar dahil edilmez.Any fractional trailing zeros aren't included.

Daha fazla bilgi: "ffff" Özel Biçim belirleyicisi.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" Bir zaman aralığı içinde saniyenin yüz binde.The hundred-thousandths of a second in a time interval. Tüm kesirli sondaki sıfırlar dahil edilmez.Any fractional trailing zeros aren't included.

Daha fazla bilgi: "FFFFF" Özel Biçim belirleyicisi.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" Saniyenin bir zaman aralığı içinde milionaltı.The millionths of a second in a time interval. Tüm kesirli sondaki sıfırlar gösterilmez.Any fractional trailing zeros aren't displayed.

Daha fazla bilgi: "FFFFFF" Özel Biçim belirleyicisi.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" Bir zaman aralığında on milyonlarca bir saniye.The ten-millions of a second in a time interval. Tüm kesirli sondaki sıfırlar veya yedi sıfır gösterilmez.Any fractional trailing zeros or seven zeros aren't displayed.

Daha fazla bilgi: "fffffff" Özel Biçim belirleyicisi.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' Değişmez dize sınırlayıcısı.Literal string delimiter.

Daha fazla bilgi: diğer karakterler.More information: Other characters.
new TimeSpan(14, 32, 17):

hh':'mm':'ss --> "14:32:17"hh':'mm':'ss --> "14:32:17"
\\ "" çıkış karakteri.The escape character.

Daha fazla bilgi: diğer karakterler.More information: Other characters.
new TimeSpan(14, 32, 17):

hh\:mm\:ss --> "14:32:17"hh\:mm\:ss --> "14:32:17"
Başka bir karakterAny other character Atlamayan herhangi bir karakter, Özel Biçim belirleyicisi olarak yorumlanır.Any other unescaped character is interpreted as a custom format specifier.

Daha fazla bilgi: diğer karakterler.More Information: Other characters.
new TimeSpan(14, 32, 17):

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

"D" Özel Biçim belirleyicisiThe "d" custom format specifier

"D" özel biçim belirticisi, zaman aralığındaki tüm gün sayısını temsil eden TimeSpan.Days özelliğinin değerini çıkarır.The "d" custom format specifier outputs the value of the TimeSpan.Days property, which represents the number of whole days in the time interval. Değer birden fazla basamağa sahip olsa bile, bir TimeSpan değerindeki tüm gün sayısını verir.It outputs the full number of days in a TimeSpan value, even if the value has more than one digit. TimeSpan.Days özelliğinin değeri sıfırsa, belirtici "0" verir.If the value of the TimeSpan.Days property is zero, the specifier outputs "0".

"D" Özel Biçim belirleyicisi tek başına kullanılırsa, "% d" öğesini bir standart biçim dizesi olarak yanlış yorumlanmaması için belirtin.If the "d" custom format specifier is used alone, specify "%d" so that it isn't misinterpreted as a standard format string. Aşağıdaki örnek, bir gösterim sağlar.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   

Aşağıdaki örnek, "d" Özel Biçim belirticisinin kullanımını gösterir.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      

Tabloya dönBack to table

"Gg"-"dddddddd" özel biçim belirticileriThe "dd"-"dddddddd" custom format specifiers

"Gg", "ddd", "gggg", "ddddd", "dddddd", "ddddddd" ve "dddddddd" özel biçim belirticileri, zaman aralığındaki tam gün sayısını temsil eden TimeSpan.Days özelliğinin değerini çıktı.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.

Çıktı dizesi, biçim tanımlayıcıda "d" karakter sayısı ile belirtilen en az basamak sayısını içerir ve gerektiğinde öndeki sıfırlar ile doldurulur.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. Gün sayısı içindeki rakamlar, biçim tanımlayıcısındaki "d" karakter sayısını aşarsa, gün sayısının tamamı sonuç dizesinde çıkış olur.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.

Aşağıdaki örnek, iki TimeSpan değerin dize gösterimini göstermek için bu biçim belirticilerini kullanır.The following example uses these format specifiers to display the string representation of two TimeSpan values. İlk zaman aralığının günler bileşeninin değeri sıfırdır; saniyenin gün bileşeni değeri 365 ' dir.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      

Tabloya dönBack to table

"H" Özel Biçim belirleyicisiThe "h" custom format specifier

"H" özel biçim belirticisi, kendi gün bileşeninin bir parçası olarak sayılmayan zaman aralığındaki tüm saatlerin sayısını temsil eden TimeSpan.Hours özelliğinin değerini çıkarır.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. TimeSpan.Hours özelliğinin değeri 0 ' dan 9 ' a kadar ise, tek basamaklı bir dize değeri döndürür ve TimeSpan.Hours özelliğinin değeri 10 ile 23 arasında bir değer döndürürse iki basamaklı bir dize değeri döndürür.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.

"H" Özel Biçim belirleyicisi tek başına kullanılırsa, standart biçim dizesi olarak yanlış yorumlanmaması için "% h" belirtin.If the "h" custom format specifier is used alone, specify "%h" so that it isn't misinterpreted as a standard format string. Aşağıdaki örnek, bir gösterim sağlar.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

Genellikle, bir ayrıştırma işleminde, yalnızca tek bir sayı içeren bir giriş dizesi gün sayısı olarak yorumlanır.Ordinarily, in a parsing operation, an input string that includes only a single number is interpreted as the number of days. Sayısal dizeyi saat sayısı olarak yorumlamak yerine "% h" özel biçim belirticisini kullanabilirsiniz.You can use the "%h" custom format specifier instead to interpret the numeric string as the number of hours. Aşağıdaki örnek, bir gösterim sağlar.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                              

Aşağıdaki örnek, "h" Özel Biçim belirticisinin kullanımını gösterir.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

Tabloya dönBack to table

"Hh" Özel Biçim belirleyicisiThe "hh" custom format specifier

"Hh" özel biçim belirticisi, kendi gün bileşeninin bir parçası olarak sayılmayan zaman aralığındaki tüm saatlerin sayısını temsil eden TimeSpan.Hours özelliğinin değerini çıkarır.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. 0 ile 9 arasında değerler için, çıkış dizesi önünde sıfır değeri içerir.For values from 0 through 9, the output string includes a leading zero.

Genellikle, bir ayrıştırma işleminde, yalnızca tek bir sayı içeren bir giriş dizesi gün sayısı olarak yorumlanır.Ordinarily, in a parsing operation, an input string that includes only a single number is interpreted as the number of days. Sayısal dizeyi saat sayısı olarak yorumlamak yerine "hh" özel biçim belirticisini kullanabilirsiniz.You can use the "hh" custom format specifier instead to interpret the numeric string as the number of hours. Aşağıdaki örnek, bir gösterim sağlar.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                              

Aşağıdaki örnek, "hh" Özel Biçim belirticisinin kullanımını gösterir.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

Tabloya dönBack to table

"D" Özel Biçim belirleyicisiThe "m" custom format specifier

"M" özel biçim belirticisi, kendi gün bileşeninin bir parçası olarak sayılmayan zaman aralığındaki tüm dakikaların sayısını temsil eden TimeSpan.Minutes özelliğinin değerini çıkarır.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. TimeSpan.Minutes özelliğinin değeri 0 ile 9 arasında olursa tek basamaklı bir dize değeri döndürür ve TimeSpan.Minutes özelliğinin değeri 10 ile 59 arasında bir değer döndürürse iki basamaklı bir dize değeri döndürür.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.

"D" Özel Biçim belirleyicisi tek başına kullanılırsa, standart biçim dizesi olarak yanlış yorumlanmaması için "% d" belirtin.If the "m" custom format specifier is used alone, specify "%m" so that it isn't misinterpreted as a standard format string. Aşağıdaki örnek, bir gösterim sağlar.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

Genellikle, bir ayrıştırma işleminde, yalnızca tek bir sayı içeren bir giriş dizesi gün sayısı olarak yorumlanır.Ordinarily, in a parsing operation, an input string that includes only a single number is interpreted as the number of days. Sayısal dizeyi dakika sayısı olarak yorumlamak yerine "% d" özel biçim belirticisini kullanabilirsiniz.You can use the "%m" custom format specifier instead to interpret the numeric string as the number of minutes. Aşağıdaki örnek, bir gösterim sağlar.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                              

Aşağıdaki örnek, "d" Özel Biçim belirticisinin kullanımını gösterir.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

Tabloya dönBack to table

"Mm" Özel Biçim belirleyicisiThe "mm" custom format specifier

"Mm" özel biçim Belirleyicisi, saat veya gün bileşeninin bir parçası olarak dahil olmayan zaman aralığındaki tüm dakikaların sayısını temsil eden TimeSpan.Minutes özelliğinin değerini çıkarır.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. 0 ile 9 arasında değerler için, çıkış dizesi önünde sıfır değeri içerir.For values from 0 through 9, the output string includes a leading zero.

Genellikle, bir ayrıştırma işleminde, yalnızca tek bir sayı içeren bir giriş dizesi gün sayısı olarak yorumlanır.Ordinarily, in a parsing operation, an input string that includes only a single number is interpreted as the number of days. Sayısal dizeyi dakika sayısı olarak yorumlamak yerine "mm" özel biçim belirticisini kullanabilirsiniz.You can use the "mm" custom format specifier instead to interpret the numeric string as the number of minutes. Aşağıdaki örnek, bir gösterim sağlar.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           

Aşağıdaki örnek, "mm" Özel Biçim belirticisinin kullanımını gösterir.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      

Tabloya dönBack to table

"S" Özel Biçim belirleyicisiThe "s" custom format specifier

"S" özel biçim Belirleyicisi, saat, gün veya dakika bileşeninin bir parçası olarak dahil olmayan zaman aralığındaki tüm saniye sayısını temsil eden TimeSpan.Seconds özelliğinin değerini verir.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. TimeSpan.Seconds özelliğinin değeri 0 ile 9 arasında olursa tek basamaklı bir dize değeri döndürür ve TimeSpan.Seconds özelliğinin değeri 10 ile 59 arasında bir değer döndürürse iki basamaklı bir dize değeri döndürür.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.

"S" Özel Biçim belirleyicisi tek başına kullanılırsa, "% s" öğesini bir standart biçim dizesi olarak yanlış yorumlanmaması için belirtin.If the "s" custom format specifier is used alone, specify "%s" so that it isn't misinterpreted as a standard format string. Aşağıdaki örnek, bir gösterim sağlar.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

Genellikle, bir ayrıştırma işleminde, yalnızca tek bir sayı içeren bir giriş dizesi gün sayısı olarak yorumlanır.Ordinarily, in a parsing operation, an input string that includes only a single number is interpreted as the number of days. Sayısal dizeyi saniye sayısı olarak yorumlamak yerine "% s" özel biçim belirticisini kullanabilirsiniz.You can use the "%s" custom format specifier instead to interpret the numeric string as the number of seconds. Aşağıdaki örnek, bir gösterim sağlar.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

Aşağıdaki örnek, "s" Özel Biçim belirticisinin kullanımını gösterir.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      

Tabloya dönBack to table

"Ss" Özel Biçim belirleyicisiThe "ss" custom format specifier

"Ss" özel biçim Belirleyicisi, saat, gün veya dakika bileşeninin bir parçası olarak dahil olmayan zaman aralığındaki tüm saniye sayısını temsil eden TimeSpan.Seconds özelliğinin değerini verir.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. 0 ile 9 arasında değerler için, çıkış dizesi önünde sıfır değeri içerir.For values from 0 through 9, the output string includes a leading zero.

Genellikle, bir ayrıştırma işleminde, yalnızca tek bir sayı içeren bir giriş dizesi gün sayısı olarak yorumlanır.Ordinarily, in a parsing operation, an input string that includes only a single number is interpreted as the number of days. Sayısal dizeyi saniye sayısı olarak yorumlamak yerine "ss" özel biçim belirticisini kullanabilirsiniz.You can use the "ss" custom format specifier instead to interpret the numeric string as the number of seconds. Aşağıdaki örnek, bir gösterim sağlar.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

Aşağıdaki örnek, "ss" Özel Biçim belirticisinin kullanımını gösterir.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

Tabloya dönBack to table

"F" Özel Biçim belirleyicisiThe "f" custom format specifier

"F" özel biçim belirticisi bir saniyenin onda birini bir zaman aralığında verir.The "f" custom format specifier outputs the tenths of a second in a time interval. Biçimlendirme işleminde, kalan kesirli basamaklar kesilir.In a formatting operation, any remaining fractional digits are truncated. TimeSpan.ParseExact veya TimeSpan.TryParseExact yöntemini çağıran bir ayrıştırma işleminde, giriş dizesinin tam olarak bir kesirli basamak içermesi gerekir.In a parsing operation that calls the TimeSpan.ParseExact or TimeSpan.TryParseExact method, the input string must contain exactly one fractional digit.

"F" Özel Biçim belirleyicisi tek başına kullanılırsa, standart biçim dizesi olarak yanlış yorumlanmaması için "% f" belirtin.If the "f" custom format specifier is used alone, specify "%f" so that it isn't misinterpreted as a standard format string.

Aşağıdaki örnek, bir TimeSpan değerinde saniyenin onda birini göstermek için "f" özel biçim belirticisini kullanır.The following example uses the "f" custom format specifier to display the tenths of a second in a TimeSpan value. "f" ilk olarak tek Biçim belirleyicisi olarak kullanılır ve ardından bir özel biçim dizesinde "s" belirticisi ile birleştirilir."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

Tabloya dönBack to table

"FF" Özel Biçim belirleyicisiThe "ff" custom format specifier

"FF" özel biçim belirticisi saniye cinsinden bir zaman aralığına çıkış verir.The "ff" custom format specifier outputs the hundredths of a second in a time interval. Biçimlendirme işleminde, kalan kesirli basamaklar kesilir.In a formatting operation, any remaining fractional digits are truncated. TimeSpan.ParseExact veya TimeSpan.TryParseExact yöntemini çağıran bir ayrıştırma işleminde, giriş dizesinin tam olarak iki kesirli basamak içermesi gerekir.In a parsing operation that calls the TimeSpan.ParseExact or TimeSpan.TryParseExact method, the input string must contain exactly two fractional digits.

Aşağıdaki örnek, bir TimeSpan değerindeki saniyenin yüzde birini göstermek için "FF" özel biçim belirticisini kullanır.The following example uses the "ff" custom format specifier to display the hundredths of a second in a TimeSpan value. önce tek Biçim belirleyicisi olarak "FF" kullanılır ve ardından özel biçim dizesinde "s" belirticisi ile birleştirilir."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

Tabloya dönBack to table

"Fff" Özel Biçim belirleyicisiThe "fff" custom format specifier

"Fff" özel biçim Belirleyicisi (üç "f" karakteri ile), bir zaman aralığındaki milisaniyeyi verir.The "fff" custom format specifier (with three "f" characters) outputs the milliseconds in a time interval. Biçimlendirme işleminde, kalan kesirli basamaklar kesilir.In a formatting operation, any remaining fractional digits are truncated. TimeSpan.ParseExact veya TimeSpan.TryParseExact yöntemini çağıran bir ayrıştırma işleminde, giriş dizesinin tam olarak üç kesirli basamak içermesi gerekir.In a parsing operation that calls the TimeSpan.ParseExact or TimeSpan.TryParseExact method, the input string must contain exactly three fractional digits.

Aşağıdaki örnek, bir TimeSpan değerindeki milisaniyeyi göstermek için "fff" özel biçim belirticisini kullanır.The following example uses the "fff" custom format specifier to display the milliseconds in a TimeSpan value. önce tek Biçim belirleyicisi olarak "fff" kullanılır ve ardından özel biçim dizesinde "s" belirticisi ile birleştirilir."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

Tabloya dönBack to table

"Ffff" Özel Biçim belirleyicisiThe "ffff" custom format specifier

"Ffff" özel biçim belirticisi (dört "f" karakterle birlikte), bir zaman aralığında saniyenin on-binde sayısını verir.The "ffff" custom format specifier (with four "f" characters) outputs the ten-thousandths of a second in a time interval. Biçimlendirme işleminde, kalan kesirli basamaklar kesilir.In a formatting operation, any remaining fractional digits are truncated. TimeSpan.ParseExact veya TimeSpan.TryParseExact yöntemini çağıran bir ayrıştırma işleminde, giriş dizesinin tam olarak dört kesirli basamak içermesi gerekir.In a parsing operation that calls the TimeSpan.ParseExact or TimeSpan.TryParseExact method, the input string must contain exactly four fractional digits.

Aşağıdaki örnek, bir TimeSpan değerindeki bir saniyenin on-binde ' unu göstermek için "ffff" özel biçim belirticisini kullanır.The following example uses the "ffff" custom format specifier to display the ten-thousandths of a second in a TimeSpan value. "ffff" ilk olarak tek Biçim belirleyicisi olarak kullanılır ve ardından özel bir biçim dizesinde "s" belirticisi ile birleştirilir."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

Tabloya dönBack to table

"Fffff" Özel Biçim belirleyicisiThe "fffff" custom format specifier

"Fffff" özel biçim Belirleyicisi (beş "f" karakterle birlikte), bir zaman aralığındaki yüz-binde ' i gösterir.The "fffff" custom format specifier (with five "f" characters) outputs the hundred-thousandths of a second in a time interval. Biçimlendirme işleminde, kalan kesirli basamaklar kesilir.In a formatting operation, any remaining fractional digits are truncated. TimeSpan.ParseExact veya TimeSpan.TryParseExact yöntemini çağıran bir ayrıştırma işleminde, giriş dizesinin tam olarak beş kesirli basamak içermesi gerekir.In a parsing operation that calls the TimeSpan.ParseExact or TimeSpan.TryParseExact method, the input string must contain exactly five fractional digits.

Aşağıdaki örnek, bir TimeSpan değerinde saniyenin yüz binde ' ni göstermek için "fffff" özel biçim belirticisini kullanır.The following example uses the "fffff" custom format specifier to display the hundred-thousandths of a second in a TimeSpan value. önce tek Biçim belirticisi olarak "fffff" kullanılır ve ardından bir özel biçim dizesinde "s" belirticisi ile birleştirilir."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

Tabloya dönBack to table

"FFFFFF" Özel Biçim belirleyicisiThe "ffffff" custom format specifier

"FFFFFF" özel biçim Belirleyicisi (altı "f" karakteriyle birlikte), bir zaman aralığında saniyenin her birinin milionda çıkışını çıkarır.The "ffffff" custom format specifier (with six "f" characters) outputs the millionths of a second in a time interval. Biçimlendirme işleminde, kalan kesirli basamaklar kesilir.In a formatting operation, any remaining fractional digits are truncated. TimeSpan.ParseExact veya TimeSpan.TryParseExact yöntemini çağıran bir ayrıştırma işleminde, giriş dizesinin tam olarak altı kesirli basamak içermesi gerekir.In a parsing operation that calls the TimeSpan.ParseExact or TimeSpan.TryParseExact method, the input string must contain exactly six fractional digits.

Aşağıdaki örnek, bir TimeSpan değerindeki bir saniyenin milionkesini göstermek için "FFFFFF" özel biçim belirticisini kullanır.The following example uses the "ffffff" custom format specifier to display the millionths of a second in a TimeSpan value. İlk olarak tek Biçim belirleyicisi olarak kullanılır ve ardından özel bir biçim dizesinde "s" belirticisi ile birleştirilir.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

Tabloya dönBack to table

"Fffffff" Özel Biçim belirleyicisiThe "fffffff" custom format specifier

"Fffffff" özel biçim belirticisi (yedi "f" karakteriyle birlikte), saniyenin on milyonda biri (veya kesir sayısı) bir zaman aralığında çıktı.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. TimeSpan.ParseExact veya TimeSpan.TryParseExact yöntemini çağıran bir ayrıştırma işleminde, giriş dizesinin tam olarak yedi kesirli basamak içermesi gerekir.In a parsing operation that calls the TimeSpan.ParseExact or TimeSpan.TryParseExact method, the input string must contain exactly seven fractional digits.

Aşağıdaki örnek, bir TimeSpan değerindeki onay işareti sayısını göstermek için "fffffff" özel biçim belirticisini kullanır.The following example uses the "fffffff" custom format specifier to display the fractional number of ticks in a TimeSpan value. İlk olarak tek Biçim belirleyicisi olarak kullanılır ve ardından özel bir biçim dizesinde "s" belirticisi ile birleştirilir.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

Tabloya dönBack to table

"F" Özel Biçim belirleyicisiThe "F" custom format specifier

"F" özel biçim belirticisi bir saniyenin onda birini bir zaman aralığında verir.The "F" custom format specifier outputs the tenths of a second in a time interval. Biçimlendirme işleminde, kalan kesirli basamaklar kesilir.In a formatting operation, any remaining fractional digits are truncated. Saniyenin ondaki zaman aralığı değeri sıfırsa, sonuç dizesine dahil değildir.If the value of the time interval's tenths of a second is zero, it isn't included in the result string. TimeSpan.ParseExact veya TimeSpan.TryParseExact yöntemini çağıran bir ayrıştırma işleminde, ikinci bir basamağın onunun varlığı isteğe bağlıdır.In a parsing operation that calls the TimeSpan.ParseExact or TimeSpan.TryParseExact method, the presence of the tenths of a second digit is optional.

"F" Özel Biçim belirleyicisi tek başına kullanılırsa, standart biçim dizesi olarak yanlış yorumlanmaması için "% F" belirtin.If the "F" custom format specifier is used alone, specify "%F" so that it isn't misinterpreted as a standard format string.

Aşağıdaki örnek, bir TimeSpan değerinde saniyenin onda birini göstermek için "F" özel biçim belirticisini kullanır.The following example uses the "F" custom format specifier to display the tenths of a second in a TimeSpan value. Bu özel biçim belirticisini bir ayrıştırma işleminde de kullanır.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'.      

Tabloya dönBack to table

"FF" Özel Biçim belirleyicisiThe "FF" custom format specifier

"FF" özel biçim belirticisi saniye cinsinden bir zaman aralığına çıkış verir.The "FF" custom format specifier outputs the hundredths of a second in a time interval. Biçimlendirme işleminde, kalan kesirli basamaklar kesilir.In a formatting operation, any remaining fractional digits are truncated. Sondaki kesirli sıfırları varsa, sonuç dizesine dahil edilmez.If there are any trailing fractional zeros, they aren't included in the result string. TimeSpan.ParseExact veya TimeSpan.TryParseExact yöntemini çağıran bir ayrıştırma işleminde, ikinci bir basamağın onun ve yüzde birinin varlığı isteğe bağlıdır.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.

Aşağıdaki örnek, bir TimeSpan değerindeki saniyenin yüzde birini göstermek için "FF" özel biçim belirticisini kullanır.The following example uses the "FF" custom format specifier to display the hundredths of a second in a TimeSpan value. Bu özel biçim belirticisini bir ayrıştırma işleminde de kullanır.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'.

Tabloya dönBack to table

"FFF" Özel Biçim belirleyicisiThe "FFF" custom format specifier

"FFF" özel biçim Belirleyicisi (üç "F" karakteri ile), bir zaman aralığındaki milisaniyeyi verir.The "FFF" custom format specifier (with three "F" characters) outputs the milliseconds in a time interval. Biçimlendirme işleminde, kalan kesirli basamaklar kesilir.In a formatting operation, any remaining fractional digits are truncated. Sondaki kesirli sıfırları varsa, sonuç dizesine dahil edilmez.If there are any trailing fractional zeros, they aren't included in the result string. TimeSpan.ParseExact veya TimeSpan.TryParseExact yöntemini çağıran bir ayrıştırma işleminde, ikinci bir basamağın onda, yüzde ve binde varlığı isteğe bağlıdır.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.

Aşağıdaki örnek, bir TimeSpan değerindeki bir saniyenin binde göstermek için "FFF" özel biçim belirticisini kullanır.The following example uses the "FFF" custom format specifier to display the thousandths of a second in a TimeSpan value. Bu özel biçim belirticisini bir ayrıştırma işleminde de kullanır.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'.

Tabloya dönBack to table

"FFFF" Özel Biçim belirleyicisiThe "FFFF" custom format specifier

"FFFF" özel biçim belirticisi (dört "F" karakterle birlikte), bir zaman aralığında saniyenin on-binde sayısını verir.The "FFFF" custom format specifier (with four "F" characters) outputs the ten-thousandths of a second in a time interval. Biçimlendirme işleminde, kalan kesirli basamaklar kesilir.In a formatting operation, any remaining fractional digits are truncated. Sondaki kesirli sıfırları varsa, sonuç dizesine dahil edilmez.If there are any trailing fractional zeros, they aren't included in the result string. TimeSpan.ParseExact veya TimeSpan.TryParseExact yöntemini çağıran bir ayrıştırma işleminde, ikinci bir basamağın onda, yüzde, binde ve on-binde bulunması isteğe bağlıdır.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.

Aşağıdaki örnek, bir TimeSpan değerindeki bir saniyenin on-binde ' unu göstermek için "FFFF" özel biçim belirticisini kullanır.The following example uses the "FFFF" custom format specifier to display the ten-thousandths of a second in a TimeSpan value. Ayrıca, bir ayrıştırma işleminde "FFFF" özel biçim belirticisini kullanır.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'.

Tabloya dönBack to table

"FFFFF" Özel Biçim belirleyicisiThe "FFFFF" custom format specifier

"FFFFF" özel biçim Belirleyicisi (beş "F" karakterle birlikte), bir zaman aralığındaki yüz-binde ' i gösterir.The "FFFFF" custom format specifier (with five "F" characters) outputs the hundred-thousandths of a second in a time interval. Biçimlendirme işleminde, kalan kesirli basamaklar kesilir.In a formatting operation, any remaining fractional digits are truncated. Sondaki kesirli sıfırları varsa, sonuç dizesine dahil edilmez.If there are any trailing fractional zeros, they aren't included in the result string. TimeSpan.ParseExact veya TimeSpan.TryParseExact yöntemini çağıran bir ayrıştırma işleminde, ikinci bir basamağın onda, yüzde, binde, on-binde ve yüz-binde varlığı isteğe bağlıdır.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.

Aşağıdaki örnek, bir TimeSpan değerinde saniyenin yüz binde ' ni göstermek için "FFFFF" özel biçim belirticisini kullanır.The following example uses the "FFFFF" custom format specifier to display the hundred-thousandths of a second in a TimeSpan value. Ayrıca bir ayrıştırma işleminde "FFFFF" özel biçim belirticisini kullanır.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'.

Tabloya dönBack to table

"FFFFFF" Özel Biçim belirleyicisiThe "FFFFFF" custom format specifier

"FFFFFF" özel biçim Belirleyicisi (altı "F" karakteriyle birlikte), bir zaman aralığında saniyenin her birinin milionda çıkışını çıkarır.The "FFFFFF" custom format specifier (with six "F" characters) outputs the millionths of a second in a time interval. Biçimlendirme işleminde, kalan kesirli basamaklar kesilir.In a formatting operation, any remaining fractional digits are truncated. Sondaki kesirli sıfırları varsa, sonuç dizesine dahil edilmez.If there are any trailing fractional zeros, they aren't included in the result string. TimeSpan.ParseExact veya TimeSpan.TryParseExact yöntemini çağıran bir ayrıştırma işleminde, ikinci bir basamağın onda, yüzde, binde, on-binde, yüz-binde ve milionon 'un varlığı isteğe bağlıdır.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.

Aşağıdaki örnek, bir TimeSpan değerindeki bir saniyenin milionkesini göstermek için "FFFFFF" özel biçim belirticisini kullanır.The following example uses the "FFFFFF" custom format specifier to display the millionths of a second in a TimeSpan value. Bu özel biçim belirticisini bir ayrıştırma işleminde de kullanır.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'.

Tabloya dönBack to table

"FFFFFFF" Özel Biçim belirleyicisiThe "FFFFFFF" custom format specifier

"FFFFFFF" özel biçim belirticisi (yedi "F" karakteriyle birlikte), saniyenin on milyonda biri (veya kesir sayısı) bir zaman aralığında çıktı.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. Sondaki kesirli sıfırları varsa, sonuç dizesine dahil edilmez.If there are any trailing fractional zeros, they aren't included in the result string. TimeSpan.ParseExact veya TimeSpan.TryParseExact yöntemini çağıran bir ayrıştırma işleminde, giriş dizesindeki yedi kesirli basamakların varlığı isteğe bağlıdır.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.

Aşağıdaki örnek, bir TimeSpan değerindeki bir saniyenin kesirli parçalarını göstermek için "FFFFFFF" özel biçim belirticisini kullanır.The following example uses the "FFFFFFF" custom format specifier to display the fractional parts of a second in a TimeSpan value. Bu özel biçim belirticisini bir ayrıştırma işleminde de kullanır.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     

Tabloya dönBack to table

Diğer karakterlerOther characters

Bir biçim dizesindeki bir boşluk karakteri de dahil olmak üzere herhangi bir kaçış karakteri özel Biçim belirleyicisi olarak yorumlanır.Any other unescaped character in a format string, including a white-space character, is interpreted as a custom format specifier. Çoğu durumda, başka bir kaçışsız karakter bulunması FormatExceptionoluşur.In most cases, the presence of any other unescaped character results in a FormatException.

Biçim dizesine bir sabit karakter dahil etmenin iki yolu vardır:There are two ways to include a literal character in a format string:

  • Tek tırnak işareti (sabit dize sınırlayıcısı) içine alın.Enclose it in single quotation marks (the literal string delimiter).

  • Kaçış karakteri olarak yorumlanan bir ters eğik çizgiyle ("\") önüne koyun.Precede it with a backslash ("\"), which is interpreted as an escape character. Bu, içinde C#biçim dizesinin @-quotedolması veya sabit karakterin önünde ek bir ters eğik çizgi olması gerektiği anlamına gelir.This means that, in C#, the format string must either be @-quoted, or the literal character must be preceded by an additional backslash.

    Bazı durumlarda, bir biçim dizesine kaçan değişmez değer eklemek için koşullu mantığı kullanmanız gerekebilir.In some cases, you may have to use conditional logic to include an escaped literal in a format string. Aşağıdaki örnek, negatif zaman aralıkları için bir işaret simgesi eklemek üzere koşullu mantığı kullanır.The following example uses conditional logic to include a sign symbol for negative time intervals.

    using System;
    
    public class Example
    {
       public static void Main()
       {
          TimeSpan result = new DateTime(2010, 01, 01) - DateTime.Now; 
          String fmt = (result < TimeSpan.Zero ?  "\\-" : "") + "dd\\.hh\\:mm";
          
          Console.WriteLine(result.ToString(fmt));
          Console.WriteLine("Interval: {0:" + fmt + "}", result);
       }
    }
    // The example displays output like the following:
    //       -1291.10:54
    //       Interval: -1291.10:54
    
    Module Example
       Public Sub Main()
          Dim result As TimeSpan = New DateTime(2010, 01, 01) - Date.Now 
          Dim fmt As String = If(result < TimeSpan.Zero, "\-", "") + "dd\.hh\:mm"
          
          Console.WriteLine(result.ToString(fmt))
          Console.WriteLine("Interval: {0:" + fmt + "}", result)
       End Sub
    End Module
    ' The example displays output like the following:
    '       -1291.10:54
    '       Interval: -1291.10:54
    

.NET, zaman aralıklarında ayırıcılar için dilbilgisi tanımlamaz..NET doesn't define a grammar for separators in time intervals. Bu, gün ve saat, saat ve dakika, dakika ve saniye ve saniye ile kesirleri arasındaki ayırıcıların hepsi bir biçim dizesinde karakter sabit değeri olarak değerlendirilmelidir.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.

Aşağıdaki örnek, çıkış dizesinde "Minutes" sözcüğünü içeren bir özel biçim dizesi tanımlamak için hem kaçış karakteri hem de tek tırnak kullanır.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      

Tabloya dönBack to table

Ayrıca bkz.See also