Bagikan melalui

String format TimeSpan kustom

String format TimeSpan menentukan representasi string dari nilai TimeSpan yang dihasilkan dari operasi pemformatan. String format kustom terdiri dari satu atau beberapa penentu format TimeSpan kustom bersama dengan sejumlah karakter harfiah. String apa pun yang bukan string format rentang Waktu Standar ditafsirkan sebagai string format TimeSpan kustom.

Penting

Penentu format TimeSpan kustom tidak menyertakan simbol pemisah tempat penampung, seperti simbol yang memisahkan hari dari jam, jam dari menit, atau detik dari detik pecahan. Sebagai gantinya, simbol-simbol ini harus disertakan dalam string format kustom sebagai literal string. Misalnya, "dd\.hh\:mm" mendefinisikan titik (.) sebagai pemisah antara hari dan jam, dan titik dua (:) sebagai pemisah antara jam dan menit.

Penentu format TimeSpan kustom juga tidak menyertakan simbol tanda yang memungkinkan Anda membedakan antara interval waktu negatif dan positif. Untuk menyertakan simbol tanda, Anda harus membuat string format dengan menggunakan logika bersyarat. Bagian karakter Lainnya menyertakan contoh.

Representasi string dari nilai TimeSpan dihasilkan oleh panggilan ke kelebihan beban metode TimeSpan.ToString, dan dengan metode yang mendukung pemformatan komposit, seperti String.Format. Untuk informasi selengkapnya, lihat Tipe Pemformatan dan Pemformatan Komposit. Contoh berikut mengilustrasikan penggunaan string format kustom dalam operasi pemformatan.

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

String format TimeSpan kustom juga digunakan oleh metode TimeSpan.ParseExact dan TimeSpan.TryParseExact untuk menentukan format string input yang diperlukan untuk operasi penguraian. (Penguraian mengonversi representasi string dari nilai ke nilai tersebut.) Contoh berikut mengilustrasikan penggunaan string format standar dalam operasi penguraian.

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

Tabel berikut ini menjelaskan penentu format tanggal dan waktu kustom.

Penentu format Deskripsi Contoh
"d", "%d" Jumlah seluruh hari dalam interval waktu.

Informasi selengkapnya: Penentu format kustom "d".		 new TimeSpan(6, 14, 32, 17, 685):

%d --> "6"

d\.hh\:mm --> "6.14:32"
"dd"-"ddddddd" Jumlah seluruh hari dalam interval waktu, diisi dengan nol di depan sesuai kebutuhan.

Informasi selengkapnya: Penentu format kustom "dd"-"dddddddd".		 new TimeSpan(6, 14, 32, 17, 685):

ddd --> "006"

dd\.hh\:mm --> "06.14:32"
"h", "%h" Jumlah seluruh jam dalam interval waktu yang tidak dihitung sebagai bagian dari hari. Jam satu digit tidak memiliki nol di depannya.

Informasi selengkapnya: Penentu format kustom "h".		 new TimeSpan(6, 14, 32, 17, 685):

%h --> "14"

hh\:mm --> "14:32"
"hh" Jumlah seluruh jam dalam interval waktu yang tidak dihitung sebagai bagian dari hari. Jam satu digit memiliki nol di depannya.

Informasi selengkapnya: Penentu format kustom "hh".		 new TimeSpan(6, 14, 32, 17, 685):

hh --> "14"

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

hh --> 08
"m", "%m" Jumlah seluruh menit dalam interval waktu yang tidak disertakan sebagai bagian dari jam atau hari. Menit satu digit tidak memiliki nol di depannya.

Informasi selengkapnya: Penentu format kustom "m".		 new TimeSpan(6, 14, 8, 17, 685):

%m --> "8"

h\:m --> "14:8"
"mm" Jumlah seluruh menit dalam interval waktu yang tidak disertakan sebagai bagian dari jam atau hari. Menit satu digit memiliki nol di depannya.

Informasi selengkapnya: Penentu format kustom "mm".		 new TimeSpan(6, 14, 8, 17, 685):

mm --> "08"

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

d\.hh\:mm\:ss --> 6.08:05:17
"s", "%s" Jumlah seluruh detik dalam interval waktu yang tidak disertakan sebagai bagian dari jam, hari, atau menit. Detik satu digit tidak memiliki nol di depannya.

Informasi selengkapnya: Penentu format kustom "s".		 TimeSpan.FromSeconds(12.965):

%s --> 12

s\.fff --> 12.965
"ss" Jumlah seluruh detik dalam interval waktu yang tidak disertakan sebagai bagian dari jam, hari, atau menit. Detik satu digit memiliki nol di depannya.

Informasi selengkapnya: Penentu format kustom "ss".		 TimeSpan.FromSeconds(6.965):

ss --> 06

ss\.fff --> 06,965
"f", "%f" Persepuluh detik dalam interval waktu.

Informasi selengkapnya: Penentu format kustom "f".		 TimeSpan.FromSeconds(6.895):

f >-- 8

ss\.f --> 06,8
ff Seratus detik dalam interval waktu.

Informasi selengkapnya: Penentu format kustom "ff".		 TimeSpan.FromSeconds(6.895):

ff --> 89

ss\.ff --> 06,89
"fff" Milidetik dalam interval waktu.

Informasi selengkapnya: Penentu format kustom "fff".		 TimeSpan.FromSeconds(6.895):

fff --> 895

ss\.fff --> 06,895
"ffff" Sepuluh ribu detik dalam interval waktu.

Informasi selengkapnya: Penentu format kustom "ffff".		 TimeSpan.Parse("0:0:6.8954321"):

ffff --> 8954

ss\.ffff --> 06.8954
"fffff" Seratus ribu detik dalam interval waktu.

Informasi selengkapnya: Penentu format kustom "fffff".		 TimeSpan.Parse("0:0:6.8954321"):

fffff --> 89543

ss\.fffff --> 06.89543
"ffffff" Jutaan detik dalam interval waktu.

Informasi selengkapnya: Penentu format kustom "ffffff".		 TimeSpan.Parse("0:0:6.8954321"):

ffffff >-- 895432

ss\.ffffff --> 06.895432
"fffffff" Sepuluh juta detik (atau tanda centang pecahan) dalam interval waktu.

Informasi selengkapnya: Penentu format kustom "fffffff".		 TimeSpan.Parse("0:0:6.8954321"):

fffffff >-- 8954321

ss\.fffffff --> 06,8954321
"F", "%F" Persepuluh detik dalam interval waktu. Tidak ada yang ditampilkan jika digit adalah nol.

Informasi selengkapnya: Penentu format kustom "F".		 TimeSpan.Parse("00:00:06.32"):

%F: 3

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

ss\.F: 03.
"FF" Seratus detik dalam interval waktu. Nol berikutnya pecahan atau dua digit nol tidak disertakan.

Informasi selengkapnya: Penentu format kustom "FF".		 TimeSpan.Parse("00:00:06.329"):

FF: 32

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

ss\.FF: 03.1
"FFF" Milidetik dalam interval waktu. Nol berikutnya pecahan apa pun tidak disertakan.

Informasi selengkapnya:		 TimeSpan.Parse("00:00:06.3291"):

FFF: 329

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

ss\.FFF: 03.1
"FFFF" Sepuluh ribu detik dalam interval waktu. Nol berikutnya pecahan apa pun tidak disertakan.

Informasi selengkapnya: Penentu format kustom "FFFF".		 TimeSpan.Parse("00:00:06.32917"):

FFFFF: 3291

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

ss\.FFFF: 03.1
FFFFF Seratus ribu detik dalam interval waktu. Nol berikutnya pecahan apa pun tidak disertakan.

Informasi selengkapnya: Penentu format kustom "FFFFF".		 TimeSpan.Parse("00:00:06.329179"):

FFFFF: 32917

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

ss\.FFFFF: 03.1
FFFFFF Jutaan detik dalam interval waktu. Nol berikutnya pecahan apa pun tidak ditampilkan.

Informasi selengkapnya: Penentu format kustom "FFFFFF".		 TimeSpan.Parse("00:00:06.3291791"):

FFFFFF: 329179

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

ss\.FFFFFF: 03.1
"FFFFFFF" Sepuluh juta detik dalam interval waktu. Nol berikutnya pecahan atau tujuh nol tidak ditampilkan.

Informasi selengkapnya: Penentu format kustom "FFFFFFF".		 TimeSpan.Parse("00:00:06.3291791"):

FFFFFF: 3291791

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

ss\.FFFFFF: 03.19
'tali' Pemisah string harfiah.

Informasi selengkapnya: Karakter lain.		 new TimeSpan(14, 32, 17):

hh':'mm':'ss --> "14:32:17"
\ Karakter escape.

Informasi selengkapnya: Karakter lain.		 new TimeSpan(14, 32, 17):

hh\:mm\:ss --> "14:32:17"
Karakter lainnya Karakter lain yang tidak dilewati ditafsirkan sebagai penentu format kustom.

Informasi Selengkapnya: Karakter lain.		 new TimeSpan(14, 32, 17):

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

Penentu format kustom "d"

Penentu format kustom "d" menghasilkan nilai properti TimeSpan.Days, yang menunjukkan jumlah seluruh hari dalam interval waktu. Ini menghasilkan jumlah hari penuh dalam nilai TimeSpan, bahkan jika nilai memiliki lebih dari satu digit. Jika nilai properti TimeSpan.Days adalah nol, penentu menghasilkan "0".

Jika penentu format kustom "d" digunakan sendiri, tentukan "%d" sehingga tidak disalahartikan sebagai string format standar. Contoh berikut memberikan ilustrasi.

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

Contoh berikut mengilustrasikan penggunaan penentu format kustom "d".

TimeSpan ts2 = new TimeSpan(4, 3, 17);
Console.WriteLine(ts2.ToString(@"d\.hh\:mm\:ss"));

TimeSpan ts3 = new TimeSpan(3, 4, 3, 17);
Console.WriteLine(ts3.ToString(@"d\.hh\:mm\:ss"));
// The example displays the following output:
//       0.04:03:17
//       3.04:03:17

Dim ts2 As New TimeSpan(4, 3, 17)
Console.WriteLine(ts2.ToString("d\.hh\:mm\:ss"))

Dim ts3 As New TimeSpan(3, 4, 3, 17)
Console.WriteLine(ts3.ToString("d\.hh\:mm\:ss"))
' The example displays the following output:
'       0.04:03:17
'       3.04:03:17

Kembali ke tabel

Penentu format kustom "dd"-"ddddddd"

Penentu format kustom "dd", "dddd", "ddddd", "dddddd", "dddddd", dan "ddddddd" menghasilkan nilai properti TimeSpan.Days, yang mewakili jumlah seluruh hari dalam interval waktu.

String output mencakup jumlah minimum digit yang ditentukan oleh jumlah karakter "d" dalam penentu format, dan diisi dengan nol di depan sesuai kebutuhan. Jika digit dalam jumlah hari melebihi jumlah karakter "d" dalam penentu format, jumlah hari penuh adalah output dalam string hasil.

Contoh berikut menggunakan penentu format ini untuk menampilkan representasi string dari dua nilai TimeSpan. Nilai komponen hari dari interval pertama kali adalah nol; nilai komponen hari dari yang kedua adalah 365.

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

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

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

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

Kembali ke tabel

Penentu format kustom "h"

Penentu format kustom "h" menghasilkan nilai properti TimeSpan.Hours, yang menunjukkan jumlah seluruh jam dalam interval waktu yang tidak dihitung sebagai bagian dari komponen harinya. Ini mengembalikan nilai string satu digit jika nilai properti TimeSpan.Hours adalah 0 hingga 9, dan mengembalikan nilai string dua digit jika nilai properti TimeSpan.Hours berkisar antara 10 hingga 23.

Jika penentu format kustom "h" digunakan sendiri, tentukan "%h" sehingga tidak disalahartikan sebagai string format standar. Contoh berikut memberikan ilustrasi.

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

Biasanya, dalam operasi penguraian, string input yang hanya menyertakan satu angka ditafsirkan sebagai jumlah hari. Anda dapat menggunakan penentu format kustom "%h" sebagai gantinya untuk menginterpretasikan string numerik sebagai jumlah jam. Contoh berikut memberikan ilustrasi.

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

Contoh berikut mengilustrasikan penggunaan penentu format kustom "h".

TimeSpan ts1 = new TimeSpan(14, 3, 17);
Console.WriteLine(ts1.ToString(@"d\.h\:mm\:ss"));

TimeSpan ts2 = new TimeSpan(3, 4, 3, 17);
Console.WriteLine(ts2.ToString(@"d\.h\:mm\:ss"));
// The example displays the following output:
//       0.14:03:17
//       3.4:03:17

Dim ts1 As New TimeSpan(14, 3, 17)
Console.WriteLine(ts1.ToString("d\.h\:mm\:ss"))

Dim ts2 As New TimeSpan(3, 4, 3, 17)
Console.WriteLine(ts2.ToString("d\.h\:mm\:ss"))
' The example displays the following output:
'       0.14:03:17
'       3.4:03:17

Kembali ke tabel

Penentu format kustom "hh"

Penentu format kustom "hh" menghasilkan nilai properti TimeSpan.Hours, yang menunjukkan jumlah seluruh jam dalam interval waktu yang tidak dihitung sebagai bagian dari komponen harinya. Untuk nilai dari 0 hingga 9, string output menyertakan nol di depannya.

Biasanya, dalam operasi penguraian, string input yang hanya menyertakan satu angka ditafsirkan sebagai jumlah hari. Anda dapat menggunakan penentu format kustom "hh" sebagai gantinya untuk menginterpretasikan string numerik sebagai jumlah jam. Contoh berikut memberikan ilustrasi.

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

Contoh berikut mengilustrasikan penggunaan penentu format kustom "hh".

TimeSpan ts1 = new TimeSpan(14, 3, 17);
Console.WriteLine(ts1.ToString(@"d\.hh\:mm\:ss"));

TimeSpan ts2 = new TimeSpan(3, 4, 3, 17);
Console.WriteLine(ts2.ToString(@"d\.hh\:mm\:ss"));
// The example displays the following output:
//       0.14:03:17
//       3.04:03:17

Dim ts1 As New TimeSpan(14, 3, 17)
Console.WriteLine(ts1.ToString("d\.hh\:mm\:ss"))

Dim ts2 As New TimeSpan(3, 4, 3, 17)
Console.WriteLine(ts2.ToString("d\.hh\:mm\:ss"))
' The example displays the following output:
'       0.14:03:17
'       3.04:03:17

Kembali ke tabel

Penentu format kustom "m"

Penentu format kustom "m" menghasilkan nilai properti TimeSpan.Minutes, yang mewakili jumlah seluruh menit dalam interval waktu yang tidak dihitung sebagai bagian dari komponen harinya. Ini mengembalikan nilai string satu digit jika nilai properti TimeSpan.Minutes adalah 0 hingga 9, dan mengembalikan nilai string dua digit jika nilai properti TimeSpan.Minutes berkisar antara 10 hingga 59.

Jika penentu format kustom "m" digunakan sendiri, tentukan "%m" sehingga tidak disalahartikan sebagai string format standar. Contoh berikut memberikan ilustrasi.

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

Biasanya, dalam operasi penguraian, string input yang hanya menyertakan satu angka ditafsirkan sebagai jumlah hari. Anda dapat menggunakan penentu format kustom "%m" sebagai gantinya untuk menginterpretasikan string numerik sebagai jumlah menit. Contoh berikut memberikan ilustrasi.

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

Contoh berikut mengilustrasikan penggunaan penentu format kustom "m".

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

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

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

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

Kembali ke tabel

Penentu format kustom "mm"

Penentu format kustom "mm" menghasilkan nilai properti TimeSpan.Minutes, yang menunjukkan jumlah seluruh menit dalam interval waktu yang tidak disertakan sebagai bagian dari komponen jam atau harinya. Untuk nilai dari 0 hingga 9, string output menyertakan nol di depannya.

Biasanya, dalam operasi penguraian, string input yang hanya menyertakan satu angka ditafsirkan sebagai jumlah hari. Anda dapat menggunakan penentu format kustom "mm" sebagai gantinya untuk menginterpretasikan string numerik sebagai jumlah menit. Contoh berikut memberikan ilustrasi.

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

Contoh berikut mengilustrasikan penggunaan penentu format kustom "mm".

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

Kembali ke tabel

Penentu format kustom "s"

Penentu format kustom "s" menghasilkan nilai properti TimeSpan.Seconds, yang mewakili jumlah seluruh detik dalam interval waktu yang tidak disertakan sebagai bagian dari komponen jam, hari, atau menitnya. Ini mengembalikan nilai string satu digit jika nilai properti TimeSpan.Seconds adalah 0 hingga 9, dan mengembalikan nilai string dua digit jika nilai properti TimeSpan.Seconds berkisar antara 10 hingga 59.

Jika penentu format kustom "s" digunakan sendiri, tentukan "%s" sehingga tidak disalahartikan sebagai string format standar. Contoh berikut memberikan ilustrasi.

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

Biasanya, dalam operasi penguraian, string input yang hanya menyertakan satu angka ditafsirkan sebagai jumlah hari. Anda dapat menggunakan penentu format kustom "%s" sebagai gantinya untuk menginterpretasikan string numerik sebagai jumlah detik. Contoh berikut memberikan ilustrasi.

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

Contoh berikut mengilustrasikan penggunaan penentu format kustom "s".

TimeSpan startTime = new TimeSpan(0, 12, 30, 15, 0);
TimeSpan endTime = new TimeSpan(0, 12, 30, 21, 3);
Console.WriteLine(@"Elapsed Time: {0:s\:fff} seconds",
                  endTime - startTime);
// The example displays the following output:
//       Elapsed Time: 6:003 seconds

Dim startTime As New TimeSpan(0, 12, 30, 15, 0)
Dim endTime As New TimeSpan(0, 12, 30, 21, 3)
Console.WriteLine("Elapsed Time: {0:s\:fff} seconds",
                  endTime - startTime)
' The example displays the following output:
'       Elapsed Time: 6:003 seconds

Kembali ke tabel

Penentu format kustom "ss"

Penentu format kustom "ss" menghasilkan nilai properti TimeSpan.Seconds, yang mewakili jumlah seluruh detik dalam interval waktu yang tidak disertakan sebagai bagian dari komponen jam, hari, atau menitnya. Untuk nilai dari 0 hingga 9, string output menyertakan nol di depannya.

Biasanya, dalam operasi penguraian, string input yang hanya menyertakan satu angka ditafsirkan sebagai jumlah hari. Anda dapat menggunakan penentu format kustom "ss" sebagai gantinya untuk menginterpretasikan string numerik sebagai jumlah detik. Contoh berikut memberikan ilustrasi.

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

Contoh berikut mengilustrasikan penggunaan penentu format kustom "ss".

TimeSpan interval1 = TimeSpan.FromSeconds(12.60);
Console.WriteLine(interval1.ToString(@"ss\.fff"));

TimeSpan interval2 = TimeSpan.FromSeconds(6.485);
Console.WriteLine(interval2.ToString(@"ss\.fff"));
// The example displays the following output:
//       12.600
//       06.485

Dim interval1 As TimeSpan = TimeSpan.FromSeconds(12.60)
Console.WriteLine(interval1.ToString("ss\.fff"))
Dim interval2 As TimeSpan = TimeSpan.FromSeconds(6.485)
Console.WriteLine(interval2.ToString("ss\.fff"))
' The example displays the following output:
'       12.600
'       06.485

Kembali ke tabel

Penentu format kustom "f"

Penentu format kustom "f" menghasilkan persepuluh detik dalam interval waktu. Dalam operasi pemformatan, digit pecahan yang tersisa dipotong. Dalam operasi penguraian yang memanggil metode TimeSpan.ParseExact atau TimeSpan.TryParseExact, string input harus berisi tepat satu digit pecahan.

Jika penentu format kustom "f" digunakan sendiri, tentukan "%f" sehingga tidak disalahartikan sebagai string format standar.

Contoh berikut menggunakan penentu format kustom "f" untuk menampilkan persepuluh detik dalam nilai TimeSpan. "f" digunakan pertama sebagai satu-satunya penentu format, lalu dikombinasikan dengan penentu "s" dalam string format kustom.

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

Kembali ke tabel

Penentu format kustom "ff"

Penentu format kustom "ff" menghasilkan seratus detik dalam interval waktu. Dalam operasi pemformatan, digit pecahan yang tersisa dipotong. Dalam operasi penguraian yang memanggil metode TimeSpan.ParseExact atau TimeSpan.TryParseExact, string input harus berisi tepat dua digit pecahan.

Contoh berikut menggunakan penentu format kustom "ff" untuk menampilkan seratus detik dalam nilai TimeSpan. "ff" digunakan pertama sebagai satu-satunya penentu format, lalu dikombinasikan dengan penentu "s" dalam string format kustom.

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

Kembali ke tabel

Penentu format kustom "fff"

Penentu format kustom "fff" (dengan tiga karakter "f")) menghasilkan milidetik dalam interval waktu. Dalam operasi pemformatan, digit pecahan yang tersisa dipotong. Dalam operasi penguraian yang memanggil metode TimeSpan.ParseExact atau TimeSpan.TryParseExact, string input harus berisi tepat tiga digit pecahan.

Contoh berikut menggunakan penentu format kustom "fff" untuk menampilkan milidetik dalam nilai TimeSpan. "fff" digunakan pertama sebagai satu-satunya penentu format, lalu dikombinasikan dengan penentu "s" dalam string format kustom.

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

Kembali ke tabel

Penentu format kustom "ffff"

Penentu format kustom "ffff" (dengan empat karakter "f")) menghasilkan sepuluh ribu detik dalam interval waktu. Dalam operasi pemformatan, digit pecahan yang tersisa dipotong. Dalam operasi penguraian yang memanggil metode TimeSpan.ParseExact atau TimeSpan.TryParseExact, string input harus berisi tepat empat digit pecahan.

Contoh berikut menggunakan penentu format kustom "ffff" untuk menampilkan sepuluh ribu detik dalam nilai TimeSpan. "ffff" digunakan terlebih dahulu sebagai satu-satunya penentu format, lalu dikombinasikan dengan penentu "s" dalam string format kustom.

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

Kembali ke tabel

Penentu format kustom "fffff"

Penentu format kustom "fffff" (dengan lima karakter "f")) menghasilkan seratus ribu detik dalam interval waktu. Dalam operasi pemformatan, digit pecahan yang tersisa dipotong. Dalam operasi penguraian yang memanggil metode TimeSpan.ParseExact atau TimeSpan.TryParseExact, string input harus berisi tepat lima digit pecahan.

Contoh berikut menggunakan penentu format kustom "fffff" untuk menampilkan seratus ribu detik dalam nilai TimeSpan. "fffff" digunakan terlebih dahulu sebagai satu-satunya penentu format, lalu dikombinasikan dengan penentu "s" dalam string format kustom.

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

Kembali ke tabel

Penentu format kustom "ffffff"

Penentu format kustom "ffffff" (dengan enam karakter "f")) menghasilkan jutaan detik dalam interval waktu. Dalam operasi pemformatan, digit pecahan yang tersisa dipotong. Dalam operasi penguraian yang memanggil metode TimeSpan.ParseExact atau TimeSpan.TryParseExact, string input harus berisi tepat enam digit pecahan.

Contoh berikut menggunakan penentu format kustom "ffffff" untuk menampilkan jutaan detik dalam nilai TimeSpan. Ini digunakan pertama sebagai satu-satunya penentu format, lalu dikombinasikan dengan penentu "s" dalam string format kustom.

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

Kembali ke tabel

Penentu format kustom "fffffff"

Penentu format kustom "fffffff" (dengan tujuh karakter "f")) menghasilkan sepuluh juta detik (atau jumlah pecahan tanda centang) dalam interval waktu. Dalam operasi penguraian yang memanggil metode TimeSpan.ParseExact atau TimeSpan.TryParseExact, string input harus berisi tepat tujuh digit pecahan.

Contoh berikut menggunakan penentu format kustom "fffffff" untuk menampilkan jumlah pecahan tanda centang dalam nilai TimeSpan. Ini digunakan pertama sebagai satu-satunya penentu format, lalu dikombinasikan dengan penentu "s" dalam string format kustom.

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

Kembali ke tabel

Penentu format kustom "F"

Penentu format kustom "F" menghasilkan persepuluh detik dalam interval waktu. Dalam operasi pemformatan, digit pecahan yang tersisa dipotong. Jika nilai persepuluh interval waktu detik adalah nol, nilai tersebut tidak disertakan dalam string hasil. Dalam operasi penguraian yang memanggil metode TimeSpan.ParseExact atau TimeSpan.TryParseExact, kehadiran persepuluh digit kedua bersifat opsional.

Jika penentu format kustom "F" digunakan sendiri, tentukan "%F" sehingga tidak disalahartikan sebagai string format standar.

Contoh berikut menggunakan penentu format kustom "F" untuk menampilkan persepuluh detik dalam nilai TimeSpan. Ini juga menggunakan penentu format kustom ini dalam operasi penguraian.

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

Kembali ke tabel

Penentu format kustom "FF"

Penentu format kustom "FF" menghasilkan seratus detik dalam interval waktu. Dalam operasi pemformatan, digit pecahan yang tersisa dipotong. Jika ada nol pecahan berikutnya, nol tersebut tidak disertakan dalam string hasil. Dalam operasi penguraian yang memanggil metode TimeSpan.ParseExact atau TimeSpan.TryParseExact, kehadiran persepuluh dan seratus digit kedua bersifat opsional.

Contoh berikut menggunakan penentu format kustom "FF" untuk menampilkan seratus detik dalam nilai TimeSpan. Ini juga menggunakan penentu format kustom ini dalam operasi penguraian.

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

Kembali ke tabel

Penentu format kustom "FFF"

Penentu format kustom "FFF" (dengan tiga karakter "F") menghasilkan milidetik dalam interval waktu. Dalam operasi pemformatan, digit pecahan yang tersisa dipotong. Jika ada nol pecahan berikutnya, nol tersebut tidak disertakan dalam string hasil. Dalam operasi penguraian yang memanggil metode TimeSpan.ParseExact atau TimeSpan.TryParseExact, keberadaan persepuluh, seratus, dan seribu digit kedua bersifat opsional.

Contoh berikut menggunakan penentu format kustom "FFF" untuk menampilkan per seribu detik dalam nilai TimeSpan. Ini juga menggunakan penentu format kustom ini dalam operasi penguraian.

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

Kembali ke tabel

Penentu format kustom "FFFF"

Penentu format kustom "FFFF" (dengan empat karakter "F") menghasilkan sepuluh ribu detik dalam interval waktu. Dalam operasi pemformatan, digit pecahan yang tersisa dipotong. Jika ada nol pecahan berikutnya, nol tersebut tidak disertakan dalam string hasil. Dalam operasi penguraian yang memanggil metode TimeSpan.ParseExact atau TimeSpan.TryParseExact, keberadaan persepuluh, seratus, perseribu, dan sepuluh ribu digit kedua bersifat opsional.

Contoh berikut menggunakan penentu format kustom "FFFF" untuk menampilkan sepuluh ribu detik dalam nilai TimeSpan. Ini juga menggunakan penentu format kustom "FFFF" dalam operasi penguraian.

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

Kembali ke tabel

Penentu format kustom "FFFFF"

Penentu format kustom "FFFFF" (dengan lima karakter "F") menghasilkan seratus ribu detik dalam interval waktu. Dalam operasi pemformatan, digit pecahan yang tersisa dipotong. Jika ada nol pecahan berikutnya, nol tersebut tidak disertakan dalam string hasil. Dalam operasi penguraian yang memanggil metode TimeSpan.ParseExact atau TimeSpan.TryParseExact, keberadaan persepuluh, seratus, perseribu, sepuluh ribu, dan seratus ribu digit kedua bersifat opsional.

Contoh berikut menggunakan penentu format kustom "FFFFF" untuk menampilkan seratus ribu detik dalam nilai TimeSpan. Ini juga menggunakan penentu format kustom "FFFFF" dalam operasi penguraian.

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

Kembali ke tabel

Penentu format kustom "FFFFFF"

Penentu format kustom "FFFFFF" (dengan enam karakter "F") menghasilkan jutaan detik dalam interval waktu. Dalam operasi pemformatan, digit pecahan yang tersisa dipotong. Jika ada nol pecahan berikutnya, nol tersebut tidak disertakan dalam string hasil. Dalam operasi penguraian yang memanggil metode TimeSpan.ParseExact atau TimeSpan.TryParseExact, kehadiran persepuluh, seratus, perseribu, sepuluh ribu, seratus ribu, dan jutaan digit kedua bersifat opsional.

Contoh berikut menggunakan penentu format kustom "FFFFFF" untuk menampilkan jutaan detik dalam nilai TimeSpan. Ini juga menggunakan penentu format kustom ini dalam operasi penguraian.

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

Kembali ke tabel

Penentu format kustom "FFFFFFF"

Penentu format kustom "FFFFFFF" (dengan tujuh karakter "F") menghasilkan sepuluh juta detik (atau jumlah pecahan tanda centang) dalam interval waktu. Jika ada nol pecahan berikutnya, nol tersebut tidak disertakan dalam string hasil. Dalam operasi penguraian yang memanggil metode TimeSpan.ParseExact atau TimeSpan.TryParseExact, kehadiran tujuh digit pecahan dalam string input bersifat opsional.

Contoh berikut menggunakan penentu format kustom "FFFFFFF" untuk menampilkan bagian pecahan detik dalam nilai TimeSpan. Ini juga menggunakan penentu format kustom ini dalam operasi penguraian.

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

Kembali ke tabel

Karakter lain

Karakter lain yang tidak dilewati dalam string format, termasuk karakter spasi putih, ditafsirkan sebagai penentu format kustom. Dalam kebanyakan kasus, keberadaan karakter lain yang tidak dilewati menghasilkan FormatException.

Ada dua cara untuk menyertakan karakter harfiah dalam string format:

  • Sertakan dalam tanda kutip tunggal (pemisah string harfiah).

  • Awali dengan garis miring terbalik ("\"), yang ditafsirkan sebagai karakter escape. Ini berarti bahwa, dalam C#, string format harus @-quoted, atau karakter harfiah harus didahului oleh garis miring terbalik tambahan.

    Dalam beberapa kasus, Anda mungkin harus menggunakan logika kondisional untuk menyertakan literal yang lolos dalam string format. Contoh berikut menggunakan logika bersyarat untuk menyertakan simbol tanda untuk interval waktu negatif.

    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 tidak menentukan tata bahasa untuk pemisah dalam interval waktu. Ini berarti bahwa pemisah antara hari dan jam, jam dan menit, menit dan detik, dan detik dan pecahan detik semuanya harus diperlakukan sebagai literal karakter dalam string format.

Contoh berikut menggunakan karakter escape dan tanda kutip tunggal untuk menentukan string format kustom yang menyertakan kata "menit" dalam string output.

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

Kembali ke tabel

Lihat juga