TimeSpan.ParseExact Metode

Referensi

Definisi

Ruang nama:: System

Rakitan:: System.Runtime.dll

Rakitan:: mscorlib.dll

Rakitan:: netstandard.dll

Penting

Beberapa informasi terkait produk prarilis yang dapat diubah secara signifikan sebelum dirilis. Microsoft tidak memberikan jaminan, tersirat maupun tersurat, sehubungan dengan informasi yang diberikan di sini.

Mengonversi representasi string dari interval waktu menjadi TimeSpan setara. Format representasi string harus sama persis dengan format yang ditentukan.

Overload

ParseExact(String, String[], IFormatProvider, TimeSpanStyles)	Mengonversi representasi string interval waktu menjadi TimeSpan setara dengan menggunakan format yang ditentukan, informasi format khusus budaya, dan gaya. Format representasi string harus sama persis dengan salah satu format yang ditentukan.
ParseExact(String, String, IFormatProvider, TimeSpanStyles)	Mengonversi representasi string interval waktu menjadi TimeSpan setara dengan menggunakan format yang ditentukan, informasi format khusus budaya, dan gaya. Format representasi string harus sama persis dengan format yang ditentukan.
ParseExact(ReadOnlySpan<Char>, String[], IFormatProvider, TimeSpanStyles)	Mengonversi representasi string interval waktu menjadi TimeSpan setara dengan menggunakan format yang ditentukan, informasi format khusus budaya, dan gaya. Format representasi string harus sama persis dengan salah satu format yang ditentukan.
ParseExact(String, String[], IFormatProvider)	Mengonversi representasi string interval waktu menjadi TimeSpan setara dengan menggunakan array string format dan informasi format khusus budaya yang ditentukan. Format representasi string harus sama persis dengan salah satu format yang ditentukan.
ParseExact(String, String, IFormatProvider)	Mengonversi representasi string interval waktu menjadi TimeSpan setara dengan menggunakan format yang ditentukan dan informasi format khusus budaya. Format representasi string harus sama persis dengan format yang ditentukan.
ParseExact(ReadOnlySpan<Char>, ReadOnlySpan<Char>, IFormatProvider, TimeSpanStyles)	Mengonversi rentang karakter interval waktu menjadi TimeSpan setara dengan menggunakan format yang ditentukan dan informasi format khusus budaya. Format representasi string harus sama persis dengan format yang ditentukan.

ParseExact(String, String[], IFormatProvider, TimeSpanStyles)

Sumber:: TimeSpan.cs

Sumber:: TimeSpan.cs

Sumber:: TimeSpan.cs

Mengonversi representasi string interval waktu menjadi TimeSpan setara dengan menggunakan format yang ditentukan, informasi format khusus budaya, dan gaya. Format representasi string harus sama persis dengan salah satu format yang ditentukan.

public:
 static TimeSpan ParseExact(System::String ^ input, cli::array <System::String ^> ^ formats, IFormatProvider ^ formatProvider, System::Globalization::TimeSpanStyles styles);

public static TimeSpan ParseExact (string input, string[] formats, IFormatProvider formatProvider, System.Globalization.TimeSpanStyles styles);

public static TimeSpan ParseExact (string input, string[] formats, IFormatProvider? formatProvider, System.Globalization.TimeSpanStyles styles);

static member ParseExact : string * string[] * IFormatProvider * System.Globalization.TimeSpanStyles -> TimeSpan

Public Shared Function ParseExact (input As String, formats As String(), formatProvider As IFormatProvider, styles As TimeSpanStyles) As TimeSpan

Parameter

input: String

String yang menentukan interval waktu yang akan dikonversi.

formats: String[]

Array string format standar atau kustom yang menentukan format yang diperlukan dari input.

formatProvider: IFormatProvider

Objek yang menyediakan informasi pemformatan khusus budaya.

styles: TimeSpanStyles

Kombinasi bitwise dari nilai enumerasi yang menentukan elemen gaya yang mungkin ada dalam input.

Mengembalikan

TimeSpan

Interval waktu yang sesuai dengan input, seperti yang ditentukan oleh formats, formatProvider, dan styles.

Pengecualian

ArgumentException

styles adalah nilai yang tidak valid TimeSpanStyles .

ArgumentNullException

inputadalah null.

FormatException

input memiliki format yang tidak valid.

OverflowException

input mewakili angka yang kurang dari TimeSpan.MinValue atau lebih besar dari TimeSpan.MaxValue.

-atau-

Setidaknya salah satu komponen hari, jam, menit, atau detik berada di input luar rentang yang valid.

Contoh

Contoh berikut memanggil ParseExact(String, String[], IFormatProvider, TimeSpanStyles) metode untuk mengonversi setiap elemen array string menjadi TimeSpan nilai. String dapat mewakili interval waktu dalam format pendek umum atau format panjang umum.

Selain itu, contoh mengubah cara metode penguraian interval waktu menginterpretasikan satu digit. Biasanya, satu digit ditafsirkan sebagai jumlah hari dalam interval waktu. Sebagai gantinya %h , string format kustom digunakan untuk menginterpretasikan satu digit sebagai jumlah jam. Agar perubahan ini efektif, perhatikan bahwa %h string format kustom harus mendahului string format lainnya dalam formats array. Perhatikan juga dari output bahwa bendera yang TimeSpanStyles.AssumeNegative ditentukan dalam panggilan metode hanya digunakan saat mengurai string dengan penentu format ini.

using System;
using System.Globalization;

public class Example
{
   public static void Main()
   {
      string[] inputs = { "3", "16:42", "1:6:52:35.0625", 
                          "1:6:52:35,0625" }; 
      string[] formats = { "%h", "g", "G" };
      TimeSpan interval;
      CultureInfo culture = new CultureInfo("de-DE");
      
      // Parse each string in inputs using formats and the de-DE culture.
      foreach (string input in inputs) {
         try {
            interval = TimeSpan.ParseExact(input, formats, culture,
                                           TimeSpanStyles.AssumeNegative);
            Console.WriteLine("{0} --> {1:c}", input, interval);
         }
         catch (FormatException) {
            Console.WriteLine("{0} --> Bad Format", input);
         }      
         catch (OverflowException) {
            Console.WriteLine("{0} --> Overflow", input);   
         }            
      }
   }
}
// The example displays the following output:
//       3 --> -03:00:00
//       16:42 --> 16:42:00
//       1:6:52:35.0625 --> Bad Format
//       1:6:52:35,0625 --> 1.06:52:35.0625000

open System
open System.Globalization

let inputs = 
    [| "3"; "16:42"; "1:6:52:35.0625"; "1:6:52:35,0625" |] 
let formats = [| "%h"; "g"; "G" |]
let culture = CultureInfo "de-DE"

// Parse each string in inputs using formats and the de-DE culture.
for input in inputs do
    try
        let interval = 
            TimeSpan.ParseExact(input, formats, culture, TimeSpanStyles.AssumeNegative)
        printfn $"{input} --> {interval:c}"
    with
    | :? FormatException ->
        printfn $"{input} --> Bad Format"
    | :? OverflowException ->
        printfn $"{input} --> Overflow"
// The example displays the following output:
//       3 --> -03:00:00
//       16:42 --> 16:42:00
//       1:6:52:35.0625 --> Bad Format
//       1:6:52:35,0625 --> 1.06:52:35.0625000

Imports System.Globalization

Module Example
   Public Sub Main()
      Dim inputs() As String = { "3", "16:42", "1:6:52:35.0625", 
                                 "1:6:52:35,0625" } 
      Dim formats() As String = { "%h", "g", "G" }
      Dim interval As TimeSpan
      Dim culture As New CultureInfo("de-DE")
      
      ' Parse each string in inputs using formats and the de-DE culture.
      For Each input As String In inputs
         Try
            interval = TimeSpan.ParseExact(input, formats, culture, 
                                           TimeSpanStyles.AssumeNegative)
            Console.WriteLine("{0} --> {1:c}", input, interval)   
         Catch e As FormatException
            Console.WriteLine("{0} --> Bad Format", input)   
         Catch e As OverflowException
            Console.WriteLine("{0} --> Overflow", input)   
         End Try            
      Next
   End Sub
End Module
' The example displays the following output:
'       3 --> -03:00:00
'       16:42 --> 16:42:00
'       1:6:52:35.0625 --> Bad Format
'       1:6:52:35,0625 --> 1.06:52:35.0625000

Keterangan

Metode ini ParseExact(String, String[], IFormatProvider, TimeSpanStyles) mengurai representasi string dari interval waktu, yang harus dalam salah satu format yang ditentukan oleh formats parameter, kecuali bahwa karakter spasi putih di depan dan di belakang diabaikan. Karena input harus persis sesuai dengan salah satu format yang ditentukan dalam formats, Anda harus selalu menggunakan penanganan pengecualian saat mengonversi input string oleh pengguna ke interval waktu. Jika Anda lebih suka tidak menggunakan penanganan pengecualian, Anda dapat memanggil metode sebagai gantinya TryParseExact(String, String[], IFormatProvider, TimeSpanStyles, TimeSpan) .

Parameter formats adalah array string yang elemennya terdiri dari penentu format standar tunggal, atau satu atau beberapa penentu format kustom yang menentukan format yang diperlukan dari input. Untuk informasi selengkapnya tentang string format yang valid, lihat String Format TimeSpan Standar dan String Format Rentang Waktu Kustom. input harus sesuai persis dengan anggota agar operasi penguraian formats berhasil. Operasi penguraian mencoba mencocokkan input dengan setiap elemen dalam formats dimulai dengan elemen pertama dalam array.

Penting

Metode ini ParseExact menggunakan konvensi budaya yang ditentukan oleh formatProvider parameter hanya jika string format yang digunakan untuk mengurai input adalah string format standar TimeSpan yang nilainya adalah "g" atau "G". String format standar "c", "t", dan "T" menggunakan konvensi pemformatan budaya invarian. String format kustom menentukan format yang tepat dari string input dan menggunakan karakter harfiah untuk memisahkan komponen interval waktu.

Parameter formatProvider adalah IFormatProvider implementasi yang menyediakan informasi khusus budaya tentang format string yang dikembalikan jika string format yang digunakan untuk mengurai input adalah string format standar. Parameter formatProvider dapat berupa salah satu hal berikut:

Objek CultureInfo yang mewakili budaya yang konvensi pemformatannya akan tercermin dalam string yang dikembalikan. Objek DateTimeFormatInfo yang CultureInfo.DateTimeFormat dikembalikan oleh properti menentukan pemformatan string yang dikembalikan.
Objek DateTimeFormatInfo yang menentukan pemformatan string yang dikembalikan.
Objek kustom yang mengimplementasikan IFormatProvider antarmuka. Metodenya IFormatProvider.GetFormat mengembalikan DateTimeFormatInfo objek yang menyediakan informasi pemformatan.

Jika formatProvider adalah null, DateTimeFormatInfo objek yang terkait dengan budaya saat ini digunakan.

Parameter styles memengaruhi interpretasi string yang diurai menggunakan string format kustom. Ini menentukan apakah input ditafsirkan sebagai interval waktu negatif hanya jika tanda negatif ada (TimeSpanStyles.None), atau apakah selalu ditafsirkan sebagai interval waktu negatif (TimeSpanStyles.AssumeNegative). Jika TimeSpanStyles.AssumeNegative tidak digunakan, format harus menyertakan simbol tanda negatif harfiah (seperti "\-") agar berhasil mengurai interval waktu negatif.

Lihat juga

Berlaku untuk

ParseExact(String, String, IFormatProvider, TimeSpanStyles)

Sumber:: TimeSpan.cs

Sumber:: TimeSpan.cs

Sumber:: TimeSpan.cs

public:
 static TimeSpan ParseExact(System::String ^ input, System::String ^ format, IFormatProvider ^ formatProvider, System::Globalization::TimeSpanStyles styles);

public static TimeSpan ParseExact (string input, string format, IFormatProvider formatProvider, System.Globalization.TimeSpanStyles styles);

public static TimeSpan ParseExact (string input, string format, IFormatProvider? formatProvider, System.Globalization.TimeSpanStyles styles);

static member ParseExact : string * string * IFormatProvider * System.Globalization.TimeSpanStyles -> TimeSpan

Public Shared Function ParseExact (input As String, format As String, formatProvider As IFormatProvider, styles As TimeSpanStyles) As TimeSpan

Parameter

input: String

String yang menentukan interval waktu yang akan dikonversi.

format: String

String format standar atau kustom yang menentukan format yang diperlukan dari input.

formatProvider: IFormatProvider

Objek yang menyediakan informasi pemformatan khusus budaya.

styles: TimeSpanStyles

Kombinasi bitwise dari nilai enumerasi yang menentukan elemen gaya yang mungkin ada di input.

Mengembalikan

TimeSpan

Interval waktu yang sesuai dengan input, seperti yang ditentukan oleh format, formatProvider, dan styles.

Pengecualian

ArgumentException

styles adalah nilai yang tidak valid TimeSpanStyles .

ArgumentNullException

inputadalah null.

FormatException

input memiliki format yang tidak valid.

OverflowException

input mewakili angka yang kurang dari TimeSpan.MinValue atau lebih besar dari TimeSpan.MaxValue.

-atau-

Setidaknya salah satu komponen hari, jam, menit, atau detik berada di input luar rentang yang valid.

Contoh

Contoh berikut menggunakan ParseExact(String, String, IFormatProvider) metode untuk mengurai beberapa representasi string interval waktu menggunakan berbagai string format dan budaya. Ini juga menggunakan TimeSpanStyles.AssumeNegative nilai untuk menafsirkan setiap string sebagai interval waktu negatif. Output dari contoh menggambarkan TimeSpanStyles.AssumeNegative bahwa gaya hanya memengaruhi nilai yang dikembalikan saat digunakan dengan string format kustom.

using System;
using System.Globalization;

public class Example
{
   public static void Main()
   {
      string intervalString, format;
      TimeSpan interval;
      CultureInfo culture = null;
      
      // Parse hour:minute value with custom format specifier.
      intervalString = "17:14";
      format = "h\\:mm";
      culture = CultureInfo.CurrentCulture;
      try {
         interval = TimeSpan.ParseExact(intervalString, format, 
                                        culture, TimeSpanStyles.AssumeNegative);
         Console.WriteLine("'{0}' ({1}) --> {2}", intervalString, format, interval);
      }   
      catch (FormatException) {
         Console.WriteLine("'{0}': Bad Format for '{1}'", intervalString, format);
      }   
      catch (OverflowException) {
         Console.WriteLine("'{0}': Overflow", intervalString);
      }      
      
      // Parse hour:minute:second value with "g" specifier.
      intervalString = "17:14:48";
      format = "g";
      culture = CultureInfo.InvariantCulture;
      try {
         interval = TimeSpan.ParseExact(intervalString, format, 
                                        culture, TimeSpanStyles.AssumeNegative);
         Console.WriteLine("'{0}' ({1}) --> {2}", intervalString, format, interval);
      }
      catch (FormatException) {
         Console.WriteLine("'{0}': Bad Format for '{1}'", intervalString, format);
      }   
      catch (OverflowException) {
         Console.WriteLine("'{0}': Overflow", intervalString);
      } 
      
      // Parse hours:minute.second value with custom format specifier.     
      intervalString = "17:14:48.153";
      format = @"h\:mm\:ss\.fff";
      culture = null;
      try {
         interval = TimeSpan.ParseExact(intervalString, format, 
                                        culture, TimeSpanStyles.AssumeNegative);
         Console.WriteLine("'{0}' ({1}) --> {2}", intervalString, format, interval);
      }
      catch (FormatException) {
         Console.WriteLine("'{0}': Bad Format for '{1}'", intervalString, format);
      }   
      catch (OverflowException) {
         Console.WriteLine("'{0}': Overflow", intervalString);
      } 

      // Parse days:hours:minute.second value with "G" specifier 
      // and current (en-US) culture.     
      intervalString = "3:17:14:48.153";
      format = "G";
      culture = CultureInfo.CurrentCulture;
      try {
         interval = TimeSpan.ParseExact(intervalString, format, 
                                        culture, TimeSpanStyles.AssumeNegative);
         Console.WriteLine("'{0}' ({1}) --> {2}", intervalString, format, interval);
      }   
      catch (FormatException) {
         Console.WriteLine("'{0}': Bad Format for '{1}'", intervalString, format);
      }
      catch (OverflowException) {
         Console.WriteLine("'{0}': Overflow", intervalString);
      } 
            
      // Parse days:hours:minute.second value with a custom format specifier.     
      intervalString = "3:17:14:48.153";
      format = @"d\:hh\:mm\:ss\.fff";
      culture = null;
      try {
         interval = TimeSpan.ParseExact(intervalString, format, 
                                        culture, TimeSpanStyles.AssumeNegative);
         Console.WriteLine("'{0}' ({1}) --> {2}", intervalString, format, interval);
      }   
      catch (FormatException) {
         Console.WriteLine("'{0}': Bad Format for '{1}'", intervalString, format);
      }   
      catch (OverflowException) {
         Console.WriteLine("'{0}': Overflow", intervalString);
      } 
      
      // Parse days:hours:minute.second value with "G" specifier 
      // and fr-FR culture.     
      intervalString = "3:17:14:48,153";
      format = "G";
      culture = new CultureInfo("fr-FR");
      try {
         interval = TimeSpan.ParseExact(intervalString, format, 
                                        culture, TimeSpanStyles.AssumeNegative);
         Console.WriteLine("'{0}' ({1}) --> {2}", intervalString, format, interval);
      }   
      catch (FormatException) {
         Console.WriteLine("'{0}': Bad Format for '{1}'", intervalString, format);
      }   
      catch (OverflowException) {
         Console.WriteLine("'{0}': Overflow", intervalString);
      } 

      // Parse a single number using the "c" standard format string. 
      intervalString = "12";
      format = "c";
      try {
         interval = TimeSpan.ParseExact(intervalString, format, 
                                        null, TimeSpanStyles.AssumeNegative);
         Console.WriteLine("'{0}' ({1}) --> {2}", intervalString, format, interval);
      }   
      catch (FormatException) {
         Console.WriteLine("'{0}': Bad Format for '{1}'", intervalString, format);
      }   
      catch (OverflowException) {
         Console.WriteLine("'{0}': Overflow", intervalString);
      } 
      
      // Parse a single number using the "%h" custom format string. 
      format = "%h";
      try {
         interval = TimeSpan.ParseExact(intervalString, format, 
                                        null, TimeSpanStyles.AssumeNegative);
         Console.WriteLine("'{0}' ({1}) --> {2}", intervalString, format, interval);
      }   
      catch (FormatException) {
         Console.WriteLine("'{0}': Bad Format for '{1}'", intervalString, format);
      }   
      catch (OverflowException) {
         Console.WriteLine("'{0}': Overflow", intervalString);
      } 
      
      // Parse a single number using the "%s" custom format string. 
      format = "%s";
      try {
         interval = TimeSpan.ParseExact(intervalString, format, 
                                        null, TimeSpanStyles.AssumeNegative);
         Console.WriteLine("'{0}' ({1}) --> {2}", intervalString, format, interval);
      }   
      catch (FormatException) {
         Console.WriteLine("'{0}': Bad Format for '{1}'", intervalString, format);
      }   
      catch (OverflowException) {
         Console.WriteLine("'{0}': Overflow", intervalString);
      } 
   }
}
// The example displays the following output:
//    '17:14' (h\:mm) --> -17:14:00
//    '17:14:48' (g) --> 17:14:48
//    '17:14:48.153' (h\:mm\:ss\.fff) --> -17:14:48.1530000
//    '3:17:14:48.153' (G) --> 3.17:14:48.1530000
//    '3:17:14:48.153' (d\:hh\:mm\:ss\.fff) --> -3.17:14:48.1530000
//    '3:17:14:48,153' (G) --> 3.17:14:48.1530000
//    '12' (c) --> 12.00:00:00
//    '12' (%h) --> -12:00:00
//    '12' (%s) --> -00:00:12

open System
open System.Globalization

do
    // Parse hour:minute value with custom format specifier.
    let intervalString = "17:14"
    let format = "h\\:mm"
    let culture = CultureInfo.CurrentCulture
    try
        let interval = TimeSpan.ParseExact(intervalString, format, culture, TimeSpanStyles.AssumeNegative)
        printfn $"'{intervalString}' ({format}) --> {interval}"
    with 
    | :? FormatException ->
        printfn $"'{intervalString}': Bad Format for '{format}'"
    | :? OverflowException ->
        printfn $"'{intervalString}': Overflow"
    
    // Parse hour:minute:second value with "g" specifier.
    let intervalString = "17:14:48"
    let format = "g"
    let culture = CultureInfo.InvariantCulture
    try
        let interval = TimeSpan.ParseExact(intervalString, format, culture, TimeSpanStyles.AssumeNegative)
        printfn $"'{intervalString}' ({format}) --> {interval}"
    with 
    | :? FormatException ->
        printfn $"'{intervalString}': Bad Format for '{format}'"
    | :? OverflowException ->
        printfn $"'{intervalString}': Overflow"
    
    // Parse hours:minute.second value with custom format specifier.     
    let intervalString = "17:14:48.153"
    let format = @"h\:mm\:ss\.fff"
    let culture = null
    try
        let interval = TimeSpan.ParseExact(intervalString, format, culture, TimeSpanStyles.AssumeNegative)
        printfn $"'{intervalString}' ({format}) --> {interval}"
    with 
    | :? FormatException ->
        printfn $"'{intervalString}': Bad Format for '{format}'"
    | :? OverflowException ->
        printfn $"'{intervalString}': Overflow"

    // Parse days:hours:minute.second value with "G" specifier 
    // and current (en-US) culture.     
    let intervalString = "3:17:14:48.153"
    let format = "G"
    let culture = CultureInfo.CurrentCulture
    try
        let interval = TimeSpan.ParseExact(intervalString, format, culture, TimeSpanStyles.AssumeNegative)
        printfn $"'{intervalString}' ({format}) --> {interval}"
    with 
    | :? FormatException ->
        printfn $"'{intervalString}': Bad Format for '{format}'"
    | :? OverflowException ->
        printfn $"'{intervalString}': Overflow"
        
    // Parse days:hours:minute.second value with a custom format specifier.     
    let intervalString = "3:17:14:48.153"
    let format = @"d\:hh\:mm\:ss\.fff"
    let culture = null
    try
        let interval = TimeSpan.ParseExact(intervalString, format, culture, TimeSpanStyles.AssumeNegative)
        printfn $"'{intervalString}' ({format}) --> {interval}"
    with 
    | :? FormatException ->
        printfn $"'{intervalString}': Bad Format for '{format}'"
    | :? OverflowException ->
        printfn $"'{intervalString}': Overflow"
    
    // Parse days:hours:minute.second value with "G" specifier 
    // and fr-FR culture.     
    let intervalString = "3:17:14:48,153"
    let format = "G"
    let culture = new CultureInfo("fr-FR")
    try
        let interval = TimeSpan.ParseExact(intervalString, format, culture, TimeSpanStyles.AssumeNegative)
        printfn $"'{intervalString}' ({format}) --> {interval}"
    with 
    | :? FormatException ->
        printfn $"'{intervalString}': Bad Format for '{format}'"
    | :? OverflowException ->
        printfn $"'{intervalString}': Overflow"

    // Parse a single number using the "c" standard format string. 
    let intervalString = "12"
    let format = "c"
    try
        let interval = TimeSpan.ParseExact(intervalString, format, null, TimeSpanStyles.AssumeNegative)
        printfn $"'{intervalString}' ({format}) --> {interval}"
    with 
    | :? FormatException ->
        printfn $"'{intervalString}': Bad Format for '{format}'"
    | :? OverflowException ->
        printfn $"'{intervalString}': Overflow"
    
    // Parse a single number using the "%h" custom format string. 
    let format = "%h"
    try
        let interval = TimeSpan.ParseExact(intervalString, format, null, TimeSpanStyles.AssumeNegative)
        printfn $"'{intervalString}' ({format}) --> {interval}"
    with 
    | :? FormatException ->
        printfn $"'{intervalString}': Bad Format for '{format}'"
    | :? OverflowException ->
        printfn $"'{intervalString}': Overflow"
    
    // Parse a single number using the "%s" custom format string. 
    let format = "%s"
    try
        let interval = TimeSpan.ParseExact(intervalString, format, null, TimeSpanStyles.AssumeNegative)
        printfn $"'{intervalString}' ({format}) --> {interval}"
    with 
    | :? FormatException ->
        printfn $"'{intervalString}': Bad Format for '{format}'"
    | :? OverflowException ->
        printfn $"'{intervalString}': Overflow"
// The example displays the following output:
//    '17:14' (h\:mm) --> -17:14:00
//    '17:14:48' (g) --> 17:14:48
//    '17:14:48.153' (h\:mm\:ss\.fff) --> -17:14:48.1530000
//    '3:17:14:48.153' (G) --> 3.17:14:48.1530000
//    '3:17:14:48.153' (d\:hh\:mm\:ss\.fff) --> -3.17:14:48.1530000
//    '3:17:14:48,153' (G) --> 3.17:14:48.1530000
//    '12' (c) --> 12.00:00:00
//    '12' (%h) --> -12:00:00
//    '12' (%s) --> -00:00:12

Imports System.Globalization

Module Example
   Public Sub Main()
      Dim intervalString, format As String
      Dim interval As TimeSpan
      Dim culture As CultureInfo = Nothing
      
      ' Parse hour:minute value with custom format specifier.
      intervalString = "17:14"
      format = "h\:mm"
      culture = CultureInfo.CurrentCulture
      Try
         interval = TimeSpan.ParseExact(intervalString, format, 
                                        culture, TimeSpanStyles.AssumeNegative)
         Console.WriteLine("'{0}' ({1}) --> {2}", intervalString, format, interval)
      Catch e As FormatException
         Console.WriteLine("'{0}': Bad Format for '{1}'", intervalString, format)
      Catch e As OverflowException
         Console.WriteLine("'{0}': Overflow", intervalString)
      End Try      
      
      ' Parse hour:minute:second value with "g" specifier.
      intervalString = "17:14:48"
      format = "g"
      culture = CultureInfo.InvariantCulture
      Try
         interval = TimeSpan.ParseExact(intervalString, format, 
                                        culture, TimeSpanStyles.AssumeNegative)
         Console.WriteLine("'{0}' ({1}) --> {2}", intervalString, format, interval)
      Catch e As FormatException
         Console.WriteLine("'{0}': Bad Format for '{1}'", intervalString, format)
      Catch e As OverflowException
         Console.WriteLine("'{0}': Overflow", intervalString)
      End Try 
      
      ' Parse hours:minute.second value with custom format specifier.     
      intervalString = "17:14:48.153"
      format = "h\:mm\:ss\.fff"
      culture = Nothing
      Try
         interval = TimeSpan.ParseExact(intervalString, format, 
                                        culture, TimeSpanStyles.AssumeNegative)
         Console.WriteLine("'{0}' ({1}) --> {2}", intervalString, format, interval)
      Catch e As FormatException
         Console.WriteLine("'{0}': Bad Format for '{1}'", intervalString, format)
      Catch e As OverflowException
         Console.WriteLine("'{0}': Overflow", intervalString)
      End Try 

      ' Parse days:hours:minute.second value with "G" specifier 
      ' and current (en-US) culture.     
      intervalString = "3:17:14:48.153"
      format = "G"
      culture = CultureInfo.CurrentCulture
      Try
         interval = TimeSpan.ParseExact(intervalString, format, 
                                        culture, TimeSpanStyles.AssumeNegative)
         Console.WriteLine("'{0}' ({1}) --> {2}", intervalString, format, interval)
      Catch e As FormatException
         Console.WriteLine("'{0}': Bad Format for '{1}'", intervalString, format)
      Catch e As OverflowException
         Console.WriteLine("'{0}': Overflow", intervalString)
      End Try 
            
      ' Parse days:hours:minute.second value with a custom format specifier.     
      intervalString = "3:17:14:48.153"
      format = "d\:hh\:mm\:ss\.fff"
      culture = Nothing
      Try
         interval = TimeSpan.ParseExact(intervalString, format, 
                                        culture, TimeSpanStyles.AssumeNegative)
         Console.WriteLine("'{0}' ({1}) --> {2}", intervalString, format, interval)
      Catch e As FormatException
         Console.WriteLine("'{0}': Bad Format for '{1}'", intervalString, format)
      Catch e As OverflowException
         Console.WriteLine("'{0}': Overflow", intervalString)
      End Try 
      
      ' Parse days:hours:minute.second value with "G" specifier 
      ' and fr-FR culture.     
      intervalString = "3:17:14:48,153"
      format = "G"
      culture = New CultureInfo("fr-FR")
      Try
         interval = TimeSpan.ParseExact(intervalString, format, 
                                        culture, TimeSpanStyles.AssumeNegative)
         Console.WriteLine("'{0}' ({1}) --> {2}", intervalString, format, interval)
      Catch e As FormatException
         Console.WriteLine("'{0}': Bad Format for '{1}'", intervalString, format)
      Catch e As OverflowException
         Console.WriteLine("'{0}': Overflow", intervalString)
      End Try 

      ' Parse a single number using the "c" standard format string. 
      intervalString = "12"
      format = "c"
      Try
         interval = TimeSpan.ParseExact(intervalString, format, 
                                        Nothing, TimeSpanStyles.AssumeNegative)
         Console.WriteLine("'{0}' ({1}) --> {2}", intervalString, format, interval)
      Catch e As FormatException
         Console.WriteLine("'{0}': Bad Format for '{1}'", intervalString, format)
      Catch e As OverflowException
         Console.WriteLine("'{0}': Overflow", intervalString)
      End Try 
      
      ' Parse a single number using the "%h" custom format string. 
      format = "%h"
      Try
         interval = TimeSpan.ParseExact(intervalString, format, 
                                        Nothing, TimeSpanStyles.AssumeNegative)
         Console.WriteLine("'{0}' ({1}) --> {2}", intervalString, format, interval)
      Catch e As FormatException
         Console.WriteLine("'{0}': Bad Format for '{1}'", intervalString, format)
      Catch e As OverflowException
         Console.WriteLine("'{0}': Overflow", intervalString)
      End Try 
      
      ' Parse a single number using the "%s" custom format string. 
      format = "%s"
      Try
         interval = TimeSpan.ParseExact(intervalString, format, 
                                        Nothing, TimeSpanStyles.AssumeNegative)
         Console.WriteLine("'{0}' ({1}) --> {2}", intervalString, format, interval)
      Catch e As FormatException
         Console.WriteLine("'{0}': Bad Format for '{1}'", intervalString, format)
      Catch e As OverflowException
         Console.WriteLine("'{0}': Overflow", intervalString)
      End Try 
   End Sub
End Module
' The example displays the following output:
'    '17:14' (h\:mm) --> -17:14:00
'    '17:14:48' (g) --> 17:14:48
'    '17:14:48.153' (h\:mm\:ss\.fff) --> -17:14:48.1530000
'    '3:17:14:48.153' (G) --> 3.17:14:48.1530000
'    '3:17:14:48.153' (d\:hh\:mm\:ss\.fff) --> -3.17:14:48.1530000
'    '3:17:14:48,153' (G) --> 3.17:14:48.1530000
'    '12' (c) --> 12.00:00:00
'    '12' (%h) --> -12:00:00
'    '12' (%s) --> -00:00:12

Keterangan

Metode ini ParseExact mengurai representasi string dari interval waktu, yang harus dalam format yang ditentukan oleh format parameter, kecuali bahwa karakter spasi putih di depan dan di belakang diabaikan. Karena input harus sesuai dengan format format persis, Anda harus selalu menggunakan penanganan pengecualian saat mengonversi input string oleh pengguna ke interval waktu. Jika Anda lebih suka tidak menggunakan penanganan pengecualian, Anda dapat memanggil metode sebagai gantinya TryParseExact(String, String, IFormatProvider, TimeSpanStyles, TimeSpan) .

Parameter format adalah string yang berisi penentu format standar tunggal, atau satu atau beberapa penentu format kustom yang menentukan format yang diperlukan dari input. Untuk informasi selengkapnya tentang string format yang valid, lihat String Format TimeSpan Standar dan String Format Rentang Waktu Kustom.

Penting

Metode ini ParseExact menggunakan konvensi budaya yang ditentukan oleh formatProvider parameter hanya jika format merupakan string format standar TimeSpan yang nilainya adalah "g" atau "G". String format standar "c", "t", dan "T" menggunakan konvensi pemformatan budaya invarian. String format kustom menentukan format yang tepat dari string input dan menggunakan karakter harfiah untuk memisahkan komponen interval waktu.

Parameter formatProvider adalah IFormatProvider implementasi yang menyediakan informasi khusus budaya tentang format string yang dikembalikan jika format merupakan string format standar. Parameter formatProvider dapat berupa salah satu hal berikut:

Objek CultureInfo yang mewakili budaya yang konvensi pemformatannya akan tercermin dalam string yang dikembalikan. Objek DateTimeFormatInfo yang CultureInfo.DateTimeFormat dikembalikan oleh properti menentukan pemformatan string yang dikembalikan.
Objek DateTimeFormatInfo yang menentukan pemformatan string yang dikembalikan.
Objek kustom yang mengimplementasikan IFormatProvider antarmuka. Metodenya IFormatProvider.GetFormat mengembalikan DateTimeFormatInfo objek yang menyediakan informasi pemformatan.

Jika formatProvider adalah null, DateTimeFormatInfo objek yang terkait dengan budaya saat ini digunakan.

Parameter styles memengaruhi interpretasi string yang diurai menggunakan string format kustom. Ini menentukan apakah input ditafsirkan sebagai interval waktu negatif hanya jika tanda negatif ada (TimeSpanStyles.None), atau apakah itu selalu ditafsirkan sebagai interval waktu negatif (TimeSpanStyles.AssumeNegative). Jika TimeSpanStyles.AssumeNegative tidak digunakan, format harus menyertakan simbol tanda negatif harfiah (seperti "\-") agar berhasil mengurai interval waktu negatif.

Lihat juga

Berlaku untuk

ParseExact(ReadOnlySpan<Char>, String[], IFormatProvider, TimeSpanStyles)

Sumber:: TimeSpan.cs

Sumber:: TimeSpan.cs

Sumber:: TimeSpan.cs

public static TimeSpan ParseExact (ReadOnlySpan<char> input, string[] formats, IFormatProvider? formatProvider, System.Globalization.TimeSpanStyles styles = System.Globalization.TimeSpanStyles.None);

public static TimeSpan ParseExact (ReadOnlySpan<char> input, string[] formats, IFormatProvider formatProvider, System.Globalization.TimeSpanStyles styles = System.Globalization.TimeSpanStyles.None);

static member ParseExact : ReadOnlySpan<char> * string[] * IFormatProvider * System.Globalization.TimeSpanStyles -> TimeSpan

Public Shared Function ParseExact (input As ReadOnlySpan(Of Char), formats As String(), formatProvider As IFormatProvider, Optional styles As TimeSpanStyles = System.Globalization.TimeSpanStyles.None) As TimeSpan

Parameter

input: ReadOnlySpan<Char>

Rentang yang menentukan interval waktu untuk dikonversi.

formats: String[]

Array string format standar atau kustom yang menentukan format yang diperlukan dari input.

formatProvider: IFormatProvider

Objek yang menyediakan informasi pemformatan khusus budaya.

styles: TimeSpanStyles

Kombinasi bitwise dari nilai enumerasi yang menentukan elemen gaya yang mungkin ada dalam input.

Mengembalikan

TimeSpan

Interval waktu yang sesuai dengan input, seperti yang ditentukan oleh formats, formatProvider, dan styles.

Berlaku untuk

ParseExact(String, String[], IFormatProvider)

Sumber:: TimeSpan.cs

Sumber:: TimeSpan.cs

Sumber:: TimeSpan.cs

Mengonversi representasi string interval waktu menjadi TimeSpan setara dengan menggunakan array string format yang ditentukan dan informasi format khusus budaya. Format representasi string harus sama persis dengan salah satu format yang ditentukan.

public:
 static TimeSpan ParseExact(System::String ^ input, cli::array <System::String ^> ^ formats, IFormatProvider ^ formatProvider);

public static TimeSpan ParseExact (string input, string[] formats, IFormatProvider formatProvider);

public static TimeSpan ParseExact (string input, string[] formats, IFormatProvider? formatProvider);

static member ParseExact : string * string[] * IFormatProvider -> TimeSpan

Public Shared Function ParseExact (input As String, formats As String(), formatProvider As IFormatProvider) As TimeSpan

Parameter

input: String

String yang menentukan interval waktu untuk dikonversi.

formats: String[]

Array string format standar atau kustom yang menentukan format yang diperlukan dari input.

formatProvider: IFormatProvider

Objek yang menyediakan informasi pemformatan khusus budaya.

Mengembalikan

TimeSpan

Interval waktu yang sesuai dengan input, seperti yang ditentukan oleh formats dan formatProvider.

Pengecualian

ArgumentNullException

inputadalah null.

FormatException

input memiliki format yang tidak valid.

OverflowException

input mewakili angka yang kurang dari TimeSpan.MinValue atau lebih besar dari TimeSpan.MaxValue.

-atau-

Setidaknya salah satu komponen hari, jam, menit, atau detik berada di input luar rentang yang valid.

Contoh

Contoh berikut memanggil ParseExact(String, String[], IFormatProvider) metode untuk mengonversi setiap elemen array string menjadi TimeSpan nilai. Contoh ini menafsirkan string menggunakan konvensi pemformatan budaya Prancis - Prancis ("fr-FR"). String dapat mewakili interval waktu dalam format pendek umum atau format panjang umum.

using System;
using System.Globalization;

public class Example
{
   public static void Main()
   {
      string[] inputs = { "3", "16:42", "1:6:52:35.0625", 
                          "1:6:52:35,0625" }; 
      string[] formats = { "g", "G", "%h"};
      TimeSpan interval;
      CultureInfo culture = new CultureInfo("fr-FR");
      
      // Parse each string in inputs using formats and the fr-FR culture.
      foreach (string input in inputs) {
         try {
            interval = TimeSpan.ParseExact(input, formats, culture);
            Console.WriteLine("{0} --> {1:c}", input, interval);
         }
         catch (FormatException) {
            Console.WriteLine("{0} --> Bad Format", input);
         }      
         catch (OverflowException) {
            Console.WriteLine("{0} --> Overflow", input);   
         }            
      }
   }
}
// The example displays the following output:
//       3 --> 03:00:00
//       16:42 --> 16:42:00
//       1:6:52:35.0625 --> Bad Format
//       1:6:52:35,0625 --> 1.06:52:35.0625000

open System
open System.Globalization

let inputs = [| "3"; "16:42"; "1:6:52:35.0625"; "1:6:52:35,0625" |] 
let formats = [| "g"; "G"; "%h" |]
let culture = CultureInfo "fr-FR"

// Parse each string in inputs using formats and the fr-FR culture.
for input in inputs do
    try
        let interval = TimeSpan.ParseExact(input, formats, culture)
        printfn $"{input} --> {interval:c}"
    with
    | :? FormatException ->
        printfn $"{input} --> Bad Format"
    | :? OverflowException ->
        printfn $"{input} --> Overflow"
// The example displays the following output:
//       3 --> 03:00:00
//       16:42 --> 16:42:00
//       1:6:52:35.0625 --> Bad Format
//       1:6:52:35,0625 --> 1.06:52:35.0625000

Imports System.Globalization

Module Example
   Public Sub Main()
      Dim inputs() As String = { "3", "16:42", "1:6:52:35.0625", 
                                 "1:6:52:35,0625" } 
      Dim formats() As String = { "%h", "g", "G" }
      Dim interval As TimeSpan
      Dim culture As New CultureInfo("fr-FR")
      
      ' Parse each string in inputs using formats and the fr-FR culture.
      For Each input As String In inputs
         Try
            interval = TimeSpan.ParseExact(input, formats, culture)
            Console.WriteLine("{0} --> {1:c}", input, interval)   
         Catch e As FormatException
            Console.WriteLine("{0} --> Bad Format", input)   
         Catch e As OverflowException
            Console.WriteLine("{0} --> Overflow", input)   
         End Try            
      Next
   End Sub
End Module
' The example displays the following output:
'       3 --> 3.00:00:00
'       16:42 --> 16:42:00
'       1:6:52:35.0625 --> Bad Format
'       1:6:52:35,0625 --> 1.06:52:35.0625000

Keterangan

Metode ini ParseExact(String, String, IFormatProvider) menguraikan representasi string dari interval waktu, yang harus dalam salah satu format yang ditentukan oleh formats parameter, kecuali bahwa karakter spasi putih di depan dan di belakang diabaikan. Karena input harus sesuai dengan salah satu format yang ditentukan dalam formats, Anda harus selalu menggunakan penanganan pengecualian saat mengonversi input string oleh pengguna ke interval waktu. Jika Anda lebih suka tidak menggunakan penanganan pengecualian, Anda dapat memanggil metode sebagai gantinya TryParseExact(String, String[], IFormatProvider, TimeSpan) .

Parameter formats adalah array string yang elemennya terdiri dari penentu format standar tunggal, atau satu atau beberapa penentu format kustom yang menentukan format yang diperlukan dari input. Untuk informasi selengkapnya tentang string format yang valid, lihat String Format Rentang Waktu Standar dan String Format Rentang Waktu Kustom. input harus sesuai persis dengan anggota agar operasi penguraian formats berhasil. Operasi penguraian mencoba mencocokkan input dengan setiap elemen dalam formats dimulai dengan elemen pertama dalam array.

Penting

Objek CultureInfo yang mewakili budaya yang konvensi pemformatannya akan tercermin dalam string yang dikembalikan. Objek DateTimeFormatInfo yang CultureInfo.DateTimeFormat dikembalikan oleh properti menentukan pemformatan string yang dikembalikan.
Objek DateTimeFormatInfo yang menentukan pemformatan string yang dikembalikan.
Objek kustom yang mengimplementasikan IFormatProvider antarmuka. Metodenya IFormatProvider.GetFormat mengembalikan DateTimeFormatInfo objek yang menyediakan informasi pemformatan.

Jika formatProvider adalah null, DateTimeFormatInfo objek yang terkait dengan budaya saat ini digunakan.

Lihat juga

Berlaku untuk

ParseExact(String, String, IFormatProvider)

Sumber:: TimeSpan.cs

Sumber:: TimeSpan.cs

Sumber:: TimeSpan.cs

Mengonversi representasi string interval waktu menjadi TimeSpan setara dengan menggunakan format yang ditentukan dan informasi format khusus budaya. Format representasi string harus sama persis dengan format yang ditentukan.

public:
 static TimeSpan ParseExact(System::String ^ input, System::String ^ format, IFormatProvider ^ formatProvider);

public static TimeSpan ParseExact (string input, string format, IFormatProvider formatProvider);

public static TimeSpan ParseExact (string input, string format, IFormatProvider? formatProvider);

static member ParseExact : string * string * IFormatProvider -> TimeSpan

Public Shared Function ParseExact (input As String, format As String, formatProvider As IFormatProvider) As TimeSpan

Parameter

input: String

String yang menentukan interval waktu untuk dikonversi.

format: String

String format standar atau kustom yang menentukan format yang diperlukan dari input.

formatProvider: IFormatProvider

Objek yang menyediakan informasi pemformatan khusus budaya.

Mengembalikan

TimeSpan

Interval waktu yang sesuai dengan input, seperti yang ditentukan oleh format dan formatProvider.

Pengecualian

ArgumentNullException

inputadalah null.

FormatException

input memiliki format yang tidak valid.

OverflowException

input mewakili angka yang kurang dari TimeSpan.MinValue atau lebih besar dari TimeSpan.MaxValue.

-atau-

Setidaknya salah satu komponen hari, jam, menit, atau detik berada di input luar rentang yang valid.

Contoh

Contoh berikut menggunakan ParseExact(String, String, IFormatProvider) metode untuk mengurai beberapa representasi string interval waktu menggunakan berbagai string format dan budaya.

using System;
using System.Globalization;

public class Example
{
   public static void Main()
   {
      string intervalString, format;
      TimeSpan interval;
      CultureInfo culture;
      
      // Parse hour:minute value with "g" specifier current culture.
      intervalString = "17:14";
      format = "g";
      culture = CultureInfo.CurrentCulture;
      try {
         interval = TimeSpan.ParseExact(intervalString, format, culture);
         Console.WriteLine("'{0}' --> {1}", intervalString, interval);
      }
      catch (FormatException) {
         Console.WriteLine("'{0}': Bad Format for '{1}'", 
                           intervalString, format);
      }                     
      catch (OverflowException) {
         Console.WriteLine("'{0}': Overflow", intervalString);
      }      
      
      // Parse hour:minute:second value with "G" specifier.
      intervalString = "17:14:48";
      format = "G";
      culture = CultureInfo.InvariantCulture;
      try {
         interval = TimeSpan.ParseExact(intervalString, format, culture);
         Console.WriteLine("'{0}' --> {1}", intervalString, interval);
      }
      catch (FormatException) {
         Console.WriteLine("'{0}': Bad Format for '{1}'", intervalString, format);
      }   
      catch (OverflowException) {
         Console.WriteLine("'{0}': Overflow", intervalString);
      } 
      
      // Parse hours:minute.second value with "G" specifier 
      // and current (en-US) culture.     
      intervalString = "17:14:48.153";
      format = "G";
      culture = CultureInfo.CurrentCulture;
      try {
         interval = TimeSpan.ParseExact(intervalString, format, culture);
         Console.WriteLine("'{0}' --> {1}", intervalString, interval);
      }   
      catch (FormatException) {
         Console.WriteLine("'{0}': Bad Format for '{1}'", intervalString, format);
      }
      catch (OverflowException) {
         Console.WriteLine("'{0}': Overflow", intervalString);
      } 

      // Parse days:hours:minute.second value with "G" specifier 
      // and current (en-US) culture.     
      intervalString = "3:17:14:48.153";
      format = "G";
      culture = CultureInfo.CurrentCulture;
      try {
         interval = TimeSpan.ParseExact(intervalString, format, culture);
         Console.WriteLine("'{0}' --> {1}", intervalString, interval);
      }   
      catch (FormatException) {
         Console.WriteLine("'{0}': Bad Format for '{1}'", intervalString, format);
      }   
      catch (OverflowException) {
         Console.WriteLine("'{0}': Overflow", intervalString);
      } 
            
      // Parse days:hours:minute.second value with "G" specifier 
      // and fr-FR culture.     
      intervalString = "3:17:14:48.153";
      format = "G";
      culture = new CultureInfo("fr-FR");
      try {
         interval = TimeSpan.ParseExact(intervalString, format, culture);
         Console.WriteLine("'{0}' --> {1}", intervalString, interval);
      }
      catch (FormatException) {
         Console.WriteLine("'{0}': Bad Format for '{1}'", intervalString, format);
      }
      catch (OverflowException) {
         Console.WriteLine("'{0}': Overflow", intervalString);
      } 
      
      // Parse days:hours:minute.second value with "G" specifier 
      // and fr-FR culture.     
      intervalString = "3:17:14:48,153";
      format = "G";
      try {
         interval = TimeSpan.ParseExact(intervalString, format, culture);
         Console.WriteLine("'{0}' --> {1}", intervalString, interval);
      }   
      catch (FormatException) {
         Console.WriteLine("'{0}': Bad Format for '{1}'", intervalString, format);
      }
      catch (OverflowException) {
         Console.WriteLine("'{0}': Overflow", intervalString);
      } 

      // Parse a single number using the "c" standard format string. 
      intervalString = "12";
      format = "c";
      try {
         interval = TimeSpan.ParseExact(intervalString, format, null);
         Console.WriteLine("'{0}' --> {1}", intervalString, interval);
      }
      catch (FormatException) {
         Console.WriteLine("'{0}': Bad Format for '{1}'", intervalString, format);
      }
      catch (OverflowException) {
         Console.WriteLine("'{0}': Overflow", intervalString);
      } 
      
      // Parse a single number using the "%h" custom format string. 
      format = "%h";
      try {
         interval = TimeSpan.ParseExact(intervalString, format, null);
         Console.WriteLine("'{0}' --> {1}", intervalString, interval);
      }
      catch (FormatException) {
         Console.WriteLine("'{0}': Bad Format for '{1}'", intervalString, format);
      }
      catch (OverflowException) {
         Console.WriteLine("'{0}': Overflow", intervalString);
      } 
      
      // Parse a single number using the "%s" custom format string. 
      format = "%s";
      try {
         interval = TimeSpan.ParseExact(intervalString, format, null);
         Console.WriteLine("'{0}' --> {1}", intervalString, interval);
      }
      catch (FormatException) {
         Console.WriteLine("'{0}': Bad Format for '{1}'", intervalString, format);
      }
      catch (OverflowException) {
         Console.WriteLine("'{0}': Overflow", intervalString);
      }
   }
}
// The example displays the following output:
//       '17:14' --> 17:14:00
//       '17:14:48': Bad Format for 'G'
//       '17:14:48.153': Bad Format for 'G'
//       '3:17:14:48.153' --> 3.17:14:48.1530000
//       '3:17:14:48.153': Bad Format for 'G'
//       '3:17:14:48,153' --> 3.17:14:48.1530000
//       '12' --> 12.00:00:00
//       '12' --> 12:00:00
//       '12' --> 00:00:12

open System
open System.Globalization

do
    // Parse hour:minute value with "g" specifier current culture.
    let intervalString = "17:14"
    let format = "g"
    let culture = CultureInfo.CurrentCulture
    try
        let interval = TimeSpan.ParseExact(intervalString, format, culture)
        printfn $"'{intervalString}' --> {interval}"
    with 
    | :? FormatException ->
        printfn $"'{intervalString}': Bad Format for '{format}'"
    | :? OverflowException ->
        printfn $"'{intervalString}': Overflow"
    
    // Parse hour:minute:second value with "G" specifier.
    let intervalString = "17:14:48"
    let format = "G"
    let culture = CultureInfo.InvariantCulture
    try
        let interval = TimeSpan.ParseExact(intervalString, format, culture)
        printfn $"'{intervalString}' --> {interval}"
    with
    | :? FormatException ->
        printfn $"'{intervalString}': Bad Format for '{format}'"
    | :? OverflowException ->
        printfn $"'{intervalString}': Overflow"
    
    // Parse hours:minute.second value with "G" specifier 
    // and current (en-US) culture.     
    let intervalString = "17:14:48.153"
    let format = "G"
    let culture = CultureInfo.CurrentCulture
    try
        let interval = TimeSpan.ParseExact(intervalString, format, culture)
        printfn $"'{intervalString}' --> {interval}"
    with 
    | :? FormatException ->
        printfn $"'{intervalString}': Bad Format for '{format}'"
    | :? OverflowException ->
        printfn $"'{intervalString}': Overflow"

    // Parse days:hours:minute.second value with "G" specifier 
    // and current (en-US) culture.     
    let intervalString = "3:17:14:48.153"
    let format = "G"
    let culture = CultureInfo.CurrentCulture
    try
        let interval = TimeSpan.ParseExact(intervalString, format, culture)
        printfn $"'{intervalString}' --> {interval}"
    with 
    | :? FormatException ->
        printfn $"'{intervalString}': Bad Format for '{format}'"
    | :? OverflowException ->
        printfn $"'{intervalString}': Overflow"
        
    // Parse days:hours:minute.second value with "G" specifier 
    // and fr-FR culture.     
    let intervalString = "3:17:14:48.153"
    let format = "G"
    let culture = CultureInfo "fr-FR"
    try
        let interval = TimeSpan.ParseExact(intervalString, format, culture)
        printfn $"'{intervalString}' --> {interval}"
    with 
    | :? FormatException ->
        printfn $"'{intervalString}': Bad Format for '{format}'"
    | :? OverflowException ->
        printfn $"'{intervalString}': Overflow"
    
    // Parse days:hours:minute.second value with "G" specifier 
    // and fr-FR culture.     
    let intervalString = "3:17:14:48,153"
    let format = "G"
    try
        let interval = TimeSpan.ParseExact(intervalString, format, culture)
        printfn $"'{intervalString}' --> {interval}"
    with 
    | :? FormatException ->
        printfn $"'{intervalString}': Bad Format for '{format}'"
    | :? OverflowException ->
        printfn $"'{intervalString}': Overflow"

    // Parse a single number using the "c" standard format string. 
    let intervalString = "12"
    let format = "c"
    try
        let interval = TimeSpan.ParseExact(intervalString, format, null)
        printfn $"'{intervalString}' --> {interval}"
    with
    | :? FormatException ->
        printfn $"'{intervalString}': Bad Format for '{format}'"
    | :? OverflowException ->
        printfn $"'{intervalString}': Overflow"
    
    // Parse a single number using the "%h" custom format string. 
    let format = "%h"
    try
        let interval = TimeSpan.ParseExact(intervalString, format, null)
        printfn $"'{intervalString}' --> {interval}"
    with 
    | :? FormatException ->
        printfn $"'{intervalString}': Bad Format for '{format}'"
    | :? OverflowException ->
        printfn $"'{intervalString}': Overflow"
    
    // Parse a single number using the "%s" custom format string. 
    let format = "%s"
    try
        let interval = TimeSpan.ParseExact(intervalString, format, null)
        printfn $"'{intervalString}' --> {interval}"
    with 
    | :? FormatException ->
        printfn $"'{intervalString}': Bad Format for '{format}'"
    | :? OverflowException ->
        printfn $"'{intervalString}': Overflow"
// The example displays the following output:
//       '17:14' --> 17:14:00
//       '17:14:48': Bad Format for 'G'
//       '17:14:48.153': Bad Format for 'G'
//       '3:17:14:48.153' --> 3.17:14:48.1530000
//       '3:17:14:48.153': Bad Format for 'G'
//       '3:17:14:48,153' --> 3.17:14:48.1530000
//       '12' --> 12.00:00:00
//       '12' --> 12:00:00
//       '12' --> 00:00:12

Imports System.Globalization

Module Example
   Public Sub Main()
      Dim intervalString, format As String
      Dim interval As TimeSpan
      Dim culture As CultureInfo
      
      ' Parse hour:minute value with "g" specifier current culture.
      intervalString = "17:14"
      format = "g"
      culture = CultureInfo.CurrentCulture
      Try
         interval = TimeSpan.ParseExact(intervalString, format, culture)
         Console.WriteLine("'{0}' --> {1}", intervalString, interval)
      Catch e As FormatException
         Console.WriteLine("'{0}': Bad Format for '{1}'", intervalString, format)
      Catch e As OverflowException
         Console.WriteLine("'{0}': Overflow", intervalString)
      End Try      
      
      ' Parse hour:minute:second value with "G" specifier.
      intervalString = "17:14:48"
      format = "G"
      culture = CultureInfo.InvariantCulture
      Try
         interval = TimeSpan.ParseExact(intervalString, format, culture)
         Console.WriteLine("'{0}' --> {1}", intervalString, interval)
      Catch e As FormatException
         Console.WriteLine("'{0}': Bad Format for '{1}'", intervalString, format)
      Catch e As OverflowException
         Console.WriteLine("'{0}': Overflow", intervalString)
      End Try 
      
      ' Parse hours:minute.second value with "G" specifier 
      ' and current (en-US) culture.     
      intervalString = "17:14:48.153"
      format = "G"
      culture = CultureInfo.CurrentCulture
      Try
         interval = TimeSpan.ParseExact(intervalString, format, culture)
         Console.WriteLine("'{0}' --> {1}", intervalString, interval)
      Catch e As FormatException
         Console.WriteLine("'{0}': Bad Format for '{1}'", intervalString, format)
      Catch e As OverflowException
         Console.WriteLine("'{0}': Overflow", intervalString)
      End Try 

      ' Parse days:hours:minute.second value with "G" specifier 
      ' and current (en-US) culture.     
      intervalString = "3:17:14:48.153"
      format = "G"
      culture = CultureInfo.CurrentCulture
      Try
         interval = TimeSpan.ParseExact(intervalString, format, culture)
         Console.WriteLine("'{0}' --> {1}", intervalString, interval)
      Catch e As FormatException
         Console.WriteLine("'{0}': Bad Format for '{1}'", intervalString, format)
      Catch e As OverflowException
         Console.WriteLine("'{0}': Overflow", intervalString)
      End Try 
            
      ' Parse days:hours:minute.second value with "G" specifier 
      ' and fr-FR culture.     
      intervalString = "3:17:14:48.153"
      format = "G"
      culture = New CultureInfo("fr-FR")
      Try
         interval = TimeSpan.ParseExact(intervalString, format, culture)
         Console.WriteLine("'{0}' --> {1}", intervalString, interval)
      Catch e As FormatException
         Console.WriteLine("'{0}': Bad Format for '{1}'", intervalString, format)
      Catch e As OverflowException
         Console.WriteLine("'{0}': Overflow", intervalString)
      End Try 
      
      ' Parse days:hours:minute.second value with "G" specifier 
      ' and fr-FR culture.     
      intervalString = "3:17:14:48,153"
      format = "G"
      culture = New CultureInfo("fr-FR")
      Try
         interval = TimeSpan.ParseExact(intervalString, format, culture)
         Console.WriteLine("'{0}' --> {1}", intervalString, interval)
      Catch e As FormatException
         Console.WriteLine("'{0}': Bad Format for '{1}'", intervalString, format)
      Catch e As OverflowException
         Console.WriteLine("'{0}': Overflow", intervalString)
      End Try 

      ' Parse a single number using the "c" standard format string. 
      intervalString = "12"
      format = "c"
      Try
         interval = TimeSpan.ParseExact(intervalString, format, Nothing)
         Console.WriteLine("'{0}' --> {1}", intervalString, interval)
      Catch e As FormatException
         Console.WriteLine("'{0}': Bad Format for '{1}'", intervalString, format)
      Catch e As OverflowException
         Console.WriteLine("'{0}': Overflow", intervalString)
      End Try 
      
      ' Parse a single number using the "%h" custom format string. 
      format = "%h"
      Try
         interval = TimeSpan.ParseExact(intervalString, format, Nothing)
         Console.WriteLine("'{0}' --> {1}", intervalString, interval)
      Catch e As FormatException
         Console.WriteLine("'{0}': Bad Format for '{1}'", intervalString, format)
      Catch e As OverflowException
         Console.WriteLine("'{0}': Overflow", intervalString)
      End Try 
      
      ' Parse a single number using the "%s" custom format string. 
      format = "%s"
      Try
         interval = TimeSpan.ParseExact(intervalString, format, Nothing)
         Console.WriteLine("'{0}' --> {1}", intervalString, interval)
      Catch e As FormatException
         Console.WriteLine("'{0}': Bad Format for '{1}'", intervalString, format)
      Catch e As OverflowException
         Console.WriteLine("'{0}': Overflow", intervalString)
      End Try 
   End Sub
End Module
' The example displays the following output:
'       '17:14' --> 17:14:00
'       '17:14:48': Bad Format for 'G'
'       '17:14:48.153': Bad Format for 'G'
'       '3:17:14:48.153' --> 3.17:14:48.1530000
'       '3:17:14:48.153': Bad Format for 'G'
'       '3:17:14:48,153' --> 3.17:14:48.1530000
'       '12' --> 12.00:00:00
'       '12' --> 12:00:00
'       '12' --> 00:00:12

Keterangan

Metode ini ParseExact(String, String, IFormatProvider) menguraikan representasi string dari interval waktu, yang harus dalam format yang ditentukan oleh format parameter, kecuali bahwa karakter spasi putih di awal dan akhir diabaikan. Karena input harus sesuai dengan format format persis, Anda harus selalu menggunakan penanganan pengecualian saat mengonversi input string oleh pengguna ke interval waktu. Jika Anda lebih suka tidak menggunakan penanganan pengecualian, Anda dapat memanggil metode sebagai gantinya TryParseExact(String, String, IFormatProvider, TimeSpan) .

Parameter format adalah string yang berisi penentu format standar tunggal, atau satu atau beberapa penentu format kustom yang menentukan format yang diperlukan dari input. Untuk informasi selengkapnya tentang string format yang valid, lihat String Format Rentang Waktu Standar dan String Format Rentang Waktu Kustom.

Penting

Objek CultureInfo yang mewakili budaya yang konvensi pemformatannya akan tercermin dalam string yang dikembalikan. Objek DateTimeFormatInfo yang CultureInfo.DateTimeFormat dikembalikan oleh properti menentukan pemformatan string yang dikembalikan.
Objek DateTimeFormatInfo yang menentukan pemformatan string yang dikembalikan.
Objek kustom yang mengimplementasikan IFormatProvider antarmuka. Metodenya IFormatProvider.GetFormat mengembalikan DateTimeFormatInfo objek yang menyediakan informasi pemformatan.

Jika formatProvider adalah null, DateTimeFormatInfo objek yang terkait dengan budaya saat ini digunakan.

Lihat juga

Berlaku untuk

ParseExact(ReadOnlySpan<Char>, ReadOnlySpan<Char>, IFormatProvider, TimeSpanStyles)

Sumber:: TimeSpan.cs

Sumber:: TimeSpan.cs

Sumber:: TimeSpan.cs

Mengonversi rentang karakter interval waktu menjadi TimeSpan setara dengan menggunakan format yang ditentukan dan informasi format khusus budaya. Format representasi string harus sama persis dengan format yang ditentukan.

public static TimeSpan ParseExact (ReadOnlySpan<char> input, ReadOnlySpan<char> format, IFormatProvider? formatProvider, System.Globalization.TimeSpanStyles styles = System.Globalization.TimeSpanStyles.None);

public static TimeSpan ParseExact (ReadOnlySpan<char> input, ReadOnlySpan<char> format, IFormatProvider formatProvider, System.Globalization.TimeSpanStyles styles = System.Globalization.TimeSpanStyles.None);

static member ParseExact : ReadOnlySpan<char> * ReadOnlySpan<char> * IFormatProvider * System.Globalization.TimeSpanStyles -> TimeSpan

Public Shared Function ParseExact (input As ReadOnlySpan(Of Char), format As ReadOnlySpan(Of Char), formatProvider As IFormatProvider, Optional styles As TimeSpanStyles = System.Globalization.TimeSpanStyles.None) As TimeSpan

Parameter

input: ReadOnlySpan<Char>

Rentang yang menentukan interval waktu untuk dikonversi.

format: ReadOnlySpan<Char>

String format standar atau kustom yang menentukan format yang diperlukan dari input.

formatProvider: IFormatProvider

Objek yang menyediakan informasi pemformatan khusus budaya.

styles: TimeSpanStyles

Kombinasi bitwise dari nilai enumerasi yang menentukan elemen gaya yang mungkin ada di input.

Mengembalikan

TimeSpan

Interval waktu yang sesuai dengan input, seperti yang ditentukan oleh format dan formatProvider.

Berlaku untuk

TimeSpan.ParseExact Metode

Definisi

Overload

ParseExact(String, String[], IFormatProvider, TimeSpanStyles)

Parameter

Mengembalikan

Pengecualian

Contoh

Keterangan

Lihat juga

Berlaku untuk

ParseExact(String, String, IFormatProvider, TimeSpanStyles)

Parameter

Mengembalikan

Pengecualian

Contoh

Keterangan

Lihat juga

Berlaku untuk

ParseExact(ReadOnlySpan<Char>, String[], IFormatProvider, TimeSpanStyles)

Parameter

Mengembalikan

Berlaku untuk

ParseExact(String, String[], IFormatProvider)

Parameter

Mengembalikan

Pengecualian

Contoh

Keterangan

Lihat juga

Berlaku untuk

ParseExact(String, String, IFormatProvider)

Parameter

Mengembalikan

Pengecualian

Contoh

Keterangan

Lihat juga

Berlaku untuk

ParseExact(ReadOnlySpan<Char>, ReadOnlySpan<Char>, IFormatProvider, TimeSpanStyles)

Parameter

Mengembalikan

Berlaku untuk

Saran dan Komentar

Sumber Daya Tambahan: