TimeSpan.TryParseExact メソッド

リファレンス

定義

名前空間:: System

アセンブリ:: System.Runtime.dll

アセンブリ:: netstandard.dll

アセンブリ:: mscorlib.dll

重要

一部の情報は、リリース前に大きく変更される可能性があるプレリリースされた製品に関するものです。 Microsoft は、ここに記載されている情報について、明示または黙示を問わず、一切保証しません。

時間間隔の文字列形式を等価の TimeSpan に変換し、変換が成功したかどうかを示す値を返します。文字列形式の形式は、指定した形式と正確に一致する必要があります。

オーバーロード

TryParseExact(ReadOnlySpan<Char>, String[], IFormatProvider, TimeSpanStyles, TimeSpan)	指定した書式、カルチャ固有の書式情報、およびスタイルを使用して、時間間隔の指定したスパン表現を等価の TimeSpan に変換します。文字列形式の形式は、指定した形式のいずれかと正確に一致する必要があります。
TryParseExact(String, String, IFormatProvider, TimeSpanStyles, TimeSpan)	指定した書式、カルチャ固有の書式情報、およびスタイルを使用して、時間間隔の文字列形式を等価の TimeSpan に変換します。文字列形式の形式は、指定した形式と正確に一致する必要があります。
TryParseExact(ReadOnlySpan<Char>, ReadOnlySpan<Char>, IFormatProvider, TimeSpanStyles, TimeSpan)	指定した形式、カルチャ固有の書式情報、およびスタイルを使用して、時間間隔の指定したスパン表現を等価の TimeSpan に変換し、変換が成功したかどうかを示す値を返します。文字列形式の形式は、指定した形式と正確に一致する必要があります。
TryParseExact(String, String[], IFormatProvider, TimeSpan)	指定した書式とカルチャ固有の書式情報を使用して、指定した文字列形式の時間間隔を等価の TimeSpan に変換します。文字列形式の形式は、指定した形式のいずれかと正確に一致する必要があります。
TryParseExact(String, String[], IFormatProvider, TimeSpanStyles, TimeSpan)	指定した書式、カルチャ固有の書式情報、およびスタイルを使用して、時間間隔の指定した文字列形式を等価の TimeSpan に変換します。文字列形式の形式は、指定した形式のいずれかと正確に一致する必要があります。
TryParseExact(ReadOnlySpan<Char>, String[], IFormatProvider, TimeSpan)	指定した書式とカルチャ固有の書式情報を使用して、時間間隔の指定したスパン表現を等価の TimeSpan に変換します。文字列形式の形式は、指定した形式のいずれかと正確に一致する必要があります。
TryParseExact(ReadOnlySpan<Char>, ReadOnlySpan<Char>, IFormatProvider, TimeSpan)	指定した書式とカルチャ固有の書式情報を使用して、時間間隔の指定したスパン表現を等価の TimeSpan に変換します。文字列形式の形式は、指定した形式と正確に一致する必要があります。
TryParseExact(String, String, IFormatProvider, TimeSpan)	指定した書式およびカルチャ固有の書式情報を使用して、時間間隔の文字列形式を等価の TimeSpan に変換します。文字列形式の形式は、指定した形式と正確に一致する必要があります。

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のスタイルを示す 1 つ以上の列挙値。

result: TimeSpan

このメソッドから制御が戻るときに、inputで指定された時間間隔を表すオブジェクトを格納するか、変換に失敗した場合に Zero します。このパラメーターは初期化されていない状態で渡されます。

戻り値

Boolean

input が正常に変換されたかどうかを true します。それ以外の場合は、falseします。

適用対象

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のスタイルを示す 1 つ以上の列挙値。

result: TimeSpan

戻り値

Boolean

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 パラメーターは、1 つの標準書式指定子、または必要な形式の inputを定義する 1 つ以上のカスタム書式指定子を含む文字列です。有効な書式指定文字列の詳細については、「標準の TimeSpan 書式指定文字列のとカスタム TimeSpan 書式指定文字列を参照してください。

formatProvider パラメーターは、format が標準書式指定文字列の場合に、返される文字列の形式に関するカルチャ固有の情報を提供する IFormatProvider 実装です。 formatProvider パラメーターには、次のいずれかを指定できます。

書式設定規則が返される文字列に反映されるカルチャを表す CultureInfo オブジェクト。 CultureInfo.DateTimeFormat プロパティによって返される DateTimeFormatInfo オブジェクトは、返される文字列の書式設定を定義します。
返される文字列の書式設定を定義する DateTimeFormatInfo オブジェクト。
IFormatProvider インターフェイスを実装するカスタムオブジェクト。その IFormatProvider.GetFormat メソッドは、書式設定情報を提供する DateTimeFormatInfo オブジェクトを返します。

formatProvider が nullされている場合は、現在のカルチャに関連付けられている DateTimeFormatInfo オブジェクトが使用されます。

styles パラメーターは、カスタム書式指定文字列を使用して解析された文字列の解釈に影響します。負の符号 (TimeSpanStyles.None) が存在する場合にのみ、input が負の時間間隔として解釈されるかどうか、または常に負の時間間隔 (TimeSpanStyles.AssumeNegative) として解釈されるかどうかを判断します。 TimeSpanStyles.AssumeNegative を使用しない場合、負の時間間隔を正常に解析するには、format にリテラル負符号記号 ("\-" など) を含める必要があります。

こちらもご覧ください

標準の TimeSpan 書式指定文字列をする
カスタム TimeSpan 書式指定文字列をする

適用対象

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のスタイルを示す 1 つ以上の列挙値。

result: TimeSpan

戻り値

Boolean

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

カルチャ固有の書式設定情報を提供するオブジェクト。

result: TimeSpan

戻り値

Boolean

input が正常に変換されたかどうかを true します。それ以外の場合は、falseします。

例

次の例では、TryParseExact(String, String[], IFormatProvider, TimeSpan) メソッドを呼び出して、文字列配列の各要素を TimeSpan 値に変換します。この例では、フランス語 - フランス語 ("fr-FR") カルチャの書式設定規則を使用して文字列を解釈します。文字列は、一般的な短い形式または一般的な長い形式で時間間隔を表すことができます。

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 パラメーターで指定された書式指定文字列の 1 つで定義された形式である必要があります。このメソッドは、変換が失敗した場合に例外をスローしない点を除き、ParseExact(String, String[], IFormatProvider) メソッドに似ています。

formats パラメーターは、1 つの標準書式指定子、または必要な形式の inputを定義する 1 つ以上のカスタム書式指定子で構成される要素を持つ文字列配列です。有効な書式指定文字列の詳細については、「標準の TimeSpan 書式指定文字列のとカスタム TimeSpan 書式指定文字列を参照してください。 input 解析操作を成功させるには、formats のメンバーに正確に対応する必要があります。解析操作は、配列内の最初の要素から始まる formats 内の各要素に input を照合しようとします。

大事な

TryParseExact メソッドは、formatProvider パラメーターで指定されたカルチャの規則を使用します。これは、input の解析に使用される書式指定文字列が、値が "g" または "G" である標準の TimeSpan 書式指定文字列である場合のみです。 "c"、"t"、および "T" 標準書式指定文字列では、インバリアントカルチャの書式設定規則が使用されます。カスタム書式指定文字列は、入力文字列の正確な形式を定義し、リテラル文字を使用して時間間隔の構成要素を区切ります。

formatProvider パラメーターは、input の解析に使用される書式指定文字列が標準の書式指定文字列である場合に、返される文字列の形式に関するカルチャ固有の情報を提供する IFormatProvider 実装です。 formatProvider パラメーターには、次のいずれかを指定できます。

書式設定規則が返される文字列に反映されるカルチャを表す CultureInfo オブジェクト。 CultureInfo.DateTimeFormat プロパティによって返される DateTimeFormatInfo オブジェクトは、返される文字列の書式設定を定義します。
返される文字列の書式設定を定義する DateTimeFormatInfo オブジェクト。
IFormatProvider インターフェイスを実装するカスタムオブジェクト。その IFormatProvider.GetFormat メソッドは、書式設定情報を提供する DateTimeFormatInfo オブジェクトを返します。

formatProvider が nullされている場合は、現在のカルチャに関連付けられている DateTimeFormatInfo オブジェクトが使用されます。

こちらもご覧ください

標準の TimeSpan 書式指定文字列をする
カスタム TimeSpan 書式指定文字列をする

適用対象

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のスタイルを示す 1 つ以上の列挙値。

result: TimeSpan

戻り値

Boolean

input が正常に変換されたかどうかを true します。それ以外の場合は、falseします。

例

次の例では、TryParseExact(String, String[], IFormatProvider, TimeSpanStyles, TimeSpan) メソッドを呼び出して、文字列配列の各要素を TimeSpan 値に変換します。文字列は、一般的な短い形式または一般的な長い形式で時間間隔を表すことができます。

さらに、この例では、時間間隔解析メソッドが 1 桁を解釈する方法を変更します。通常、1 桁は時間間隔の日数として解釈されます。代わりに、%h カスタム書式指定文字列を使用して、1 桁を時間数として解釈します。この変更を有効にするには、%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 パラメーターで指定された書式指定文字列の 1 つで定義された形式である必要があります。このメソッドは、変換が失敗した場合に例外をスローしない点を除き、ParseExact(String, String[], IFormatProvider, TimeSpanStyles) メソッドに似ています。

大事な

ParseExact メソッドは、formatProvider パラメーターで指定されたカルチャの規則を使用します。これは、input の解析に使用される書式指定文字列が、値が "g" または "G" である標準の TimeSpan 書式指定文字列である場合のみです。 "c"、"t"、および "T" 標準書式指定文字列では、インバリアントカルチャの書式設定規則が使用されます。カスタム書式指定文字列は、入力文字列の正確な形式を定義し、リテラル文字を使用して時間間隔の構成要素を区切ります。

書式設定規則が返される文字列に反映されるカルチャを表す CultureInfo オブジェクト。 CultureInfo.DateTimeFormat プロパティによって返される DateTimeFormatInfo オブジェクトは、返される文字列の書式設定を定義します。
返される文字列の書式設定を定義する DateTimeFormatInfo オブジェクト。
IFormatProvider インターフェイスを実装するカスタムオブジェクト。その IFormatProvider.GetFormat メソッドは、書式設定情報を提供する DateTimeFormatInfo オブジェクトを返します。

formatProvider が nullされている場合は、現在のカルチャに関連付けられている DateTimeFormatInfo オブジェクトが使用されます。

styles パラメーターは、カスタム書式指定文字列を使用して解析される文字列の解釈に影響します。負の符号 (TimeSpanStyles.None) が存在する場合にのみ、input が負の時間間隔として解釈されるかどうか、または常に負の時間間隔 (TimeSpanStyles.AssumeNegative) として解釈されるかどうかを判断します。 TimeSpanStyles.AssumeNegative を使用しない場合、負の時間間隔を正常に解析するには、format にリテラル負符号記号 ("\-" など) を含める必要があります。

こちらもご覧ください

標準の TimeSpan 書式指定文字列をする
カスタム TimeSpan 書式指定文字列をする

適用対象

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

カルチャ固有の書式設定情報を提供するオブジェクト。

result: TimeSpan

戻り値

Boolean

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

カルチャ固有の書式設定情報を提供するオブジェクト。

result: TimeSpan

戻り値

Boolean

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

カルチャ固有の書式設定情報を提供するオブジェクト。

result: TimeSpan

戻り値

Boolean

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) メソッドに似ています。

大事な

TryParseExact(String, String, IFormatProvider, TimeSpan) メソッドは、format が値が "g" または "G" である標準の TimeSpan 書式指定文字列である場合にのみ、formatProvider パラメーターで指定されたカルチャの規則を使用します。 "c"、"t"、および "T" 標準書式指定文字列では、インバリアントカルチャの書式設定規則が使用されます。カスタム書式指定文字列は、入力文字列の正確な形式を定義し、リテラル文字を使用して時間間隔の構成要素を区切ります。

書式設定規則が返される文字列に反映されるカルチャを表す CultureInfo オブジェクト。 CultureInfo.DateTimeFormat プロパティによって返される DateTimeFormatInfo オブジェクトは、返される文字列の書式設定を定義します。
返される文字列の書式設定を定義する DateTimeFormatInfo オブジェクト。
IFormatProvider インターフェイスを実装するカスタムオブジェクト。その IFormatProvider.GetFormat メソッドは、書式設定情報を提供する DateTimeFormatInfo オブジェクトを返します。

formatProvider が nullされている場合は、現在のカルチャに関連付けられている DateTimeFormatInfo オブジェクトが使用されます。

こちらもご覧ください

標準の TimeSpan 書式指定文字列をする
カスタム TimeSpan 書式指定文字列をする

適用対象

次の方法で共有

TimeSpan.TryParseExact メソッド

定義

オーバーロード

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

パラメーター

戻り値

適用対象

TryParseExact(String, String, IFormatProvider, TimeSpanStyles, TimeSpan)

パラメーター

戻り値

例

注釈

こちらもご覧ください

適用対象

TryParseExact(ReadOnlySpan<Char>, ReadOnlySpan<Char>, IFormatProvider, TimeSpanStyles, TimeSpan)

パラメーター

戻り値

適用対象

TryParseExact(String, String[], IFormatProvider, TimeSpan)

パラメーター

戻り値

例

注釈

こちらもご覧ください

適用対象

TryParseExact(String, String[], IFormatProvider, TimeSpanStyles, TimeSpan)

パラメーター

戻り値

例

注釈

こちらもご覧ください

適用対象

TryParseExact(ReadOnlySpan<Char>, String[], IFormatProvider, TimeSpan)

パラメーター

戻り値

適用対象

TryParseExact(ReadOnlySpan<Char>, ReadOnlySpan<Char>, IFormatProvider, TimeSpan)

パラメーター

戻り値

適用対象

TryParseExact(String, String, IFormatProvider, TimeSpan)

パラメーター

戻り値

例

注釈

こちらもご覧ください

適用対象

その他のリソース