Aracılığıyla paylaş

Özel TimeSpan biçim dizeleri

  • Makale

TimeSpan biçim dizesi, biçimlendirme işleminden kaynaklanan bir TimeSpan değerinin dize gösterimini tanımlar. Özel biçim dizesi, herhangi bir sayıda değişmez karakterle birlikte bir veya daha fazla özel TimeSpan biçim tanımlayıcılarından oluşur. Standart TimeSpan biçim dizesi olmayan tüm dizeler özel TimeSpan biçim dizesi olarak yorumlanır.

Önemli

Özel TimeSpan biçim tanımlayıcıları, saatleri saatlerden, dakikalardan saatlere veya saniyeleri kesirli saniyelerden ayıran simgeler gibi yer tutucu ayırıcı simgeleri içermez. Bunun yerine, bu simgeler özel biçim dizesine dize değişmez değerleri olarak eklenmelidir. Örneğin, "dd\.hh\:mm" günler ve saatler arasında ayırıcı olarak bir nokta (.) ve saat ile dakikalar arasında ayırıcı olarak iki nokta (:)) tanımlar.

Özel TimeSpan biçim tanımlayıcıları, negatif ve pozitif zaman aralıklarını ayırt etmenizi sağlayan bir işaret simgesi de içermez. İşaret simgesi eklemek için, koşullu mantık kullanarak bir biçim dizesi oluşturmanız gerekir. Diğer karakterler bölümü bir örnek içerir.

TimeSpan değerlerin dize gösterimleri, TimeSpan.ToString yönteminin aşırı yüklemelerine çağrılar ve String.Formatgibi bileşik biçimlendirmeyi destekleyen yöntemler tarafından oluşturulur. Daha fazla bilgi için bkz. Biçimlendirme Türleri ve bileşik biçimlendirme . Aşağıdaki örnekte, biçimlendirme işlemlerinde özel biçim dizelerinin kullanımı gösterilmektedir.

using System;

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

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

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

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

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

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

Özel TimeSpan biçim dizeleri, ayrıştırma işlemleri için gerekli giriş dizelerinin biçimini tanımlamak için TimeSpan.ParseExact ve TimeSpan.TryParseExact yöntemleri tarafından da kullanılır. (Ayrıştırma, bir değerin dize gösterimini 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östermektedir.

using System;

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

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

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

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

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

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

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

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

Aşağıdaki tabloda özel tarih ve saat biçimi tanımlayıcıları açıklanmaktadır.

Biçim tanımlayıcısı Açıklama Örnek
"d", "%d" Zaman aralığındaki tam gün sayısı.

Daha fazla bilgi: "d" özel biçim tanımlayıcısı.		 new TimeSpan(6, 14, 32, 17, 685):

%d --> "6"

d\.hh\:mm --> "6.14:32"
"dd"-"ddddddddd" Zaman aralığındaki, gerektiğinde baştaki sıfırlarla doldurulmuş tam gün sayısı.

Daha fazla bilgi: "dd"-"dddddddd" özel biçim tanımlayıcıları.		 new TimeSpan(6, 14, 32, 17, 685):

ddd --> "006"

dd\.hh\:mm --> "06.14:32"
"h", "%h" Günlerin bir parçası olarak sayılan zaman aralığındaki tam saat sayısı. Tek basamaklı saatlerin başında sıfır yoktur.

Daha fazla bilgi: "h" özel biçim tanımlayıcısı.		 new TimeSpan(6, 14, 32, 17, 685):

%h --> "14"

hh\:mm --> "14:32"
hh Günlerin bir parçası olarak sayılan zaman aralığındaki tam saat sayısı. Tek basamaklı saatlerin başında sıfır vardır.

Daha fazla bilgi: "hh" özel biçim tanımlayıcısı.		 new TimeSpan(6, 14, 32, 17, 685):

hh --> "14"

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

hh --> 08
"m", "%m" Saat veya günlerin parçası olarak dahil olmayan zaman aralığındaki tam dakika sayısı. Tek basamaklı dakikaların başında sıfır yoktur.

Daha fazla bilgi: "m" özel biçim tanımlayıcısı.		 new TimeSpan(6, 14, 8, 17, 685):

%m --> "8"

h\:m --> "14:8"
"mm" Saat veya günlerin parçası olarak dahil olmayan zaman aralığındaki tam dakika sayısı. Tek basamaklı dakikaların başında sıfır vardır.

Daha fazla bilgi: "mm" özel biçim tanımlayıcısı.		 new TimeSpan(6, 14, 8, 17, 685):

mm --> "08"

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

d\.hh\:mm\:ss --> 6.08:05:17
"s", "%s" Saat, gün veya dakika parçası olarak dahil olmayan zaman aralığındaki tam saniye sayısı. Tek basamaklı saniyelerin başında sıfır yoktur.

Daha fazla bilgi: "s" özel biçim tanımlayıcısı.		 TimeSpan.FromSeconds(12.965):

%s --> 12

s\.fff --> 12.965
"ss" Saat, gün veya dakika parçası olarak dahil olmayan zaman aralığındaki tam saniye sayısı. Tek basamaklı saniyelerin başında sıfır vardır.

Daha fazla bilgi: "ss" özel biçim tanımlayıcısı.		 TimeSpan.FromSeconds(6.965):

ss --> 06

ss\.fff --> 06.965
"f", "%f" Bir zaman aralığında saniyenin onda biri.

Daha fazla bilgi: "f" özel biçim tanımlayıcısı.		 TimeSpan.FromSeconds(6.895):

f --> 8

ss\.f --> 06.8
"ff" Bir zaman aralığında saniyenin yüzde biri.

Daha fazla bilgi: "ff" özel biçim tanımlayıcısı.		 TimeSpan.FromSeconds(6.895):

ff --> 89

ss\.ff --> 06.89
"fff" Bir zaman aralığındaki milisaniye.

Daha fazla bilgi: "fff" özel biçim tanımlayıcısı.		 TimeSpan.FromSeconds(6.895):

fff --> 895

ss\.fff --> 06.895
"ffff" Bir zaman aralığında saniyenin on binde biri.

Daha fazla bilgi: "ffff" özel biçim tanımlayıcısı.		 TimeSpan.Parse("0:0:6.8954321"):

ffff --> 8954

ss\.ffff --> 06.8954
"fffff" Bir zaman aralığında saniyenin yüz binde biri.

Daha fazla bilgi: "fffff" özel biçim tanımlayıcısı.		 TimeSpan.Parse("0:0:6.8954321"):

fffff --> 89543

ss\.fffff --> 06.89543
"ffffff" Bir zaman aralığında saniyenin milyonda biri.

Daha fazla bilgi: "ffffff" özel biçim tanımlayıcısı.		 TimeSpan.Parse("0:0:6.8954321"):

ffffff --> 895432

ss\.ffffff --> 06.895432
"fffffff" Bir zaman aralığında saniyenin on milyonda biri (veya kesirli değer sayısı).

Daha fazla bilgi: "fffffff" özel biçim tanımlayıcısı.		 TimeSpan.Parse("0:0:6.8954321"):

fffffff --> 8954321

ss\.fffffff --> 06.8954321
"F", "%F" Bir zaman aralığında saniyenin onda biri. Basamak sıfır olduğunda hiçbir şey görüntülenmez.

Daha fazla bilgi: "F" özel biçim tanımlayıcısı.		 TimeSpan.Parse("00:00:06.32"):

%F: 3

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

ss\.F: 03.
"FF" Bir zaman aralığında saniyenin yüzde biri. Kesirli sondaki sıfırlar veya iki sıfır basamak dahil değildir.

Daha fazla bilgi: "FF" özel biçim tanımlayıcısı.		 TimeSpan.Parse("00:00:06.329"):

FF: 32

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

ss\.FF: 03.1
"FFF" Bir zaman aralığındaki milisaniye. Kesirli sondaki sıfırlar dahil değildir.

Daha fazla bilgi:		 TimeSpan.Parse("00:00:06.3291"):

FFF: 329

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

ss\.FFF: 03.1
"FFFF" Bir zaman aralığında saniyenin on binde biri. Kesirli sondaki sıfırlar dahil değildir.

Daha fazla bilgi: "FFFF" özel biçim tanımlayıcısı.		 TimeSpan.Parse("00:00:06.32917"):

FFFFF: 3291

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

ss\.FFFF: 03.1
"FFFFF" Bir zaman aralığında saniyenin yüz binde biri. Kesirli sondaki sıfırlar dahil değildir.

Daha fazla bilgi: "FFFFF" özel biçim tanımlayıcısı.		 TimeSpan.Parse("00:00:06.329179"):

FFFFF: 32917

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

ss\.FFFFF: 03.1
"FFFFFF" Bir zaman aralığında saniyenin milyonda biri. Kesirli sondaki sıfırlar görüntülenmez.

Daha fazla bilgi: "FFFFFF" özel biçim tanımlayıcısı.		 TimeSpan.Parse("00:00:06.3291791"):

FFFFFF: 329179

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

ss\.FFFFFF: 03.1
"FFFFFFF" Bir zaman aralığındaki on milyon saniye. Kesirli sondaki sıfırlar veya yedi sıfır görüntülenmez.

Daha fazla bilgi: "FFFFFFF" özel biçim tanımlayıcısı.		 TimeSpan.Parse("00:00:06.3291791"):

FFFFFF: 3291791

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

ss\.FFFFFF: 03.19
'string' Değişmez dize sınırlayıcısı.

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

hh':'mm':'ss --> "14:32:17"
\ Kaçış karakteri.

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

hh\:mm\:ss --> "14:32:17"
Başka bir karakter Diğer tüm sıralanmamış karakterler özel biçim tanımlayıcısı olarak yorumlanır.

Daha Fazla Bilgi: Diğer karakterler.		 new TimeSpan(14, 32, 17):

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

"d" özel biçim tanımlayıcısı

"d" özel biçim tanımlayıcısı, zaman aralığındaki tam gün sayısını temsil eden TimeSpan.Days özelliğinin değerini verir. Değerin birden fazla basama sahip olsa bile TimeSpan bir değerdeki gün sayısının tamamını verir. TimeSpan.Days özelliğinin değeri sıfırsa, tanımlayıcı "0" çıkışını verir.

"d" özel biçim belirticisi tek başına kullanılıyorsa, standart biçim dizesi olarak yanlış anlaşılmaması için "%d" değerini belirtin. Aşağıdaki örnek, bir gösterim sağlar.

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 örnekte "d" özel biçim tanımlayıcısının kullanımı gösterilmektedir.

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 geri dön

"dd"-"dddddddd" özel biçim tanımlayıcıları

"dd", "ddd", "dddd", "ddd", "ddd", "dd" ve "ddd" özel biçim tanımlayıcıları, zaman aralığındaki tam gün sayısını temsil eden TimeSpan.Days özelliğinin değerini verir.

Çıkış dizesi, biçim belirticisindeki "d" karakter sayısıyla belirtilen en az basamak sayısını içerir ve gerektiğinde baştaki sıfırlarla doldurulur. Gün sayısındaki basamaklar biçim belirticisindeki "d" karakter sayısını aşarsa, sonuç dizesinde tam gün sayısı verilir.

Aşağıdaki örnek, iki TimeSpan değerinin dize gösterimini görüntülemek için bu biçim tanımlayıcılarını kullanır. İlk zaman aralığının days bileşeninin değeri sıfırdır; saniyenin days bileşeninin değeri 365'tir.

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

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

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

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

Tabloya geri dön

"h" özel biçim tanımlayıcısı

"h" özel biçim tanımlayıcısı, TimeSpan.Hours özelliğinin değerini verir. Bu değer, gün bileşeninin bir parçası olarak sayılan zaman aralığındaki tam saat sayısını temsil eder. TimeSpan.Hours özelliğinin değeri 0 ile 9 arasındaysa tek basamaklı bir dize değeri döndürür ve TimeSpan.Hours özelliğinin değeri 10 ile 23 arasındaysa iki basamaklı bir dize değeri döndürür.

"h" özel biçim tanımlayıcısı tek başına kullanılıyorsa, standart biçim dizesi olarak yanlış yorumlanmıyor olması için "%h" değerini belirtin. Aşağıdaki örnek, bir gösterim sağlar.

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

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

Normalde, ayrıştırma işleminde yalnızca tek bir sayı içeren bir giriş dizesi gün sayısı olarak yorumlanır. Sayısal dizeyi saat sayısı olarak yorumlamak için bunun yerine "%h" özel biçim tanımlayıcısını kullanabilirsiniz. Aşağıdaki örnek, bir gösterim sağlar.

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

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

Aşağıdaki örnekte "h" özel biçim tanımlayıcısının kullanımı gösterilmektedir.

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 geri dön

"hh" özel biçim tanımlayıcısı

"hh" özel biçim tanımlayıcısı, TimeSpan.Hours özelliğinin değerini verir. Bu değer, gün bileşeninin bir parçası olarak sayılan zaman aralığındaki tam saat sayısını temsil eder. 0 ile 9 arasında değerler için çıkış dizesi baştaki sıfırı içerir.

Normalde, ayrıştırma işleminde yalnızca tek bir sayı içeren bir giriş dizesi gün sayısı olarak yorumlanır. Sayısal dizeyi saat sayısı olarak yorumlamak için bunun yerine "hh" özel biçim tanımlayıcısını kullanabilirsiniz. Aşağıdaki örnek, bir gösterim sağlar.

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

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

Aşağıdaki örnekte "hh" özel biçim tanımlayıcısının kullanımı gösterilmektedir.

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 geri dön

"m" özel biçim tanımlayıcısı

"m" özel biçim tanımlayıcısı, TimeSpan.Minutes özelliğinin değerini verir. Bu değer, gün bileşeninin bir parçası olarak sayılan zaman aralığındaki tam dakika sayısını temsil eder. TimeSpan.Minutes özelliğinin değeri 0 ile 9 arasındaysa tek basamaklı bir dize değeri döndürür ve TimeSpan.Minutes özelliğinin değeri 10 ile 59 arasındaysa iki basamaklı bir dize değeri döndürür.

"m" özel biçim belirticisi tek başına kullanılıyorsa, standart biçim dizesi olarak yanlış anlaşılmaması için "%m" değerini belirtin. Aşağıdaki örnek, bir gösterim sağlar.

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

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

Normalde, ayrıştırma işleminde yalnızca tek bir sayı içeren bir giriş dizesi gün sayısı olarak yorumlanır. Sayısal dizeyi dakika sayısı olarak yorumlamak için bunun yerine "%m" özel biçim tanımlayıcısını kullanabilirsiniz. Aşağıdaki örnek, bir gösterim sağlar.

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

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

Aşağıdaki örnekte "m" özel biçim tanımlayıcısının kullanımı gösterilmektedir.

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

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

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

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

Tabloya geri dön

"mm" özel biçim tanımlayıcısı

"mm" özel biçim tanımlayıcısı, saat veya gün bileşeninin parçası olarak dahil olmayan zaman aralığındaki tam dakika sayısını temsil eden TimeSpan.Minutes özelliğinin değerini verir. 0 ile 9 arasında değerler için çıkış dizesi baştaki sıfırı içerir.

Normalde, ayrıştırma işleminde yalnızca tek bir sayı içeren bir giriş dizesi gün sayısı olarak yorumlanır. Sayısal dizeyi dakika sayısı olarak yorumlamak için bunun yerine "mm" özel biçim tanımlayıcısını kullanabilirsiniz. Aşağıdaki örnek, bir gösterim sağlar.

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

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

Aşağıdaki örnekte "mm" özel biçim tanımlayıcısının kullanımı gösterilmektedir.

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

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

Tabloya geri dön

"s" özel biçim tanımlayıcısı

"s" özel biçim tanımlayıcısı, saat, gün veya dakika bileşeninin parçası olarak dahil olmayan zaman aralığındaki tam saniye sayısını temsil eden TimeSpan.Seconds özelliğinin değerini verir. TimeSpan.Seconds özelliğinin değeri 0 ile 9 arasındaysa tek basamaklı bir dize değeri döndürür ve TimeSpan.Seconds özelliğinin değeri 10 ile 59 arasındaysa iki basamaklı bir dize değeri döndürür.

"s" özel biçim belirticisi tek başına kullanılıyorsa, standart biçim dizesi olarak yanlış anlaşılmaması için "%s" değerini belirtin. Aşağıdaki örnek, bir gösterim sağlar.

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

Normalde, ayrıştırma işleminde yalnızca tek bir sayı içeren bir giriş dizesi gün sayısı olarak yorumlanır. Sayısal dizeyi saniye sayısı olarak yorumlamak için bunun yerine "%s" özel biçim tanımlayıcısını kullanabilirsiniz. Aşağıdaki örnek, bir gösterim sağlar.

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

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

Aşağıdaki örnekte "s" özel biçim tanımlayıcısının kullanımı gösterilmektedir.

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 geri dön

"ss" özel biçim tanımlayıcısı

"ss" özel biçim tanımlayıcısı, saat, gün veya dakika bileşeninin parçası olarak dahil olmayan zaman aralığındaki tam saniye sayısını temsil eden TimeSpan.Seconds özelliğinin değerini verir. 0 ile 9 arasında değerler için çıkış dizesi baştaki sıfırı içerir.

Normalde, ayrıştırma işleminde yalnızca tek bir sayı içeren bir giriş dizesi gün sayısı olarak yorumlanır. Sayısal dizeyi saniye sayısı olarak yorumlamak için bunun yerine "ss" özel biçim tanımlayıcısını kullanabilirsiniz. Aşağıdaki örnek, bir gösterim sağlar.

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

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

Aşağıdaki örnekte "ss" özel biçim tanımlayıcısının kullanımı gösterilmektedir.

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 geri dön

"f" özel biçim tanımlayıcısı

"f" özel biçim tanımlayıcısı bir zaman aralığında saniyenin onda birini oluşturur. Biçimlendirme işleminde kalan kesirli basamaklar kesilir. TimeSpan.ParseExact veya TimeSpan.TryParseExact yöntemini çağıran bir ayrıştırma işleminde, giriş dizesi tam olarak bir kesirli basamak içermelidir.

"f" özel biçim tanımlayıcısı tek başına kullanılıyorsa, standart biçim dizesi olarak yanlış yorumlanmıyor olması için "%f" belirtin.

Aşağıdaki örnek, bir TimeSpan değerinde saniyenin onda birini görüntülemek için "f" özel biçim tanımlayıcısını kullanır. "f" önce tek biçim tanımlayıcısı olarak kullanılır ve ardından özel biçim dizesinde "s" tanımlayıcısı ile birleştirilir.

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

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

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

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

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

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

Tabloya geri dön

"ff" özel biçim tanımlayıcısı

"ff" özel biçim tanımlayıcısı bir zaman aralığında saniyenin yüzde birini oluşturur. Biçimlendirme işleminde kalan kesirli basamaklar kesilir. TimeSpan.ParseExact veya TimeSpan.TryParseExact yöntemini çağıran bir ayrıştırma işleminde, giriş dizesi tam olarak iki kesirli basamak içermelidir.

Aşağıdaki örnek, TimeSpan bir değerde saniyenin yüzde birini görüntülemek için "ff" özel biçim tanımlayıcısını kullanır. "ff" önce tek biçim tanımlayıcısı olarak kullanılır ve ardından özel biçim dizesinde "s" tanımlayıcısıyla birleştirilir.

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

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

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

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

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

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

Tabloya geri dön

"fff" özel biçim tanımlayıcısı

"fff" özel biçim tanımlayıcısı (üç "f" karakteriyle), milisaniyeleri bir zaman aralığında çıkarır. Biçimlendirme işleminde kalan kesirli basamaklar kesilir. TimeSpan.ParseExact veya TimeSpan.TryParseExact yöntemini çağıran bir ayrıştırma işleminde, giriş dizesi tam olarak üç kesirli basamak içermelidir.

Aşağıdaki örnek, milisaniyeleri TimeSpan bir değerde görüntülemek için "fff" özel biçim tanımlayıcısını kullanır. "fff" önce tek biçim tanımlayıcısı olarak kullanılır ve ardından özel biçim dizesinde "s" tanımlayıcısı ile birleştirilir.

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

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

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

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

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

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

Tabloya geri dön

"ffff" özel biçim tanımlayıcısı

"ffff" özel biçim tanımlayıcısı (dört "f" karakteriyle), saniyenin on binde birini zaman aralığında çıkarır. Biçimlendirme işleminde kalan kesirli basamaklar kesilir. TimeSpan.ParseExact veya TimeSpan.TryParseExact yöntemini çağıran bir ayrıştırma işleminde, giriş dizesi tam olarak dört kesirli basamak içermelidir.

Aşağıdaki örnek, bir TimeSpan değerinde saniyenin on binde birini görüntülemek için "ffff" özel biçim tanımlayıcısını kullanır. "ffff" önce tek biçim tanımlayıcısı olarak kullanılır ve ardından özel biçim dizesinde "s" tanımlayıcısı ile birleştirilir.

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

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

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

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

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

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

Tabloya geri dön

"fffff" özel biçim tanımlayıcısı

"fffff" özel biçim tanımlayıcısı (beş "f" karakteriyle), bir zaman aralığında saniyenin yüz binde birini çıkarır. Biçimlendirme işleminde kalan kesirli basamaklar kesilir. TimeSpan.ParseExact veya TimeSpan.TryParseExact yöntemini çağıran bir ayrıştırma işleminde, giriş dizesi tam olarak beş kesirli basamak içermelidir.

Aşağıdaki örnek, bir saniyenin yüz binde birini TimeSpan bir değerde görüntülemek için "fffff" özel biçim tanımlayıcısını kullanır. "fffff" önce tek biçim tanımlayıcısı olarak kullanılır ve ardından özel biçim dizesinde "s" tanımlayıcısı ile birleştirilir.

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

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

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

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

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

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

Tabloya geri dön

"ffffff" özel biçim tanımlayıcısı

"ffffff" özel biçim tanımlayıcısı (altı "f" karakteriyle), bir zaman aralığında saniyenin milyonda birini çıkarır. Biçimlendirme işleminde kalan kesirli basamaklar kesilir. TimeSpan.ParseExact veya TimeSpan.TryParseExact yöntemini çağıran bir ayrıştırma işleminde, giriş dizesi tam olarak altı kesirli basamak içermelidir.

Aşağıdaki örnek, bir saniyenin milyonda birini TimeSpan bir değerde görüntülemek için "ffffff" özel biçim tanımlayıcısını kullanır. İlk olarak tek biçim tanımlayıcısı olarak kullanılır ve ardından özel biçim dizesinde "s" tanımlayıcısı ile birleştirilir.

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

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

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

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

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

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

Tabloya geri dön

"fffffff" özel biçim tanımlayıcısı

"fffffff" özel biçim tanımlayıcısı (yedi "f" karakteriyle), saniyenin on milyonda birini (veya kesirli değer sayısını) bir zaman aralığında verir. TimeSpan.ParseExact veya TimeSpan.TryParseExact yöntemini çağıran bir ayrıştırma işleminde, giriş dizesi tam olarak yedi kesirli basamak içermelidir.

Aşağıdaki örnek, bir TimeSpan değerindeki kesirli değer sayısını görüntülemek için "fffffff" özel biçim tanımlayıcısını kullanır. İlk olarak tek biçim tanımlayıcısı olarak kullanılır ve ardından özel biçim dizesinde "s" tanımlayıcısı ile birleştirilir.

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

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

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

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

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

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

Tabloya geri dön

"F" özel biçim tanımlayıcısı

"F" özel biçim tanımlayıcısı, bir zaman aralığında saniyenin onda birini oluşturur. Biçimlendirme işleminde kalan kesirli basamaklar kesilir. Zaman aralığının saniyenin onda biri değeri sıfırsa, sonuç dizesine dahil değildir. TimeSpan.ParseExact veya TimeSpan.TryParseExact yöntemini çağıran bir ayrıştırma işleminde, ikinci basamak onda birinin varlığı isteğe bağlıdır.

"F" özel biçim tanımlayıcısı tek başına kullanılıyorsa, standart biçim dizesi olarak yanlış yorumlanmıyor olması için "%F" belirtin.

Aşağıdaki örnek, saniyenin onda birini TimeSpan bir değerde görüntülemek için "F" özel biçim tanımlayıcısını kullanır. Ayrıştırma işleminde bu özel biçim tanımlayıcısını da kullanır.

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

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

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

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

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

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

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

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

Tabloya geri dön

"FF" özel biçim tanımlayıcısı

"FF" özel biçim tanımlayıcısı bir zaman aralığında saniyenin yüzde birini oluşturur. Biçimlendirme işleminde kalan kesirli basamaklar kesilir. Sondaki kesirli sıfırlar varsa, sonuç dizesine dahil değildir. TimeSpan.ParseExact veya TimeSpan.TryParseExact yöntemini çağıran bir ayrıştırma işleminde, ikinci bir basanın onda birinin ve yüzde birinin varlığı isteğe bağlıdır.

Aşağıdaki örnek, bir saniyenin yüzde birini TimeSpan bir değerde görüntülemek için "FF" özel biçim tanımlayıcısını kullanır. Ayrıştırma işleminde bu özel biçim tanımlayıcısını da kullanır.

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

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

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

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

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

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

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

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

Tabloya geri dön

"FFF" özel biçim tanımlayıcısı

"FFF" özel biçim tanımlayıcısı (üç "F" karakteriyle), milisaniyeleri bir zaman aralığında çıkarır. Biçimlendirme işleminde kalan kesirli basamaklar kesilir. Sondaki kesirli sıfırlar varsa, sonuç dizesine dahil değildir. TimeSpan.ParseExact veya TimeSpan.TryParseExact yöntemini çağıran bir ayrıştırma işleminde, ikinci basamakta onuncu, yüzüncü ve binde birinin varlığı isteğe bağlıdır.

Aşağıdaki örnek, bir saniyenin binde birini TimeSpan bir değerde görüntülemek için "FFF" özel biçim tanımlayıcısını kullanır. Ayrıştırma işleminde bu özel biçim tanımlayıcısını da kullanır.

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

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

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

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

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

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

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

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

Tabloya geri dön

"FFFF" özel biçim tanımlayıcısı

"FFFF" özel biçim tanımlayıcısı (dört "F" karakteriyle), bir zaman aralığında saniyenin on binde birini çıkarır. Biçimlendirme işleminde kalan kesirli basamaklar kesilir. Sondaki kesirli sıfırlar varsa, sonuç dizesine dahil değildir. TimeSpan.ParseExact veya TimeSpan.TryParseExact yöntemini çağıran bir ayrıştırma işleminde, ikinci basamakta onuncu, yüzüncü, binci ve on binde birinin varlığı isteğe bağlıdır.

Aşağıdaki örnek, bir TimeSpan değerinde saniyenin on binde birini görüntülemek için "FFFF" özel biçim tanımlayıcısını kullanır. Ayrıştırma işleminde "FFFF" özel biçim tanımlayıcısını da kullanır.

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

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

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

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

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

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

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

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

Tabloya geri dön

"FFFFF" özel biçim tanımlayıcısı

"FFFFF" özel biçim tanımlayıcısı (beş "F" karakteriyle), bir zaman aralığında saniyenin yüz binde birini çıkarır. Biçimlendirme işleminde kalan kesirli basamaklar kesilir. Sondaki kesirli sıfırlar varsa, sonuç dizesine dahil değildir. TimeSpan.ParseExact veya TimeSpan.TryParseExact yöntemini çağıran bir ayrıştırma işleminde, ikinci basamakta onuncu, yüzüncü, binde biri, on binde biri ve yüz binde birinin varlığı isteğe bağlıdır.

Aşağıdaki örnek, bir saniyenin yüz binde birini TimeSpan bir değerde görüntülemek için "FFFFF" özel biçim tanımlayıcısını kullanır. Ayrıştırma işleminde "FFFFF" özel biçim tanımlayıcısını da kullanır.

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

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

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

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

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

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

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

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

Tabloya geri dön

"FFFFFF" özel biçim tanımlayıcısı

"FFFFFF" özel biçim tanımlayıcısı (altı "F" karakteriyle), bir zaman aralığında saniyenin milyonda birini çıkarır. Biçimlendirme işleminde kalan kesirli basamaklar kesilir. Sondaki kesirli sıfırlar varsa, sonuç dizesine dahil değildir. TimeSpan.ParseExact veya TimeSpan.TryParseExact yöntemini çağıran bir ayrıştırma işleminde, onuncu, yüzüncü, binde biri, on binde biri, yüz binde biri ve ikinci bir basının milyonda birinin varlığı isteğe bağlıdır.

Aşağıdaki örnek, bir saniyenin milyonda birini TimeSpan bir değerde görüntülemek için "FFFFFF" özel biçim tanımlayıcısını kullanır. Ayrıştırma işleminde bu özel biçim tanımlayıcısını da kullanır.

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

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

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

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

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

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

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

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

Tabloya geri dön

"FFFFFFF" özel biçim tanımlayıcısı

"FFFFFFF" özel biçim tanımlayıcısı (yedi "F" karakteriyle), saniyenin on milyonda birini (veya kesirli değer sayısını) bir zaman aralığında verir. Sondaki kesirli sıfırlar varsa, sonuç dizesine dahil değildir. TimeSpan.ParseExact veya TimeSpan.TryParseExact yöntemini çağıran bir ayrıştırma işleminde, giriş dizesindeki yedi kesirli basamağın varlığı isteğe bağlıdır.

Aşağıdaki örnek, saniyenin kesirli bölümlerini bir TimeSpan değerinde görüntülemek için "FFFFFFF" özel biçim tanımlayıcısını kullanır. Ayrıştırma işleminde bu özel biçim tanımlayıcısını da kullanır.

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

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

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

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

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

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

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

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

Tabloya geri dön

Diğer karakterler

Bir biçim dizesindeki boşluk karakteri de dahil olmak üzere diğer tüm sıralanmamış karakterler, özel biçim tanımlayıcısı olarak yorumlanır. Çoğu durumda, başka bir sıralanmamış karakterin varlığı bir FormatExceptionile sonuçlanabilir.

Biçim dizesine değişmez karakter eklemenin iki yolu vardır:

  • Tek tırnak içine alın (değişmez değer dizesi sınırlayıcısı).

  • Önüne kaçış karakteri olarak yorumlanan ters eğik çizgi ("\") koyun. Bu, C# dilinde biçim dizesinin @tırnak içine alınması veya değişmez karakterden önce ek bir ters eğik çizgi olması gerektiği anlamına gelir.

    Bazı durumlarda, bir biçim dizesine kaçış değişmez değeri eklemek için koşullu mantık kullanmanız gerekebilir. Aşağıdaki örnek, negatif zaman aralıkları için bir işaret simgesi eklemek için koşullu mantık kullanır.

    using System;

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

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

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

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

.NET, zaman aralıklarında ayırıcılar için dil bilgisi tanımlamaz. Bu, gün ve saat, saat ve dakika, dakika ve saniye arasındaki ayırıcıların ve saniye ile saniye kesirlerinin tümünün bir biçim dizesinde karakter değişmez değerleri olarak ele alınması gerektiği anlamına gelir.

Aşağıdaki örnekte çıkış dizesinde "minutes" sözcüğünü içeren özel bir biçim dizesi tanımlamak için hem kaçış karakteri hem de tek tırnak kullanılır.

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 geri dön

Ayrıca bkz.