TimeSpan.TryParseExact 方法
定義
重要
部分資訊涉及發行前產品,在發行之前可能會有大幅修改。 Microsoft 對此處提供的資訊,不做任何明確或隱含的瑕疵擔保。
將時間間隔的字串表示,轉換為其相等的 TimeSpan,並傳回一個值表示轉換是否成功。 字串表示的格式必須完全符合指定的格式。
多載
TryParseExact(String, String, IFormatProvider, TimeSpanStyles, TimeSpan)
- 來源:
- TimeSpan.cs
- 來源:
- TimeSpan.cs
- 來源:
- TimeSpan.cs
使用指定的格式、文化特性專屬格式資訊及樣式,將時間間隔的指定字串表示法轉換成對等的 TimeSpan。 字串表示的格式必須完全符合指定的格式。
public:
static bool TryParseExact(System::String ^ input, System::String ^ format, IFormatProvider ^ formatProvider, System::Globalization::TimeSpanStyles styles, [Runtime::InteropServices::Out] TimeSpan % result);
public static bool TryParseExact (string input, string format, IFormatProvider formatProvider, System.Globalization.TimeSpanStyles styles, out TimeSpan result);
public static bool TryParseExact (string? input, string? format, IFormatProvider? formatProvider, System.Globalization.TimeSpanStyles styles, out TimeSpan result);
public static bool TryParseExact (string? input, string format, IFormatProvider? formatProvider, System.Globalization.TimeSpanStyles styles, out TimeSpan result);
static member TryParseExact : string * string * IFormatProvider * System.Globalization.TimeSpanStyles * TimeSpan -> bool
Public Shared Function TryParseExact (input As String, format As String, formatProvider As IFormatProvider, styles As TimeSpanStyles, ByRef result As TimeSpan) As Boolean
參數
- input
- String
字串,指定要轉換的時間間隔。
- format
- String
標準或自訂格式字串,其定義 input
的必要格式。
- formatProvider
- IFormatProvider
物件,提供特定文化特性格式資訊。
- styles
- TimeSpanStyles
一或多個列舉值,這些值會指出 input
的樣式。
傳回
如果 input
轉換成功,則為 true
,否則為 false
。
範例
下列範例會 ParseExact(String, String, IFormatProvider) 使用 方法,使用各種格式字串和文化特性剖析數個時間間隔的字串表示。 它也會使用 TimeSpanStyles.AssumeNegative 值將每個字串解譯為負時間間隔。 範例的輸出說明只有在 TimeSpanStyles.AssumeNegative 搭配自定義格式字串使用樣式時,樣式才會影響傳回值。
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;
if (TimeSpan.TryParseExact(intervalString, format,
culture, TimeSpanStyles.AssumeNegative, out interval))
Console.WriteLine("'{0}' ({1}) --> {2}", intervalString, format, interval);
else
Console.WriteLine("Unable to parse '{0}' using format {1}",
intervalString, format);
// Parse hour:minute:second value with "g" specifier.
intervalString = "17:14:48";
format = "g";
culture = CultureInfo.InvariantCulture;
if (TimeSpan.TryParseExact(intervalString, format,
culture, TimeSpanStyles.AssumeNegative, out interval))
Console.WriteLine("'{0}' ({1}) --> {2}", intervalString, format, interval);
else
Console.WriteLine("Unable to parse '{0}' using format {1}",
intervalString, format);
// Parse hours:minute.second value with custom format specifier.
intervalString = "17:14:48.153";
format = @"h\:mm\:ss\.fff";
culture = null;
if (TimeSpan.TryParseExact(intervalString, format,
culture, TimeSpanStyles.AssumeNegative, out interval))
Console.WriteLine("'{0}' ({1}) --> {2}", intervalString, format, interval);
else
Console.WriteLine("Unable to parse '{0}' using format {1}",
intervalString, format);
// 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;
if (TimeSpan.TryParseExact(intervalString, format,
culture, TimeSpanStyles.AssumeNegative, out interval))
Console.WriteLine("'{0}' ({1}) --> {2}", intervalString, format, interval);
else
Console.WriteLine("Unable to parse '{0}' using format {1}",
intervalString, format);
// 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;
if (TimeSpan.TryParseExact(intervalString, format,
culture, TimeSpanStyles.AssumeNegative, out interval))
Console.WriteLine("'{0}' ({1}) --> {2}", intervalString, format, interval);
else
Console.WriteLine("Unable to parse '{0}' using format {1}",
intervalString, format);
// 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");
if (TimeSpan.TryParseExact(intervalString, format,
culture, TimeSpanStyles.AssumeNegative, out interval))
Console.WriteLine("'{0}' ({1}) --> {2}", intervalString, format, interval);
else
Console.WriteLine("Unable to parse '{0}' using format {1}",
intervalString, format);
// Parse a single number using the "c" standard format string.
intervalString = "12";
format = "c";
if (TimeSpan.TryParseExact(intervalString, format,
null, TimeSpanStyles.AssumeNegative, out interval))
Console.WriteLine("'{0}' ({1}) --> {2}", intervalString, format, interval);
else
Console.WriteLine("Unable to parse '{0}' using format {1}",
intervalString, format);
// Parse a single number using the "%h" custom format string.
format = "%h";
if (TimeSpan.TryParseExact(intervalString, format,
null, TimeSpanStyles.AssumeNegative, out interval))
Console.WriteLine("'{0}' ({1}) --> {2}", intervalString, format, interval);
else
Console.WriteLine("Unable to parse '{0}' using format {1}",
intervalString, format);
// Parse a single number using the "%s" custom format string.
format = "%s";
if (TimeSpan.TryParseExact(intervalString, format,
null, TimeSpanStyles.AssumeNegative, out interval))
Console.WriteLine("'{0}' ({1}) --> {2}", intervalString, format, interval);
else
Console.WriteLine("Unable to parse '{0}' using format {1}",
intervalString, format);
}
}
// 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
match TimeSpan.TryParseExact(intervalString, format, culture, TimeSpanStyles.AssumeNegative) with
| true, interval ->
printfn $"'{intervalString}' ({format}) --> {interval}"
| _ ->
printfn $"Unable to parse '{intervalString}' using format {format}"
// Parse hour:minute:second value with "g" specifier.
let intervalString = "17:14:48"
let format = "g"
let culture = CultureInfo.InvariantCulture
match TimeSpan.TryParseExact(intervalString, format, culture, TimeSpanStyles.AssumeNegative) with
| true, interval ->
printfn $"'{intervalString}' ({format}) --> {interval}"
| _ ->
printfn $"Unable to parse '{intervalString}' using format {format}"
// Parse hours:minute.second value with custom format specifier.
let intervalString = "17:14:48.153"
let format = @"h\:mm\:ss\.fff"
let culture = null
match TimeSpan.TryParseExact(intervalString, format, culture, TimeSpanStyles.AssumeNegative) with
| true, interval ->
printfn $"'{intervalString}' ({format}) --> {interval}"
| _ ->
printfn $"Unable to parse '{intervalString}' using format {format}"
// 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
match TimeSpan.TryParseExact(intervalString, format, culture, TimeSpanStyles.AssumeNegative) with
| true, interval ->
printfn $"'{intervalString}' ({format}) --> {interval}"
| _ ->
printfn $"Unable to parse '{intervalString}' using format {format}"
// 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
match TimeSpan.TryParseExact(intervalString, format, culture, TimeSpanStyles.AssumeNegative) with
| true, interval ->
printfn $"'{intervalString}' ({format}) --> {interval}"
| _ ->
printfn $"Unable to parse '{intervalString}' using format {format}"
// 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")
match TimeSpan.TryParseExact(intervalString, format, culture, TimeSpanStyles.AssumeNegative) with
| true, interval ->
printfn $"'{intervalString}' ({format}) --> {interval}"
| _ ->
printfn $"Unable to parse '{intervalString}' using format {format}"
// Parse a single number using the "c" standard format string.
let intervalString = "12"
let format = "c"
match TimeSpan.TryParseExact(intervalString, format, null, TimeSpanStyles.AssumeNegative) with
| true, interval ->
printfn $"'{intervalString}' ({format}) --> {interval}"
| _ ->
printfn $"Unable to parse '{intervalString}' using format {format}"
// Parse a single number using the "%h" custom format string.
let format = "%h"
match TimeSpan.TryParseExact(intervalString, format, null, TimeSpanStyles.AssumeNegative) with
| true, interval ->
printfn $"'{intervalString}' ({format}) --> {interval}"
| _ ->
printfn $"Unable to parse '{intervalString}' using format {format}"
// Parse a single number using the "%s" custom format string.
let format = "%s"
match TimeSpan.TryParseExact(intervalString, format, null, TimeSpanStyles.AssumeNegative) with
| true, interval ->
printfn $"'{intervalString}' ({format}) --> {interval}"
| _ ->
printfn $"Unable to parse '{intervalString}' using format {format}"
// 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
If TimeSpan.TryParseExact(intervalString, format,
culture, TimeSpanStyles.AssumeNegative, interval) Then
Console.WriteLine("'{0}' ({1}) --> {2}", intervalString, format, interval)
Else
Console.WriteLine("Unable to parse '{0}' using format {1}",
intervalString, format)
End If
' Parse hour:minute:second value with "g" specifier.
intervalString = "17:14:48"
format = "g"
culture = CultureInfo.InvariantCulture
If TimeSpan.TryParseExact(intervalString, format,
culture, TimeSpanStyles.AssumeNegative, interval) Then
Console.WriteLine("'{0}' ({1}) --> {2}", intervalString, format, interval)
Else
Console.WriteLine("Unable to parse '{0}' using format {1}",
intervalString, format)
End If
' Parse hours:minute.second value with custom format specifier.
intervalString = "17:14:48.153"
format = "h\:mm\:ss\.fff"
culture = Nothing
If TimeSpan.TryParseExact(intervalString, format,
culture, TimeSpanStyles.AssumeNegative, interval) Then
Console.WriteLine("'{0}' ({1}) --> {2}", intervalString, format, interval)
Else
Console.WriteLine("Unable to parse '{0}' using format {1}",
intervalString, format)
End If
' 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
If TimeSpan.TryParseExact(intervalString, format,
culture, TimeSpanStyles.AssumeNegative, interval) Then
Console.WriteLine("'{0}' ({1}) --> {2}", intervalString, format, interval)
Else
Console.WriteLine("Unable to parse '{0}' using format {1}",
intervalString, format)
End If
' 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
If TimeSpan.TryParseExact(intervalString, format,
culture, TimeSpanStyles.AssumeNegative, interval) Then
Console.WriteLine("'{0}' ({1}) --> {2}", intervalString, format, interval)
Else
Console.WriteLine("Unable to parse '{0}' using format {1}",
intervalString, format)
End If
' 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")
If TimeSpan.TryParseExact(intervalString, format,
culture, TimeSpanStyles.AssumeNegative, interval) Then
Console.WriteLine("'{0}' ({1}) --> {2}", intervalString, format, interval)
Else
Console.WriteLine("Unable to parse '{0}' using format {1}",
intervalString, format)
End If
' Parse a single number using the "c" standard format string.
intervalString = "12"
format = "c"
If TimeSpan.TryParseExact(intervalString, format,
Nothing, TimeSpanStyles.AssumeNegative, interval) Then
Console.WriteLine("'{0}' ({1}) --> {2}", intervalString, format, interval)
Else
Console.WriteLine("Unable to parse '{0}' using format {1}",
intervalString, format)
End If
' Parse a single number using the "%h" custom format string.
format = "%h"
If TimeSpan.TryParseExact(intervalString, format,
Nothing, TimeSpanStyles.AssumeNegative, interval) Then
Console.WriteLine("'{0}' ({1}) --> {2}", intervalString, format, interval)
Else
Console.WriteLine("Unable to parse '{0}' using format {1}",
intervalString, format)
End If
' Parse a single number using the "%s" custom format string.
format = "%s"
If TimeSpan.TryParseExact(intervalString, format,
Nothing, TimeSpanStyles.AssumeNegative, interval) Then
Console.WriteLine("'{0}' ({1}) --> {2}", intervalString, format, interval)
Else
Console.WriteLine("Unable to parse '{0}' using format {1}",
intervalString, format)
End If
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
備註
方法 TryParseExact(String, String, IFormatProvider, TimeSpanStyles, TimeSpan) 會剖析時間間隔的字串表示,其格式必須是 參數所 format
定義的格式,但會忽略前置和尾端空格符。 這個方法與 ParseExact(String, String, IFormatProvider, TimeSpanStyles) 方法類似,不同之處在於,如果轉換失敗,則不會擲回例外狀況。
參數 format
是包含單一標準格式規範的字串,或是定義 必要格式的 input
一或多個自定義格式規範。 如需有效格式字串的詳細資訊,請參閱 標準 TimeSpan 格式字串 和 自定義 TimeSpan 格式字串。
參數 formatProvider
是實作, IFormatProvider 如果 format
是標準格式字串,則提供傳回字串格式的特定文化特性資訊。 參數 formatProvider
可以是下列任一項:
CultureInfo物件,表示格式慣例要反映在傳回字串中的文化特性。 屬性 DateTimeFormatInfo 所 CultureInfo.DateTimeFormat 傳回的物件會定義傳回字串的格式。
DateTimeFormatInfo對象,定義傳回字串的格式。
實作 介面的 IFormatProvider 自定義物件。 其 IFormatProvider.GetFormat 方法會傳回提供 DateTimeFormatInfo 格式化信息的物件。
如果 為 formatProvider
null
,則會 DateTimeFormatInfo 使用與目前文化特性相關聯的物件。
參數 styles
會影響使用自定義格式字串剖析的字串解譯。 它決定 input
只有在負號存在 () TimeSpanStyles.None 時,還是一律解譯為負數時間間隔, (TimeSpanStyles.AssumeNegative) 。 如果未 TimeSpanStyles.AssumeNegative 使用 , format
則必須包含常值負號符號 (,例如 “\-”) ,才能成功剖析負時間間隔。
另請參閱
適用於
TryParseExact(ReadOnlySpan<Char>, String[], IFormatProvider, TimeSpanStyles, TimeSpan)
- 來源:
- TimeSpan.cs
- 來源:
- TimeSpan.cs
- 來源:
- TimeSpan.cs
使用指定的格式、文化特性專屬格式資訊及樣式,將時間間隔的指定範圍表示法轉換成對等的 TimeSpan。 字串表示的格式必須完全符合其中一個指定的格式。
public:
static bool TryParseExact(ReadOnlySpan<char> input, cli::array <System::String ^> ^ formats, IFormatProvider ^ formatProvider, System::Globalization::TimeSpanStyles styles, [Runtime::InteropServices::Out] TimeSpan % result);
public static bool TryParseExact (ReadOnlySpan<char> input, string?[]? formats, IFormatProvider? formatProvider, System.Globalization.TimeSpanStyles styles, out TimeSpan result);
public static bool TryParseExact (ReadOnlySpan<char> input, string[] formats, IFormatProvider formatProvider, System.Globalization.TimeSpanStyles styles, out TimeSpan result);
public static bool TryParseExact (ReadOnlySpan<char> input, string[] formats, IFormatProvider? formatProvider, System.Globalization.TimeSpanStyles styles, out TimeSpan result);
static member TryParseExact : ReadOnlySpan<char> * string[] * IFormatProvider * System.Globalization.TimeSpanStyles * TimeSpan -> bool
Public Shared Function TryParseExact (input As ReadOnlySpan(Of Char), formats As String(), formatProvider As IFormatProvider, styles As TimeSpanStyles, ByRef result As TimeSpan) As Boolean
參數
- input
- ReadOnlySpan<Char>
範圍,其包含代表要轉換時間間隔的字元。
- formats
- String[]
標準或自訂格式字串的陣列,這些格式字串會定義 input
可接受的格式。
- formatProvider
- IFormatProvider
物件,提供特定文化特性格式資訊。
- styles
- TimeSpanStyles
一或多個列舉值,這些值會指出 input
的樣式。
傳回
如果 input
轉換成功,則為 true
,否則為 false
。
適用於
TryParseExact(ReadOnlySpan<Char>, ReadOnlySpan<Char>, IFormatProvider, TimeSpanStyles, TimeSpan)
- 來源:
- TimeSpan.cs
- 來源:
- TimeSpan.cs
- 來源:
- TimeSpan.cs
使用指定格式、特定文件特性格式資訊及樣式,將指定的時間間隔範圍表示轉換為其對等的 TimeSpan,並傳回值以指出轉換是否成功。 字串表示的格式必須完全符合指定的格式。
public:
static bool TryParseExact(ReadOnlySpan<char> input, ReadOnlySpan<char> format, IFormatProvider ^ formatProvider, System::Globalization::TimeSpanStyles styles, [Runtime::InteropServices::Out] TimeSpan % result);
public static bool TryParseExact (ReadOnlySpan<char> input, ReadOnlySpan<char> format, IFormatProvider? formatProvider, System.Globalization.TimeSpanStyles styles, out TimeSpan result);
public static bool TryParseExact (ReadOnlySpan<char> input, ReadOnlySpan<char> format, IFormatProvider formatProvider, System.Globalization.TimeSpanStyles styles, out TimeSpan result);
static member TryParseExact : ReadOnlySpan<char> * ReadOnlySpan<char> * IFormatProvider * System.Globalization.TimeSpanStyles * TimeSpan -> bool
Public Shared Function TryParseExact (input As ReadOnlySpan(Of Char), format As ReadOnlySpan(Of Char), formatProvider As IFormatProvider, styles As TimeSpanStyles, ByRef result As TimeSpan) As Boolean
參數
- input
- ReadOnlySpan<Char>
範圍,其包含代表要轉換時間間隔的字元。
- format
- ReadOnlySpan<Char>
包含字元的範圍,這些字元代表的標準或自訂格式字串會定義 input
可接受的格式。
- formatProvider
- IFormatProvider
物件,提供特定文化特性格式資訊。
- styles
- TimeSpanStyles
一或多個列舉值,這些值會指出 input
的樣式。
傳回
如果 input
轉換成功,則為 true
,否則為 false
。
適用於
TryParseExact(String, String[], IFormatProvider, TimeSpan)
- 來源:
- TimeSpan.cs
- 來源:
- TimeSpan.cs
- 來源:
- TimeSpan.cs
使用指定的格式和文化特性專屬格式資訊,將時間間隔的指定字串表示法轉換成對等的 TimeSpan。 字串表示的格式必須完全符合其中一個指定的格式。
public:
static bool TryParseExact(System::String ^ input, cli::array <System::String ^> ^ formats, IFormatProvider ^ formatProvider, [Runtime::InteropServices::Out] TimeSpan % result);
public static bool TryParseExact (string input, string[] formats, IFormatProvider formatProvider, out TimeSpan result);
public static bool TryParseExact (string? input, string?[]? formats, IFormatProvider? formatProvider, out TimeSpan result);
public static bool TryParseExact (string? input, string[] formats, IFormatProvider? formatProvider, out TimeSpan result);
static member TryParseExact : string * string[] * IFormatProvider * TimeSpan -> bool
Public Shared Function TryParseExact (input As String, formats As String(), formatProvider As IFormatProvider, ByRef result As TimeSpan) As Boolean
參數
- input
- String
字串,指定要轉換的時間間隔。
- formats
- String[]
標準或自訂格式字串的陣列,這些格式字串會定義 input
可接受的格式。
- formatProvider
- IFormatProvider
物件,提供特定文化特性格式資訊。
傳回
如果 input
轉換成功,則為 true
,否則為 false
。
範例
下列範例會呼叫 方法, TryParseExact(String, String[], IFormatProvider, TimeSpan) 將字串陣列的每個項目轉換成 TimeSpan 值。 此範例會使用法文 - 法國 (“fr-FR”) 文化特性的格式慣例來解譯字串。 字串可以代表一般簡短格式或一般長格式的時間間隔。
此外,此範例會變更時間間隔剖析方法解譯單一數位的方式。 一般而言,單一數位會解譯為時間間隔中的天數。 相反地 %h
,自定義格式字串會用來將單一數位解譯為時數。 若要讓這項變更生效,請注意 %h
,自定義格式字串必須位於數位中的其他 formats
格式字串之前。
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) {
if(TimeSpan.TryParseExact(input, formats, culture, out interval))
Console.WriteLine("{0} --> {1:c}", input, interval);
else
Console.WriteLine("Unable to parse {0}", input);
}
}
}
// The example displays the following output:
// 3 --> 03:00:00
// 16:42 --> 16:42:00
// Unable to parse 1:6:52:35.0625
// 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
match TimeSpan.TryParseExact(input, formats, culture) with
| true, interval ->
printfn $"{input} --> {interval:c}"
| _ ->
printfn $"Unable to parse {input}"
// The example displays the following output:
// 3 --> 03:00:00
// 16:42 --> 16:42:00
// Unable to parse 1:6:52:35.0625
// 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
If TimeSpan.TryParseExact(input, formats, culture, interval) Then
Console.WriteLine("{0} --> {1:c}", input, interval)
Else
Console.WriteLine("Unable to parse {0}", input)
End If
Next
End Sub
End Module
' The example displays the following output:
' 3 --> 03:00:00
' 16:42 --> 16:42:00
' Unable to parse 1:6:52:35.0625
' 1:6:52:35,0625 --> 1.06:52:35.0625000
備註
方法 TryParseExact(String, String[], IFormatProvider, TimeSpan) 會剖析時間間隔的字串表示,其格式必須是 參數所 formats
指定的其中一個格式字串所定義,但忽略開頭和尾端空格符。 這個方法與 ParseExact(String, String[], IFormatProvider) 方法類似,不同之處在於,如果轉換失敗,則不會擲回例外狀況。
參數 formats
是字串數位,其元素是由單一標準格式規範所組成,或是定義必要格式的 input
一或多個自定義格式規範。 如需有效格式字串的詳細資訊,請參閱 標準 TimeSpan 格式字串 和 自定義 TimeSpan 格式字串。
input
必須完全符合的成員 formats
,剖析作業才能成功。 剖析作業會嘗試比 input
對陣列中 formats
第一個項目開頭的每個元素。
重要
TryParseExact只有在用來剖input
析的格式字串是值為 「g」 或 「G」 的標準TimeSpan格式字串時,方法才會使用 參數所formatProvider
指定的文化特性慣例。 “c”、“t” 和 “T” 標準格式字串會使用不因文化特性而異的格式慣例。 自訂格式字串會定義輸入字串的精確格式,並使用常值字元分隔時間間隔的元件。
如果用來剖析input
的格式字串是標準格式字串,參數formatProvider
是實IFormatProvider作,可提供傳回字串格式的特定文化特性資訊。 參數 formatProvider
可以是下列任一項:
CultureInfo物件,表示格式慣例要反映在傳回字串中的文化特性。 屬性 DateTimeFormatInfo 所 CultureInfo.DateTimeFormat 傳回的物件會定義傳回字串的格式。
DateTimeFormatInfo對象,定義傳回字串的格式。
實作 介面的 IFormatProvider 自定義物件。 其 IFormatProvider.GetFormat 方法會傳回提供 DateTimeFormatInfo 格式化信息的物件。
如果 為 formatProvider
null
,則會 DateTimeFormatInfo 使用與目前文化特性相關聯的物件。
另請參閱
適用於
TryParseExact(String, String[], IFormatProvider, TimeSpanStyles, TimeSpan)
- 來源:
- TimeSpan.cs
- 來源:
- TimeSpan.cs
- 來源:
- TimeSpan.cs
使用指定的格式、文化特性專屬格式資訊及樣式,將時間間隔的指定字串表示法轉換成對等的 TimeSpan。 字串表示的格式必須完全符合其中一個指定的格式。
public:
static bool TryParseExact(System::String ^ input, cli::array <System::String ^> ^ formats, IFormatProvider ^ formatProvider, System::Globalization::TimeSpanStyles styles, [Runtime::InteropServices::Out] TimeSpan % result);
public static bool TryParseExact (string input, string[] formats, IFormatProvider formatProvider, System.Globalization.TimeSpanStyles styles, out TimeSpan result);
public static bool TryParseExact (string? input, string?[]? formats, IFormatProvider? formatProvider, System.Globalization.TimeSpanStyles styles, out TimeSpan result);
public static bool TryParseExact (string? input, string[] formats, IFormatProvider? formatProvider, System.Globalization.TimeSpanStyles styles, out TimeSpan result);
static member TryParseExact : string * string[] * IFormatProvider * System.Globalization.TimeSpanStyles * TimeSpan -> bool
Public Shared Function TryParseExact (input As String, formats As String(), formatProvider As IFormatProvider, styles As TimeSpanStyles, ByRef result As TimeSpan) As Boolean
參數
- input
- String
字串,指定要轉換的時間間隔。
- formats
- String[]
標準或自訂格式字串的陣列,這些格式字串會定義 input
可接受的格式。
- formatProvider
- IFormatProvider
物件,提供特定文化特性格式資訊。
- styles
- TimeSpanStyles
一或多個列舉值,這些值會指出 input
的樣式。
傳回
如果 input
轉換成功,則為 true
,否則為 false
。
範例
下列範例會呼叫 方法, TryParseExact(String, String[], IFormatProvider, TimeSpanStyles, TimeSpan) 將字串陣列的每個項目轉換成 TimeSpan 值。 字串可以代表一般簡短格式或一般長格式的時間間隔。
此外,此範例會變更時間間隔剖析方法解譯單一數位的方式。 一般而言,單一數位會解譯為時間間隔中的天數。 相反地 %h
,自定義格式字串會用來將單一數位解譯為時數。 若要讓這項變更生效,請注意 %h
,自定義格式字串必須位於數位中的其他 formats
格式字串之前。 另請注意,從輸出中,只有在剖析具有這個格式規範的字串時, TimeSpanStyles.AssumeNegative 才會使用方法呼叫中指定的旗標。
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("fr-FR");
// Parse each string in inputs using formats and the fr-FR culture.
foreach (string input in inputs) {
if(TimeSpan.TryParseExact(input, formats, culture,
TimeSpanStyles.AssumeNegative, out interval))
Console.WriteLine("{0} --> {1:c}", input, interval);
else
Console.WriteLine("Unable to parse {0}", input);
}
}
}
// The example displays the following output:
// 3 --> -03:00:00
// 16:42 --> 16:42:00
// Unable to parse 1:6:52:35.0625
// 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 "fr-FR"
// Parse each string in inputs using formats and the fr-FR culture.
for input in inputs do
match TimeSpan.TryParseExact(input, formats, culture, TimeSpanStyles.AssumeNegative) with
| true, interval ->
printfn $"{input} --> {interval:c}"
| _ ->
printfn $"Unable to parse {input}"
// The example displays the following output:
// 3 --> -03:00:00
// 16:42 --> 16:42:00
// Unable to parse 1:6:52:35.0625
// 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 fr-FR culture.
For Each input As String In inputs
If TimeSpan.TryParseExact(input, formats, culture,
TimeSpanStyles.AssumeNegative, interval) Then
Console.WriteLine("{0} --> {1:c}", input, interval)
Else
Console.WriteLine("Unable to parse {0}", input)
End If
Next
End Sub
End Module
' The example displays the following output:
' 3 --> -03:00:00
' 16:42 --> 16:42:00
' Unable to parse 1:6:52:35.0625
' 1:6:52:35,0625 --> 1.06:52:35.0625000
備註
方法 TryParseExact(String, String[], IFormatProvider, TimeSpanStyles, TimeSpan) 會剖析時間間隔的字串表示,其格式必須是 參數所 formats
指定的其中一個格式字串所定義,但忽略開頭和尾端空格符。 這個方法與 ParseExact(String, String[], IFormatProvider, TimeSpanStyles) 方法類似,不同之處在於,如果轉換失敗,則不會擲回例外狀況。
參數 formats
是字串數位,其元素是由單一標準格式規範所組成,或是定義必要格式的 input
一或多個自定義格式規範。 如需有效格式字串的詳細資訊,請參閱 標準 TimeSpan 格式字串 和 自定義 TimeSpan 格式字串。
input
必須完全符合的成員 formats
,剖析作業才能成功。 剖析作業會嘗試比 input
對陣列中 formats
第一個項目開頭的每個元素。
重要
ParseExact只有在用來剖input
析的格式字串是值為 「g」 或 「G」 的標準TimeSpan格式字串時,方法才會使用 參數所formatProvider
指定的文化特性慣例。 “c”、“t” 和 “T” 標準格式字串會使用不因文化特性而異的格式慣例。 自訂格式字串會定義輸入字串的精確格式,並使用常值字元分隔時間間隔的元件。
如果用來剖析input
的格式字串是標準格式字串,參數formatProvider
是實IFormatProvider作,可提供傳回字串格式的特定文化特性資訊。 參數 formatProvider
可以是下列任一項:
CultureInfo物件,表示格式慣例要反映在傳回字串中的文化特性。 屬性 DateTimeFormatInfo 所 CultureInfo.DateTimeFormat 傳回的物件會定義傳回字串的格式。
DateTimeFormatInfo對象,定義傳回字串的格式。
實作 介面的 IFormatProvider 自定義物件。 其 IFormatProvider.GetFormat 方法會傳回提供 DateTimeFormatInfo 格式化信息的物件。
如果 為 formatProvider
null
,則會 DateTimeFormatInfo 使用與目前文化特性相關聯的物件。
參數 styles
會影響使用自定義格式字串剖析的字串解譯。 它決定 input
只有在負號存在 () TimeSpanStyles.None 時,還是一律解譯為負數時間間隔, (TimeSpanStyles.AssumeNegative) 。 如果未 TimeSpanStyles.AssumeNegative 使用 , format
則必須包含常值負號符號 (,例如 “\-”) ,才能成功剖析負時間間隔。
另請參閱
適用於
TryParseExact(ReadOnlySpan<Char>, String[], IFormatProvider, TimeSpan)
- 來源:
- TimeSpan.cs
- 來源:
- TimeSpan.cs
- 來源:
- TimeSpan.cs
使用指定的格式和文化特性專屬格式資訊,將時間間隔的指定範圍表示法轉換成對等的 TimeSpan。 字串表示的格式必須完全符合其中一個指定的格式。
public:
static bool TryParseExact(ReadOnlySpan<char> input, cli::array <System::String ^> ^ formats, IFormatProvider ^ formatProvider, [Runtime::InteropServices::Out] TimeSpan % result);
public static bool TryParseExact (ReadOnlySpan<char> input, string?[]? formats, IFormatProvider? formatProvider, out TimeSpan result);
public static bool TryParseExact (ReadOnlySpan<char> input, string[] formats, IFormatProvider formatProvider, out TimeSpan result);
public static bool TryParseExact (ReadOnlySpan<char> input, string[] formats, IFormatProvider? formatProvider, out TimeSpan result);
static member TryParseExact : ReadOnlySpan<char> * string[] * IFormatProvider * TimeSpan -> bool
Public Shared Function TryParseExact (input As ReadOnlySpan(Of Char), formats As String(), formatProvider As IFormatProvider, ByRef result As TimeSpan) As Boolean
參數
- input
- ReadOnlySpan<Char>
範圍,其包含代表要轉換時間間隔的字元。
- formats
- String[]
標準或自訂格式字串的陣列,這些格式字串會定義 input
可接受的格式。
- formatProvider
- IFormatProvider
物件,提供特定文化特性格式資訊。
傳回
如果 input
轉換成功,則為 true
,否則為 false
。
適用於
TryParseExact(ReadOnlySpan<Char>, ReadOnlySpan<Char>, IFormatProvider, TimeSpan)
- 來源:
- TimeSpan.cs
- 來源:
- TimeSpan.cs
- 來源:
- TimeSpan.cs
使用指定的格式和文化特性專屬格式資訊,將時間間隔的指定範圍表示法轉換成對等的 TimeSpan。 字串表示的格式必須完全符合指定的格式。
public:
static bool TryParseExact(ReadOnlySpan<char> input, ReadOnlySpan<char> format, IFormatProvider ^ formatProvider, [Runtime::InteropServices::Out] TimeSpan % result);
public static bool TryParseExact (ReadOnlySpan<char> input, ReadOnlySpan<char> format, IFormatProvider? formatProvider, out TimeSpan result);
public static bool TryParseExact (ReadOnlySpan<char> input, ReadOnlySpan<char> format, IFormatProvider formatProvider, out TimeSpan result);
static member TryParseExact : ReadOnlySpan<char> * ReadOnlySpan<char> * IFormatProvider * TimeSpan -> bool
Public Shared Function TryParseExact (input As ReadOnlySpan(Of Char), format As ReadOnlySpan(Of Char), formatProvider As IFormatProvider, ByRef result As TimeSpan) As Boolean
參數
- input
- ReadOnlySpan<Char>
範圍,其包含代表要轉換時間間隔的字元。
- format
- ReadOnlySpan<Char>
包含字元的範圍,這些字元代表的標準或自訂格式字串能定義 input
可接受的格式。
- formatProvider
- IFormatProvider
物件,提供特定文化特性格式資訊。
傳回
如果 input
轉換成功,則為 true
,否則為 false
。
適用於
TryParseExact(String, String, IFormatProvider, TimeSpan)
- 來源:
- TimeSpan.cs
- 來源:
- TimeSpan.cs
- 來源:
- TimeSpan.cs
使用指定之格式和特定文化特性格式資訊,將時間間隔的字串表示轉換為其相等的 TimeSpan。 字串表示的格式必須完全符合指定的格式。
public:
static bool TryParseExact(System::String ^ input, System::String ^ format, IFormatProvider ^ formatProvider, [Runtime::InteropServices::Out] TimeSpan % result);
public static bool TryParseExact (string input, string format, IFormatProvider formatProvider, out TimeSpan result);
public static bool TryParseExact (string? input, string? format, IFormatProvider? formatProvider, out TimeSpan result);
public static bool TryParseExact (string? input, string format, IFormatProvider? formatProvider, out TimeSpan result);
static member TryParseExact : string * string * IFormatProvider * TimeSpan -> bool
Public Shared Function TryParseExact (input As String, format As String, formatProvider As IFormatProvider, ByRef result As TimeSpan) As Boolean
參數
- input
- String
字串,指定要轉換的時間間隔。
- format
- String
標準或自訂格式字串,其定義 input
的必要格式。
- formatProvider
- IFormatProvider
物件,提供特定文化特性格式資訊。
傳回
如果 input
轉換成功,則為 true
,否則為 false
。
範例
下列範例會 TryParseExact(String, String, IFormatProvider, TimeSpanStyles, TimeSpan) 使用 方法,使用各種格式字串和文化特性剖析數個時間間隔的字串表示。
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;
if (TimeSpan.TryParseExact(intervalString, format, culture, out interval))
Console.WriteLine("'{0}' --> {1}", intervalString, interval);
else
Console.WriteLine("Unable to parse {0}", intervalString);
// Parse hour:minute:second value with "G" specifier.
intervalString = "17:14:48";
format = "G";
culture = CultureInfo.InvariantCulture;
if (TimeSpan.TryParseExact(intervalString, format, culture, out interval))
Console.WriteLine("'{0}' --> {1}", intervalString, interval);
else
Console.WriteLine("Unable to parse {0}", intervalString);
// Parse hours:minute.second value with "G" specifier
// and current (en-US) culture.
intervalString = "17:14:48.153";
format = "G";
culture = CultureInfo.CurrentCulture;
if (TimeSpan.TryParseExact(intervalString, format, culture, out interval))
Console.WriteLine("'{0}' --> {1}", intervalString, interval);
else
Console.WriteLine("Unable to parse {0}", 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;
if (TimeSpan.TryParseExact(intervalString, format, culture, out interval))
Console.WriteLine("'{0}' --> {1}", intervalString, interval);
else
Console.WriteLine("Unable to parse {0}", 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");
if (TimeSpan.TryParseExact(intervalString, format, culture, out interval))
Console.WriteLine("'{0}' --> {1}", intervalString, interval);
else
Console.WriteLine("Unable to parse {0}", intervalString);
// Parse days:hours:minute.second value with "G" specifier
// and fr-FR culture.
intervalString = "3:17:14:48,153";
format = "G";
if (TimeSpan.TryParseExact(intervalString, format, culture, out interval))
Console.WriteLine("'{0}' --> {1}", intervalString, interval);
else
Console.WriteLine("Unable to parse {0}", intervalString);
// Parse a single number using the "c" standard format string.
intervalString = "12";
format = "c";
if (TimeSpan.TryParseExact(intervalString, format, null, out interval))
Console.WriteLine("'{0}' --> {1}", intervalString, interval);
else
Console.WriteLine("Unable to parse {0}", intervalString);
// Parse a single number using the "%h" custom format string.
format = "%h";
if (TimeSpan.TryParseExact(intervalString, format, null, out interval))
Console.WriteLine("'{0}' --> {1}", intervalString, interval);
else
Console.WriteLine("Unable to parse {0}", intervalString);
// Parse a single number using the "%s" custom format string.
format = "%s";
if (TimeSpan.TryParseExact(intervalString, format, null, out interval))
Console.WriteLine("'{0}' --> {1}", intervalString, interval);
else
Console.WriteLine("Unable to parse {0}", intervalString);
}
}
// The example displays the following output:
// '17:14' --> 17:14:00
// Unable to parse 17:14:48
// Unable to parse 17:14:48.153
// '3:17:14:48.153' --> 3.17:14:48.1530000
// Unable to parse 3:17:14:48.153
// '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
match TimeSpan.TryParseExact(intervalString, format, culture) with
| true, interval ->
printfn $"'{intervalString}' --> {interval}"
| _ ->
printfn $"Unable to parse {intervalString}"
// Parse hour:minute:second value with "G" specifier.
let intervalString = "17:14:48"
let format = "G"
let culture = CultureInfo.InvariantCulture
match TimeSpan.TryParseExact(intervalString, format, culture) with
| true, interval ->
printfn $"'{intervalString}' --> {interval}"
| _ ->
printfn $"Unable to parse {intervalString}"
// 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
match TimeSpan.TryParseExact(intervalString, format, culture) with
| true, interval ->
printfn $"'{intervalString}' --> {interval}"
| _ ->
printfn $"Unable to parse {intervalString}"
// 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
match TimeSpan.TryParseExact(intervalString, format, culture) with
| true, interval ->
printfn $"'{intervalString}' --> {interval}"
| _ ->
printfn $"Unable to parse {intervalString}"
// 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")
match TimeSpan.TryParseExact(intervalString, format, culture) with
| true, interval ->
printfn $"'{intervalString}' --> {interval}"
| _ ->
printfn $"Unable to parse {intervalString}"
// Parse days:hours:minute.second value with "G" specifier
// and fr-FR culture.
let intervalString = "3:17:14:48,153"
let format = "G"
match TimeSpan.TryParseExact(intervalString, format, culture) with
| true, interval ->
printfn $"'{intervalString}' --> {interval}"
| _ ->
printfn $"Unable to parse {intervalString}"
// Parse a single number using the "c" standard format string.
let intervalString = "12"
let format = "c"
match TimeSpan.TryParseExact(intervalString, format, null) with
| true, interval ->
printfn $"'{intervalString}' --> {interval}"
| _ ->
printfn $"Unable to parse {intervalString}"
// Parse a single number using the "%h" custom format string.
let format = "%h"
match TimeSpan.TryParseExact(intervalString, format, null) with
| true, interval ->
printfn $"'{intervalString}' --> {interval}"
| _ ->
printfn $"Unable to parse {intervalString}"
// Parse a single number using the "%s" custom format string.
let format = "%s"
match TimeSpan.TryParseExact(intervalString, format, null) with
| true, interval ->
printfn $"'{intervalString}' --> {interval}"
| _ ->
printfn $"Unable to parse {intervalString}"
// The example displays the following output:
// '17:14' --> 17:14:00
// Unable to parse 17:14:48
// Unable to parse 17:14:48.153
// '3:17:14:48.153' --> 3.17:14:48.1530000
// Unable to parse 3:17:14:48.153
// '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
If TimeSpan.TryParseExact(intervalString, format, culture, interval) Then
Console.WriteLine("'{0}' --> {1}", intervalString, interval)
Else
Console.WriteLine("Unable to parse {0}", intervalString)
End If
' Parse hour:minute:second value with "G" specifier.
intervalString = "17:14:48"
format = "G"
culture = CultureInfo.InvariantCulture
If TimeSpan.TryParseExact(intervalString, format, culture, interval) Then
Console.WriteLine("'{0}' --> {1}", intervalString, interval)
Else
Console.WriteLine("Unable to parse {0}", intervalString)
End If
' Parse hours:minute.second value with "G" specifier
' and current (en-US) culture.
intervalString = "17:14:48.153"
format = "G"
culture = CultureInfo.CurrentCulture
If TimeSpan.TryParseExact(intervalString, format, culture, interval) Then
Console.WriteLine("'{0}' --> {1}", intervalString, interval)
Else
Console.WriteLine("Unable to parse {0}", intervalString)
End If
' 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
If TimeSpan.TryParseExact(intervalString, format, culture, interval) Then
Console.WriteLine("'{0}' --> {1}", intervalString, interval)
Else
Console.WriteLine("Unable to parse {0}", intervalString)
End If
' 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")
If TimeSpan.TryParseExact(intervalString, format, culture, interval) Then
Console.WriteLine("'{0}' --> {1}", intervalString, interval)
Else
Console.WriteLine("Unable to parse {0}", intervalString)
End If
' 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")
If TimeSpan.TryParseExact(intervalString, format, culture, interval) Then
Console.WriteLine("'{0}' --> {1}", intervalString, interval)
Else
Console.WriteLine("Unable to parse {0}", intervalString)
End If
' Parse a single number using the "c" standard format string.
intervalString = "12"
format = "c"
If TimeSpan.TryParseExact(intervalString, format, Nothing, interval)
Console.WriteLine("'{0}' --> {1}", intervalString, interval)
Else
Console.WriteLine("Unable to parse {0}", intervalString)
End If
' Parse a single number using the "%h" custom format string.
format = "%h"
If TimeSpan.TryParseExact(intervalString, format, Nothing, interval)
Console.WriteLine("'{0}' --> {1}", intervalString, interval)
Else
Console.WriteLine("Unable to parse {0}", intervalString)
End If
' Parse a single number using the "%s" custom format string.
format = "%s"
If TimeSpan.TryParseExact(intervalString, format, Nothing, interval) Then
Console.WriteLine("'{0}' --> {1}", intervalString, interval)
Else
Console.WriteLine("Unable to parse {0}", intervalString)
End If
End Sub
End Module
' The example displays the following output:
' '17:14' --> 17:14:00
' Unable to parse 17:14:48
' Unable to parse 17:14:48.153
' '3:17:14:48.153' --> 3.17:14:48.1530000
' Unable to parse 3:17:14:48.153
' '3:17:14:48,153' --> 3.17:14:48.1530000
' '12' --> 12.00:00:00
' '12' --> 12:00:00
' '12' --> 00:00:12
備註
方法 TryParseExact(String, String, IFormatProvider, TimeSpan) 會剖析時間間隔的字串表示,其格式必須是 參數所 format
定義的格式,但會忽略前置和尾端空格符。 這個方法與 ParseExact(String, String, IFormatProvider) 方法類似,不同之處在於,如果轉換失敗,則不會擲回例外狀況。
參數 format
是包含單一標準格式規範的字串,或是定義 必要格式的 input
一或多個自定義格式規範。 如需有效格式字串的詳細資訊,請參閱 標準 TimeSpan 格式字串 和 自定義 TimeSpan 格式字串。
重要
TryParseExact(String, String, IFormatProvider, TimeSpan)只有在 format
是值為 「g」 或 「G」 的標準TimeSpan格式字串時,方法才會使用 參數所formatProvider
指定文化特性的慣例。 “c”、“t” 和 “T” 標準格式字串會使用不因文化特性而異的格式慣例。 自訂格式字串會定義輸入字串的精確格式,並使用常值字元分隔時間間隔的元件。
參數 formatProvider
是實作, IFormatProvider 如果 format
是標準格式字串,則提供傳回字串格式的特定文化特性資訊。 參數 formatProvider
可以是下列任一項:
CultureInfo物件,表示格式慣例要反映在傳回字串中的文化特性。 屬性 DateTimeFormatInfo 所 CultureInfo.DateTimeFormat 傳回的物件會定義傳回字串的格式。
DateTimeFormatInfo對象,定義傳回字串的格式。
實作 介面的 IFormatProvider 自定義物件。 其 IFormatProvider.GetFormat 方法會傳回提供 DateTimeFormatInfo 格式化信息的物件。
如果 為 formatProvider
null
,則會 DateTimeFormatInfo 使用與目前文化特性相關聯的物件。
另請參閱
適用於
意見反應
https://aka.ms/ContentUserFeedback。
即將登場:在 2024 年,我們將逐步淘汰 GitHub 問題作為內容的意見反應機制,並將它取代為新的意見反應系統。 如需詳細資訊,請參閱:提交並檢視相關的意見反應