TimeSpan.ParseExact メソッド

定義

時間間隔の文字列形式を等価の TimeSpan に変換します。Converts the string representation of a time interval to its TimeSpan equivalent. 文字列形式の書式は、指定した書式と完全に一致する必要があります。The format of the string representation must match a specified format exactly.

オーバーロード

ParseExact(String, String, IFormatProvider, TimeSpanStyles)

指定した書式、カルチャ固有の書式情報、およびスタイルを使用して、時間間隔の文字列形式を等価の TimeSpan に変換します。Converts the string representation of a time interval to its TimeSpan equivalent by using the specified format, culture-specific format information, and styles. 文字列形式の書式は、指定した書式と完全に一致する必要があります。The format of the string representation must match the specified format exactly.

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

指定した書式、カルチャ固有の書式情報、およびスタイルを使用して、時間間隔の文字列形式を等価の TimeSpan に変換します。Converts the string representation of a time interval to its TimeSpan equivalent by using the specified formats, culture-specific format information, and styles. 文字列形式の書式は、指定されたいずれかの書式と完全に一致する必要があります。The format of the string representation must match one of the specified formats exactly.

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

指定した書式、カルチャ固有の書式情報、およびスタイルを使用して、時間間隔の文字列形式を等価の TimeSpan に変換します。Converts the string representation of a time interval to its TimeSpan equivalent by using the specified formats, culture-specific format information, and styles. 文字列形式の書式は、指定されたいずれかの書式と完全に一致する必要があります。The format of the string representation must match one of the specified formats exactly.

ParseExact(String, String[], IFormatProvider)

指定した書式指定文字列の配列とカルチャ固有の書式情報を使用して、時間間隔の文字列形式を等価の TimeSpan に変換します。Converts the string representation of a time interval to its TimeSpan equivalent by using the specified array of format strings and culture-specific format information. 文字列形式の書式は、指定されたいずれかの書式と完全に一致する必要があります。The format of the string representation must match one of the specified formats exactly.

ParseExact(String, String, IFormatProvider)

指定した書式とカルチャ固有の書式情報を使用して、時間間隔の文字列形式を等価の TimeSpan に変換します。Converts the string representation of a time interval to its TimeSpan equivalent by using the specified format and culture-specific format information. 文字列形式の書式は、指定した書式と完全に一致する必要があります。The format of the string representation must match the specified format exactly.

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

指定した書式とカルチャ固有の書式情報を使用して、時間間隔の文字スパンを等価の TimeSpan に変換します。Converts the char span of a time interval to its TimeSpan equivalent by using the specified format and culture-specific format information. 文字列形式の書式は、指定した書式と完全に一致する必要があります。The format of the string representation must match the specified format exactly.

ParseExact(String, String, IFormatProvider, TimeSpanStyles)

指定した書式、カルチャ固有の書式情報、およびスタイルを使用して、時間間隔の文字列形式を等価の TimeSpan に変換します。Converts the string representation of a time interval to its TimeSpan equivalent by using the specified format, culture-specific format information, and styles. 文字列形式の書式は、指定した書式と完全に一致する必要があります。The format of the string representation must match the specified format exactly.

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);
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

変換する時間間隔を指定する文字列。A string that specifies the time interval to convert.

format
String

input で必要とされる書式を定義する標準またはカスタムの書式指定文字列。A standard or custom format string that defines the required format of input.

formatProvider
IFormatProvider

カルチャ固有の書式情報を提供するオブジェクト。An object that provides culture-specific formatting information.

styles
TimeSpanStyles

input で使用できるスタイル要素を定義する列挙値のビットごとの組み合わせ。A bitwise combination of enumeration values that defines the style elements that may be present in input.

戻り値

inputformat、および formatProvider の指定に従って変換された、styles に対応する時間間隔。A time interval that corresponds to input, as specified by format, formatProvider, and styles.

例外

styles は無効な TimeSpanStyles 値です。styles is an invalid TimeSpanStyles value.

inputnull です。input is null.

input の形式は無効です。input has an invalid format.

inputMinValue 未満の数値か、MaxValue より大きい数値を表します。input represents a number that is less than MinValue or greater than MaxValue.

または-or- input の日、時間、分、または秒のコンポーネントのうち少なくとも 1 つが、その有効範囲外です。At least one of the days, hours, minutes, or seconds components in input is outside its valid range.

次の例では、ParseExact(String, String, IFormatProvider) メソッドを使用して、さまざまな書式指定文字列とカルチャを使用して、時間間隔の文字列形式をいくつか解析します。The following example uses the ParseExact(String, String, IFormatProvider) method to parse several string representations of time intervals using various format strings and cultures. また、TimeSpanStyles.AssumeNegative 値を使用して、各文字列を負の時間間隔として解釈します。It also uses the TimeSpanStyles.AssumeNegative value to interpret each string as a negative time interval. この例の出力は、カスタム書式指定文字列で使用されている場合にのみ、TimeSpanStyles.AssumeNegative スタイルが戻り値に影響を与えることを示しています。The output from the example illustrates that the TimeSpanStyles.AssumeNegative style affects the return value only when it is used with custom format strings.

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
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 パラメーターで定義された形式で指定する必要があります。The ParseExact method parses the string representation of a time interval, which must be in the format defined by the format parameter, except that leading and trailing white-space characters are ignored. inputformat の形式に厳密に準拠している必要があるため、ユーザーが入力した文字列を時間間隔に変換する場合は、常に例外処理を使用する必要があります。Because input must conform to the format of format exactly, you should always use exception handling when converting a string input by the user to a time interval. 例外処理を使用しない場合は、代わりに TryParseExact(String, String, IFormatProvider, TimeSpanStyles, TimeSpan) メソッドを呼び出すことができます。If you prefer not to use exception handling, you can call the TryParseExact(String, String, IFormatProvider, TimeSpanStyles, TimeSpan) method instead.

format パラメーターは、1つの標準書式指定子を含む文字列か、または inputの必要な書式を定義する1つ以上のカスタム書式指定子で構成されます。The format parameter is a string that contains either a single standard format specifier, or one or more custom format specifiers that define the required format of input. 有効な書式指定文字列の詳細については、「標準の Timespan 書式指定文字列」および「カスタム TimeSpan 書式指定文字列」を参照してください。For more information about valid format strings, see Standard TimeSpan Format Strings and Custom TimeSpan Format Strings.

重要

ParseExact メソッドは、formatProvider パラメーターで指定されたカルチャの規則を使用します。これは format が、値が "g" または "G" の標準 TimeSpan 書式指定文字列の場合のみです。The ParseExact method uses the conventions of the culture specified by the formatProvider parameter only if format is a standard TimeSpan format string whose value is either "g" or "G". "C"、"t"、"T" の標準書式指定文字列では、インバリアントカルチャの書式指定規則が使用されます。The "c", "t", and "T" standard format strings use the formatting conventions of the invariant culture. カスタム書式指定文字列では、入力文字列の正確な形式が定義され、リテラル文字を使用して時間間隔のコンポーネントが分離されます。Custom format strings define the precise format of the input string and use literal characters to separate the components of a time interval.

formatProvider パラメーターは、format が標準書式指定文字列の場合に、返される文字列の書式に関するカルチャ固有の情報を提供する、IFormatProvider の実装です。The formatProvider parameter is an IFormatProvider implementation that provides culture-specific information about the format of the returned string if format is a standard format string. formatProviderパラメーターには、次のいずれかを指定できます。The formatProvider parameter can be any of the following:

formatProvidernull場合は、現在のカルチャに関連付けられている DateTimeFormatInfo オブジェクトが使用されます。If formatProvider is null, the DateTimeFormatInfo object that is associated with the current culture is used.

styles パラメーターは、カスタム書式指定文字列を使用して解析される文字列の解釈に影響します。The styles parameter affects the interpretation of strings that are parsed using custom format strings. 負の符号が存在する場合 (TimeSpanStyles.None)、または常に負の時間間隔として解釈されるか (TimeSpanStyles.AssumeNegative)、input が負の時間間隔として解釈されるかどうかを決定します。It determines whether input is interpreted as a negative time interval only if a negative sign is present (TimeSpanStyles.None), or whether it is always interpreted as a negative time interval (TimeSpanStyles.AssumeNegative). TimeSpanStyles.AssumeNegative が使用されていない場合、負の時間間隔を正常に解析するには、format にリテラルの負の記号 ("\-" など) を含める必要があります。If TimeSpanStyles.AssumeNegative is not used, format must include a literal negative sign symbol (such as "\-") to successfully parse a negative time interval.

こちらもご覧ください

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

指定した書式、カルチャ固有の書式情報、およびスタイルを使用して、時間間隔の文字列形式を等価の TimeSpan に変換します。Converts the string representation of a time interval to its TimeSpan equivalent by using the specified formats, culture-specific format information, and styles. 文字列形式の書式は、指定されたいずれかの書式と完全に一致する必要があります。The format of the string representation must match one of the specified formats exactly.

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>

変換する時間間隔を指定するスパン。A span that specifies the time interval to convert.

formats
String[]

input で必要とされる書式を定義する標準またはカスタムの書式指定文字列の配列。An array of standard or custom format strings that define the required format of input.

formatProvider
IFormatProvider

カルチャ固有の書式情報を提供するオブジェクト。An object that provides culture-specific formatting information.

styles
TimeSpanStyles

input で使用できるスタイル要素を定義する列挙値のビットごとの組み合わせ。A bitwise combination of enumeration values that defines the style elements that may be present in input.

戻り値

inputformats、および formatProvider の指定に従って変換された、styles に対応する時間間隔。A time interval that corresponds to input, as specified by formats, formatProvider, and styles.

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

指定した書式、カルチャ固有の書式情報、およびスタイルを使用して、時間間隔の文字列形式を等価の TimeSpan に変換します。Converts the string representation of a time interval to its TimeSpan equivalent by using the specified formats, culture-specific format information, and styles. 文字列形式の書式は、指定されたいずれかの書式と完全に一致する必要があります。The format of the string representation must match one of the specified formats exactly.

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);
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

変換する時間間隔を指定する文字列。A string that specifies the time interval to convert.

formats
String[]

input で必要とされる書式を定義する標準またはカスタムの書式指定文字列の配列。An array of standard or custom format strings that define the required format of input.

formatProvider
IFormatProvider

カルチャ固有の書式情報を提供するオブジェクト。An object that provides culture-specific formatting information.

styles
TimeSpanStyles

input で使用できるスタイル要素を定義する列挙値のビットごとの組み合わせ。A bitwise combination of enumeration values that defines the style elements that may be present in input.

戻り値

inputformats、および formatProvider の指定に従って変換された、styles に対応する時間間隔。A time interval that corresponds to input, as specified by formats, formatProvider, and styles.

例外

styles は無効な TimeSpanStyles 値です。styles is an invalid TimeSpanStyles value.

inputnull です。input is null.

input の形式は無効です。input has an invalid format.

inputMinValue 未満の数値か、MaxValue より大きい数値を表します。input represents a number that is less than MinValue or greater than MaxValue.

または-or- input の日、時間、分、または秒のコンポーネントのうち少なくとも 1 つが、その有効範囲外です。At least one of the days, hours, minutes, or seconds components in input is outside its valid range.

次の例では、ParseExact(String, String[], IFormatProvider, TimeSpanStyles) メソッドを呼び出して、文字列配列の各要素を TimeSpan 値に変換します。The following example calls the ParseExact(String, String[], IFormatProvider, TimeSpanStyles) method to convert each element of a string array to a TimeSpan value. 文字列は、一般的な短い形式または一般の長い形式の時間間隔を表すことができます。The strings can represent a time interval in either the general short format or the general long format.

さらに、この例では、時間間隔の解析メソッドが1つの数字を解釈する方法を変更します。In addition, the example changes the way in which the time interval parsing methods interpret a single digit. 通常、1桁の数字は、時間間隔の日数として解釈されます。Ordinarily, a single digit is interpreted as the number of days in a time interval. 代わりに、%h カスタム書式指定文字列を使用して、1つの数字を時間数として解釈します。Instead, the %h custom format string is used to interpret a single digit as the number of hours. この変更を有効にするには、%h カスタム書式指定文字列が、formats 配列内の他の書式指定文字列の前に配置されている必要があることに注意してください。For this change to be effective, note that the %h custom format string must precede the other format strings in the formats array. また、出力から、メソッドの呼び出しで指定された TimeSpanStyles.AssumeNegative フラグが、この書式指定子を使用して文字列を解析する場合にのみ使用されていることにも注意してください。Also note from the output that the TimeSpanStyles.AssumeNegative flag specified in the method call is used only when parsing a string with this format specifier.

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
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 パラメーターで定義されたいずれかの形式にする必要があります。The ParseExact(String, String[], IFormatProvider, TimeSpanStyles) method parses the string representation of a time interval, which must be in one of the formats defined by the formats parameter, except that leading and trailing white-space characters are ignored. inputformatsで指定された形式のいずれかに正確に準拠している必要があるため、ユーザーが入力した文字列を時間間隔に変換する場合は、常に例外処理を使用する必要があります。Because input must exactly conform to one of the formats specified in formats, you should always use exception handling when converting a string input by the user to a time interval. 例外処理を使用しない場合は、代わりに TryParseExact(String, String[], IFormatProvider, TimeSpanStyles, TimeSpan) メソッドを呼び出すことができます。If you prefer not to use exception handling, you can call the TryParseExact(String, String[], IFormatProvider, TimeSpanStyles, TimeSpan) method instead.

formats パラメーターは、1つの標準書式指定子、または必要な形式の inputを定義する1つ以上のカスタム書式指定子で構成される要素を持つ文字列配列です。The formats parameter is a string array whose elements consist of either a single standard format specifier, or one or more custom format specifiers that define the required format of input. 有効な書式指定文字列の詳細については、「標準の Timespan 書式指定文字列」および「カスタム TimeSpan 書式指定文字列」を参照してください。For more information about valid format strings, see Standard TimeSpan Format Strings and Custom TimeSpan Format Strings. 解析操作を成功させるには、inputformats のメンバーと正確に対応している必要があります。input must correspond exactly to a member of formats for the parse operation to succeed. 解析操作は、配列内の最初の要素で始まる formats 内の各要素に対して、input の照合を試みます。The parse operation attempts to match input to each element in formats starting with the first element in the array.

重要

ParseExact メソッドは、formatProvider パラメーターで指定されたカルチャの規則を使用します。これは input の解析に使用される書式指定文字列が、"g" または "G" の値を持つ標準 TimeSpan 書式指定文字列である場合のみです。The ParseExact method uses the conventions of the culture specified by the formatProvider parameter only if the format string used to parse input is a standard TimeSpan format string whose value is either "g" or "G". "C"、"t"、"T" の標準書式指定文字列では、インバリアントカルチャの書式指定規則が使用されます。The "c", "t", and "T" standard format strings use the formatting conventions of the invariant culture. カスタム書式指定文字列では、入力文字列の正確な形式が定義され、リテラル文字を使用して時間間隔のコンポーネントが分離されます。Custom format strings define the precise format of the input string and use literal characters to separate the components of a time interval.

formatProvider パラメーターは、input の解析に使用される書式指定文字列が標準書式指定文字列の場合に、返される文字列の書式に関するカルチャ固有の情報を提供する、IFormatProvider の実装です。The formatProvider parameter is an IFormatProvider implementation that provides culture-specific information about the format of the returned string if the format string used to parse input is a standard format string. formatProviderパラメーターには、次のいずれかを指定できます。The formatProvider parameter can be any of the following:

formatProvidernull場合は、現在のカルチャに関連付けられている DateTimeFormatInfo オブジェクトが使用されます。If formatProvider is null, the DateTimeFormatInfo object that is associated with the current culture is used.

styles パラメーターは、カスタム書式指定文字列を使用して解析される文字列の解釈に影響します。The styles parameter affects the interpretation of strings that are parsed using custom format strings. 負の符号が存在する場合 (TimeSpanStyles.None)、または常に負の時間間隔として解釈されるか (TimeSpanStyles.AssumeNegative)、input が負の時間間隔として解釈されるかどうかを決定します。It determines whether input is interpreted as a negative time interval only if a negative sign is present (TimeSpanStyles.None), or whether it is always interpreted as a negative time interval (TimeSpanStyles.AssumeNegative). TimeSpanStyles.AssumeNegative が使用されていない場合、負の時間間隔を正常に解析するには、format にリテラルの負の記号 ("\-" など) を含める必要があります。If TimeSpanStyles.AssumeNegative is not used, format must include a literal negative sign symbol (such as "\-") to successfully parse a negative time interval.

こちらもご覧ください

ParseExact(String, String[], IFormatProvider)

指定した書式指定文字列の配列とカルチャ固有の書式情報を使用して、時間間隔の文字列形式を等価の TimeSpan に変換します。Converts the string representation of a time interval to its TimeSpan equivalent by using the specified array of format strings and culture-specific format information. 文字列形式の書式は、指定されたいずれかの書式と完全に一致する必要があります。The format of the string representation must match one of the specified formats exactly.

public:
 static TimeSpan ParseExact(System::String ^ input, cli::array <System::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

変換する時間間隔を指定する文字列。A string that specifies the time interval to convert.

formats
String[]

input で必要とされる書式を定義する標準またはカスタムの書式指定文字列の配列。An array of standard or custom format strings that defines the required format of input.

formatProvider
IFormatProvider

カルチャ固有の書式情報を提供するオブジェクト。An object that provides culture-specific formatting information.

戻り値

input および formats の指定に従って変換された、formatProvider に対応する時間間隔。A time interval that corresponds to input, as specified by formats and formatProvider.

例外

inputnull です。input is null.

input の形式は無効です。input has an invalid format.

inputMinValue 未満の数値か、MaxValue より大きい数値を表します。input represents a number that is less than MinValue or greater than MaxValue.

または-or- input の日、時間、分、または秒のコンポーネントのうち少なくとも 1 つが、その有効範囲外です。At least one of the days, hours, minutes, or seconds components in input is outside its valid range.

次の例では、ParseExact(String, String[], IFormatProvider) メソッドを呼び出して、文字列配列の各要素を TimeSpan 値に変換します。The following example calls the ParseExact(String, String[], IFormatProvider) method to convert each element of a string array to a TimeSpan value. この例では、フランス語-フランス語 ("fr-fr") カルチャの書式指定規則を使用して、文字列を解釈します。The example interprets the strings using the formatting conventions of the French - France ("fr-FR") culture. 文字列は、一般的な短い形式または一般の長い形式の時間間隔を表すことができます。The strings can represent a time interval in either the general short format or the general long format.

さらに、この例では、時間間隔の解析メソッドが1つの数字を解釈する方法を変更します。In addition, the example changes the way in which the time interval parsing methods interpret a single digit. 通常、1桁の数字は、時間間隔の日数として解釈されます。Ordinarily, a single digit is interpreted as the number of days in a time interval. 代わりに、%h カスタム書式指定文字列を使用して、1つの数字を時間数として解釈します。Instead, the %h custom format string is used to interpret a single digit as the number of hours. この変更を有効にするには、%h カスタム書式指定文字列が、formats 配列内の他の書式指定文字列の前に配置されている必要があることに注意してください。For this change to be effective, note that the %h custom format string must precede the other format strings in the formats array.

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
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 パラメーターで定義されたいずれかの形式にする必要があります。The ParseExact(String, String, IFormatProvider) method parses the string representation of a time interval, which must be in one of the formats defined by the formats parameter, except that leading and trailing white-space characters are ignored. inputformatsで指定された形式のいずれかに正確に準拠している必要があるため、ユーザーが入力した文字列を時間間隔に変換する場合は、常に例外処理を使用する必要があります。Because input must exactly conform to one of the formats specified in formats, you should always use exception handling when converting a string input by the user to a time interval. 例外処理を使用しない場合は、代わりに TryParseExact(String, String[], IFormatProvider, TimeSpan) メソッドを呼び出すことができます。If you prefer not to use exception handling, you can call the TryParseExact(String, String[], IFormatProvider, TimeSpan) method instead.

formats パラメーターは、1つの標準書式指定子、または必要な形式の inputを定義する1つ以上のカスタム書式指定子で構成される要素を持つ文字列配列です。The formats parameter is a string array whose elements consist of either a single standard format specifier, or one or more custom format specifiers that define the required format of input. 有効な書式指定文字列の詳細については、「標準の Timespan 書式指定文字列」および「カスタム TimeSpan 書式指定文字列」を参照してください。For more information about valid format strings, see Standard TimeSpan Format Strings and Custom TimeSpan Format Strings. 解析操作を成功させるには、inputformats のメンバーと正確に対応している必要があります。input must correspond exactly to a member of formats for the parse operation to succeed. 解析操作は、配列内の最初の要素で始まる formats 内の各要素に対して、input の照合を試みます。The parse operation attempts to match input to each element in formats starting with the first element in the array.

重要

ParseExact メソッドは、formatProvider パラメーターで指定されたカルチャの規則を使用します。これは input の解析に使用される書式指定文字列が、"g" または "G" の値を持つ標準 TimeSpan 書式指定文字列である場合のみです。The ParseExact method uses the conventions of the culture specified by the formatProvider parameter only if the format string used to parse input is a standard TimeSpan format string whose value is either "g" or "G". "C"、"t"、"T" の標準書式指定文字列では、インバリアントカルチャの書式指定規則が使用されます。The "c", "t", and "T" standard format strings use the formatting conventions of the invariant culture. カスタム書式指定文字列では、入力文字列の正確な形式が定義され、リテラル文字を使用して時間間隔のコンポーネントが分離されます。Custom format strings define the precise format of the input string and use literal characters to separate the components of a time interval.

formatProvider パラメーターは、input の解析に使用される書式指定文字列が標準書式指定文字列の場合に、返される文字列の書式に関するカルチャ固有の情報を提供する、IFormatProvider の実装です。The formatProvider parameter is an IFormatProvider implementation that provides culture-specific information about the format of the returned string if the format string used to parse input is a standard format string. formatProviderパラメーターには、次のいずれかを指定できます。The formatProvider parameter can be any of the following:

formatProvidernull場合は、現在のカルチャに関連付けられている DateTimeFormatInfo オブジェクトが使用されます。If formatProvider is null, the DateTimeFormatInfo object that is associated with the current culture is used.

こちらもご覧ください

ParseExact(String, String, IFormatProvider)

指定した書式とカルチャ固有の書式情報を使用して、時間間隔の文字列形式を等価の TimeSpan に変換します。Converts the string representation of a time interval to its TimeSpan equivalent by using the specified format and culture-specific format information. 文字列形式の書式は、指定した書式と完全に一致する必要があります。The format of the string representation must match the specified format exactly.

public:
 static TimeSpan ParseExact(System::String ^ input, System::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

変換する時間間隔を指定する文字列。A string that specifies the time interval to convert.

format
String

input で必要とされる書式を定義する標準またはカスタムの書式指定文字列。A standard or custom format string that defines the required format of input.

formatProvider
IFormatProvider

カルチャ固有の書式情報を提供するオブジェクト。An object that provides culture-specific formatting information.

戻り値

input および format の指定に従って変換された、formatProvider に対応する時間間隔。A time interval that corresponds to input, as specified by format and formatProvider.

例外

inputnull です。input is null.

input の形式は無効です。input has an invalid format.

inputMinValue 未満の数値か、MaxValue より大きい数値を表します。input represents a number that is less than MinValue or greater than MaxValue.

または-or- input の日、時間、分、または秒のコンポーネントのうち少なくとも 1 つが、その有効範囲外です。At least one of the days, hours, minutes, or seconds components in input is outside its valid range.

次の例では、ParseExact(String, String, IFormatProvider) メソッドを使用して、さまざまな書式指定文字列とカルチャを使用して、時間間隔の文字列形式をいくつか解析します。The following example uses the ParseExact(String, String, IFormatProvider) method to parse several string representations of time intervals using various format strings and cultures.

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
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 パラメーターで定義された形式で指定する必要があります。The ParseExact(String, String, IFormatProvider) method parses the string representation of a time interval, which must be in the format defined by the format parameter, except that leading and trailing white-space characters are ignored. inputformat の形式に厳密に準拠している必要があるため、ユーザーが入力した文字列を時間間隔に変換する場合は、常に例外処理を使用する必要があります。Because input must conform to the format of format exactly, you should always use exception handling when converting a string input by the user to a time interval. 例外処理を使用しない場合は、代わりに TryParseExact(String, String, IFormatProvider, TimeSpan) メソッドを呼び出すことができます。If you prefer not to use exception handling, you can call the TryParseExact(String, String, IFormatProvider, TimeSpan) method instead.

format パラメーターは、1つの標準書式指定子を含む文字列か、または inputの必要な書式を定義する1つ以上のカスタム書式指定子で構成されます。The format parameter is a string that contains either a single standard format specifier, or one or more custom format specifiers that define the required format of input. 有効な書式指定文字列の詳細については、「標準の Timespan 書式指定文字列」および「カスタム TimeSpan 書式指定文字列」を参照してください。For more information about valid format strings, see Standard TimeSpan Format Strings and Custom TimeSpan Format Strings.

重要

ParseExact メソッドは、formatProvider パラメーターで指定されたカルチャの規則を使用します。これは format が、値が "g" または "G" の標準 TimeSpan 書式指定文字列の場合のみです。The ParseExact method uses the conventions of the culture specified by the formatProvider parameter only if format is a standard TimeSpan format string whose value is either "g" or "G". "C"、"t"、"T" の標準書式指定文字列では、インバリアントカルチャの書式指定規則が使用されます。The "c", "t", and "T" standard format strings use the formatting conventions of the invariant culture. カスタム書式指定文字列では、入力文字列の正確な形式が定義され、リテラル文字を使用して時間間隔のコンポーネントが分離されます。Custom format strings define the precise format of the input string and use literal characters to separate the components of a time interval.

formatProvider パラメーターは、format が標準書式指定文字列の場合に、返される文字列の書式に関するカルチャ固有の情報を提供する、IFormatProvider の実装です。The formatProvider parameter is an IFormatProvider implementation that provides culture-specific information about the format of the returned string if format is a standard format string. formatProviderパラメーターには、次のいずれかを指定できます。The formatProvider parameter can be any of the following:

formatProvidernull場合は、現在のカルチャに関連付けられている DateTimeFormatInfo オブジェクトが使用されます。If formatProvider is null, the DateTimeFormatInfo object that is associated with the current culture is used.

こちらもご覧ください

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

指定した書式とカルチャ固有の書式情報を使用して、時間間隔の文字スパンを等価の TimeSpan に変換します。Converts the char span of a time interval to its TimeSpan equivalent by using the specified format and culture-specific format information. 文字列形式の書式は、指定した書式と完全に一致する必要があります。The format of the string representation must match the specified format exactly.

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>

変換する時間間隔を指定するスパン。A span that specifies the time interval to convert.

format
ReadOnlySpan<Char>

input で必要とされる書式を定義する標準またはカスタムの書式指定文字列。A standard or custom format string that defines the required format of input.

formatProvider
IFormatProvider

カルチャ固有の書式情報を提供するオブジェクト。An object that provides culture-specific formatting information.

styles
TimeSpanStyles

input で使用できるスタイル要素を定義する列挙値のビットごとの組み合わせ。A bitwise combination of enumeration values that defines the style elements that may be present in input.

戻り値

input および format の指定に従って変換された、formatProvider に対応する時間間隔。A time interval that corresponds to input, as specified by format and formatProvider.

適用対象