TimeSpan.ParseExact メソッド

リファレンス

定義

名前空間:: System

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

アセンブリ:: mscorlib.dll

アセンブリ:: netstandard.dll

重要

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

時間間隔の文字列形式を等価の TimeSpan に変換します。文字列形式の書式は、指定した書式と完全に一致する必要があります。

オーバーロード

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

ParseExact(String, String, IFormatProvider, TimeSpanStyles)

指定した書式、カルチャ固有の書式情報、およびスタイルを使用して、時間間隔の文字列形式を等価の TimeSpan に変換します。文字列形式の書式は、指定した書式と完全に一致する必要があります。

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

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

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

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

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

パラメーター

input: String

変換する時間間隔を指定する文字列。

format: String

input で必要とされる書式を定義する標準またはカスタムの書式指定文字列。

formatProvider: IFormatProvider

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

styles: TimeSpanStyles

input で使用できるスタイル要素を定義する列挙値のビットごとの組み合わせ。

戻り値

TimeSpan

format、formatProvider、および styles の指定に従って変換された、input に対応する時間間隔。

例外

ArgumentException

styles は無効な TimeSpanStyles 値です。

ArgumentNullException

input が nullです。

FormatException

input の形式は無効です。

OverflowException

input は、 TimeSpan.MinValue より小さいか、 TimeSpan.MaxValue より大きい数値を表します。

- または -

input の日、時間、分、または秒のコンポーネントのうち少なくとも 1 つが、その有効範囲外です。

例

次の例では、メソッドを 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;
      try {
         interval = TimeSpan.ParseExact(intervalString, format, 
                                        culture, TimeSpanStyles.AssumeNegative);
         Console.WriteLine("'{0}' ({1}) --> {2}", intervalString, format, interval);
      }   
      catch (FormatException) {
         Console.WriteLine("'{0}': Bad Format for '{1}'", intervalString, format);
      }   
      catch (OverflowException) {
         Console.WriteLine("'{0}': Overflow", intervalString);
      }      
      
      // Parse hour:minute:second value with "g" specifier.
      intervalString = "17:14:48";
      format = "g";
      culture = CultureInfo.InvariantCulture;
      try {
         interval = TimeSpan.ParseExact(intervalString, format, 
                                        culture, TimeSpanStyles.AssumeNegative);
         Console.WriteLine("'{0}' ({1}) --> {2}", intervalString, format, interval);
      }
      catch (FormatException) {
         Console.WriteLine("'{0}': Bad Format for '{1}'", intervalString, format);
      }   
      catch (OverflowException) {
         Console.WriteLine("'{0}': Overflow", intervalString);
      } 
      
      // Parse hours:minute.second value with custom format specifier.     
      intervalString = "17:14:48.153";
      format = @"h\:mm\:ss\.fff";
      culture = null;
      try {
         interval = TimeSpan.ParseExact(intervalString, format, 
                                        culture, TimeSpanStyles.AssumeNegative);
         Console.WriteLine("'{0}' ({1}) --> {2}", intervalString, format, interval);
      }
      catch (FormatException) {
         Console.WriteLine("'{0}': Bad Format for '{1}'", intervalString, format);
      }   
      catch (OverflowException) {
         Console.WriteLine("'{0}': Overflow", intervalString);
      } 

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

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

open System
open System.Globalization

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

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

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

Imports System.Globalization

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

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

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

注釈

メソッドは ParseExact 、時間間隔の文字列表現を解析します。これは、パラメーターで定義された format 形式である必要があります。ただし、先頭と末尾の空白文字は無視されます。の形式formatに正確に準拠する必要があるためinput、ユーザーによる文字列入力を時間間隔に変換するときは、常に例外処理を使用する必要があります。例外処理を使用しない場合は、代わりにメソッドを TryParseExact(String, String, IFormatProvider, TimeSpanStyles, TimeSpan) 呼び出すことができます。

パラメーターは format 、1 つの標準書式指定子、またはの必要な形式を定義する 1 つ以上の inputカスタム書式指定子を含む文字列です。有効な書式指定文字列の詳細については、「標準の TimeSpan 書式指定文字列」および「カスタム TimeSpan 書式指定文字列」を参照してください。

重要

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

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

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

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

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

こちらもご覧ください

適用対象

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

指定した書式、カルチャ固有の書式情報、およびスタイルを使用して、時間間隔の文字列形式を等価の TimeSpan に変換します。文字列形式の書式は、指定されたいずれかの書式と完全に一致する必要があります。

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

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

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

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

パラメーター

input: ReadOnlySpan<Char>

変換する時間間隔を指定するスパン。

formats: String[]

input で必要とされる書式を定義する標準またはカスタムの書式指定文字列の配列。

formatProvider: IFormatProvider

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

styles: TimeSpanStyles

input で使用できるスタイル要素を定義する列挙値のビットごとの組み合わせ。

戻り値

TimeSpan

formats、formatProvider、および styles の指定に従って変換された、input に対応する時間間隔。

適用対象

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

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

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

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

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

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

パラメーター

input: String

変換する時間間隔を指定する文字列。

formats: String[]

input で必要とされる書式を定義する標準またはカスタムの書式指定文字列の配列。

formatProvider: IFormatProvider

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

styles: TimeSpanStyles

input で使用できるスタイル要素を定義する列挙値のビットごとの組み合わせ。

戻り値

TimeSpan

formats、formatProvider、および styles の指定に従って変換された、input に対応する時間間隔。

例外

ArgumentException

styles は無効な TimeSpanStyles 値です。

ArgumentNullException

input が nullです。

FormatException

input の形式は無効です。

OverflowException

input は、 TimeSpan.MinValue より小さいか、 TimeSpan.MaxValue より大きい数値を表します。

- または -

input の日、時間、分、または秒のコンポーネントのうち少なくとも 1 つが、その有効範囲外です。

例

次の例では、メソッドを ParseExact(String, String[], IFormatProvider, TimeSpanStyles) 呼び出して、文字列配列の各要素を値に 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("de-DE");
      
      // Parse each string in inputs using formats and the de-DE culture.
      foreach (string input in inputs) {
         try {
            interval = TimeSpan.ParseExact(input, formats, culture,
                                           TimeSpanStyles.AssumeNegative);
            Console.WriteLine("{0} --> {1:c}", input, interval);
         }
         catch (FormatException) {
            Console.WriteLine("{0} --> Bad Format", input);
         }      
         catch (OverflowException) {
            Console.WriteLine("{0} --> Overflow", input);   
         }            
      }
   }
}
// The example displays the following output:
//       3 --> -03:00:00
//       16:42 --> 16:42:00
//       1:6:52:35.0625 --> Bad Format
//       1:6:52:35,0625 --> 1.06:52:35.0625000

open System
open System.Globalization

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

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

Imports System.Globalization

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

注釈

メソッドは ParseExact(String, String[], IFormatProvider, TimeSpanStyles) 時間間隔の文字列表現を解析します。これは、先頭と末尾の空白文字が無視されることを除き、パラメーターで定義された formats 形式のいずれかで指定する必要があります。で指定されたformats形式のいずれかに正確に準拠している必要があるためinput、ユーザーによる文字列入力を時間間隔に変換するときは、常に例外処理を使用する必要があります。例外処理を使用しない場合は、代わりにメソッドを TryParseExact(String, String[], IFormatProvider, TimeSpanStyles, TimeSpan) 呼び出すことができます。

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

重要

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

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

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

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

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

こちらもご覧ください

適用対象

ParseExact(String, String[], IFormatProvider)

指定した書式指定文字列の配列とカルチャ固有の書式情報を使用して、時間間隔の文字列形式を等価の TimeSpan に変換します。文字列形式の書式は、指定されたいずれかの書式と完全に一致する必要があります。

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

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

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

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

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

パラメーター

input: String

変換する時間間隔を指定する文字列。

formats: String[]

input で必要とされる書式を定義する標準またはカスタムの書式指定文字列の配列。

formatProvider: IFormatProvider

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

戻り値

TimeSpan

formats および formatProvider の指定に従って変換された、input に対応する時間間隔。

例外

ArgumentNullException

input が nullです。

FormatException

input の形式は無効です。

OverflowException

input は、 TimeSpan.MinValue より小さいか、 TimeSpan.MaxValue より大きい数値を表します。

- または -

input の日、時間、分、または秒のコンポーネントのうち少なくとも 1 つが、その有効範囲外です。

例

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

さらに、この例では、時間間隔解析メソッドが 1 桁を解釈する方法を変更します。通常、1 桁は時間間隔の日数として解釈されます。代わりに、 %h カスタム書式指定文字列を使用して、1 桁を時間数として解釈します。この変更を有効にするには、カスタム書式指定文字列を配列内の %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) {
         try {
            interval = TimeSpan.ParseExact(input, formats, culture);
            Console.WriteLine("{0} --> {1:c}", input, interval);
         }
         catch (FormatException) {
            Console.WriteLine("{0} --> Bad Format", input);
         }      
         catch (OverflowException) {
            Console.WriteLine("{0} --> Overflow", input);   
         }            
      }
   }
}
// The example displays the following output:
//       3 --> 03:00:00
//       16:42 --> 16:42:00
//       1:6:52:35.0625 --> Bad Format
//       1:6:52:35,0625 --> 1.06:52:35.0625000

open System
open System.Globalization

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

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

Imports System.Globalization

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

注釈

メソッドは ParseExact(String, String, IFormatProvider) 、時間間隔の文字列表現を解析します。これは、パラメーターで定義されている formats 形式のいずれかである必要があります。ただし、先頭と末尾の空白文字は無視されます。でformats指定された形式のいずれかに完全に準拠している必要があるためinput、ユーザーによる文字列入力を時間間隔に変換するときは、常に例外処理を使用する必要があります。例外処理を使用しない場合は、代わりにメソッドを TryParseExact(String, String[], IFormatProvider, TimeSpan) 呼び出すことができます。

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

重要

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

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

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

こちらもご覧ください

適用対象

ParseExact(String, String, IFormatProvider)

指定した書式とカルチャ固有の書式情報を使用して、時間間隔の文字列形式を等価の TimeSpan に変換します。文字列形式の書式は、指定した書式と完全に一致する必要があります。

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

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

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

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

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

パラメーター

input: String

変換する時間間隔を指定する文字列。

format: String

input で必要とされる書式を定義する標準またはカスタムの書式指定文字列。

formatProvider: IFormatProvider

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

戻り値

TimeSpan

format および formatProvider の指定に従って変換された、input に対応する時間間隔。

例外

ArgumentNullException

input が nullです。

FormatException

input の形式は無効です。

OverflowException

input は、 TimeSpan.MinValue より小さいか、 TimeSpan.MaxValue より大きい数値を表します。

- または -

input の日、時間、分、または秒のコンポーネントのうち少なくとも 1 つが、その有効範囲外です。

例

次の例では、メソッドを ParseExact(String, String, IFormatProvider) 使用して、さまざまな書式指定文字列とカルチャを使用して、時間間隔のいくつかの文字列表現を解析します。

using System;
using System.Globalization;

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

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

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

open System
open System.Globalization

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

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

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

Imports System.Globalization

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

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

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

注釈

メソッドは ParseExact(String, String, IFormatProvider) 、時間間隔の文字列表現を解析します。これは、パラメーターで定義された format 形式である必要があります。ただし、先頭と末尾の空白文字は無視されます。の形式formatに正確に準拠している必要があるためinput、ユーザーによる文字列入力を時間間隔に変換するときは、常に例外処理を使用する必要があります。例外処理を使用しない場合は、代わりにメソッドを TryParseExact(String, String, IFormatProvider, TimeSpan) 呼び出すことができます。

重要

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

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

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

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

こちらもご覧ください

適用対象

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

指定した書式とカルチャ固有の書式情報を使用して、時間間隔の文字スパンを等価の TimeSpan に変換します。文字列形式の書式は、指定した書式と完全に一致する必要があります。

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

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

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

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

パラメーター

input: ReadOnlySpan<Char>

変換する時間間隔を指定するスパン。

format: ReadOnlySpan<Char>

input で必要とされる書式を定義する標準またはカスタムの書式指定文字列。

formatProvider: IFormatProvider

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

styles: TimeSpanStyles

input で使用できるスタイル要素を定義する列挙値のビットごとの組み合わせ。

戻り値

TimeSpan

format および formatProvider の指定に従って変換された、input に対応する時間間隔。

適用対象

TimeSpan.ParseExact メソッド

定義

オーバーロード

ParseExact(String, String, IFormatProvider, TimeSpanStyles)

パラメーター

戻り値

例外

例

注釈

こちらもご覧ください

適用対象

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

パラメーター

戻り値

適用対象

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

パラメーター

戻り値

例外

例

注釈

こちらもご覧ください

適用対象

ParseExact(String, String[], IFormatProvider)

パラメーター

戻り値

例外

例

注釈

こちらもご覧ください

適用対象

ParseExact(String, String, IFormatProvider)

パラメーター

戻り値

例外

例

注釈

こちらもご覧ください

適用対象

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

パラメーター

戻り値

適用対象

フィードバック

その他のリソース