TimeSpan.ParseExact TimeSpan.ParseExact TimeSpan.ParseExact TimeSpan.ParseExact Method

定義

時間間隔の文字列形式を等価の 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) ParseExact(String, String, IFormatProvider, TimeSpanStyles) ParseExact(String, String, IFormatProvider, TimeSpanStyles) 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) ParseExact(ReadOnlySpan<Char>, String[], IFormatProvider, TimeSpanStyles) ParseExact(ReadOnlySpan<Char>, String[], IFormatProvider, TimeSpanStyles)
ParseExact(String, String[], IFormatProvider, TimeSpanStyles) ParseExact(String, String[], IFormatProvider, TimeSpanStyles) ParseExact(String, String[], IFormatProvider, TimeSpanStyles) 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) ParseExact(String, String[], IFormatProvider) ParseExact(String, String[], IFormatProvider) 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) ParseExact(String, String, IFormatProvider) ParseExact(String, String, IFormatProvider) 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) ParseExact(ReadOnlySpan<Char>, ReadOnlySpan<Char>, IFormatProvider, TimeSpanStyles) ParseExact(ReadOnlySpan<Char>, ReadOnlySpan<Char>, IFormatProvider, TimeSpanStyles)

ParseExact(String, String, IFormatProvider, TimeSpanStyles) ParseExact(String, String, IFormatProvider, TimeSpanStyles) ParseExact(String, String, IFormatProvider, TimeSpanStyles) 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 String String String

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

format
String String String String

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

formatProvider
IFormatProvider IFormatProvider IFormatProvider IFormatProvider

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

styles
TimeSpanStyles TimeSpanStyles TimeSpanStyles TimeSpanStyles

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

戻り値

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

例外

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

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. inputの形式に準拠している必要がありますformat正確を使用する例外処理、ユーザーが入力された文字列を時間間隔に変換するときにします。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 つの標準書式指定子、または必要な書式を定義する 1 つまたは複数のカスタム書式指定子を含む文字列inputします。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標準TimeSpan値の"g"または"G"のいずれかの文字列の書式を設定します。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パラメーターは、IFormatProvider場合、返される文字列の書式設定に関するカルチャに固有の情報を提供する実装formatは標準書式指定文字列。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:

場合formatProvidernullDateTimeFormatInfo現在のカルチャに関連付けられているオブジェクトを使用します。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. 判断したかどうかinputは、負の符号が存在する場合にのみ負の時間間隔として解釈されます (TimeSpanStyles.None)、常に負の時間間隔として解釈ことか、または (TimeSpanStyles.AssumeNegative)。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) ParseExact(ReadOnlySpan<Char>, String[], IFormatProvider, TimeSpanStyles) ParseExact(ReadOnlySpan<Char>, String[], IFormatProvider, TimeSpanStyles)

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

パラメーター

formats
String[]

戻り値

ParseExact(String, String[], IFormatProvider, TimeSpanStyles) ParseExact(String, String[], IFormatProvider, TimeSpanStyles) ParseExact(String, String[], IFormatProvider, TimeSpanStyles) 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 String String String

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

formats
String[]

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

formatProvider
IFormatProvider IFormatProvider IFormatProvider IFormatProvider

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

styles
TimeSpanStyles TimeSpanStyles TimeSpanStyles TimeSpanStyles

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

戻り値

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

例外

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

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. inputで指定された形式のいずれかに正確に従っている必要がありますformats、時間間隔をユーザーが入力された文字列を変換するときに常に、例外処理を使用する必要があります。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 つの標準書式指定子、または必要な書式を定義する 1 つまたは複数のカスタム書式指定子のいずれかの要素で構成されますinputします。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. input メンバーと正確に一致する必要がありますformats解析操作を完了します。input must correspond exactly to a member of formats for the parse operation to succeed. 解析操作が、照合しようとしています。input内の各要素にformats以降では、配列の最初の要素。The parse operation attempts to match input to each element in formats starting with the first element in the array.

重要

ParseExactメソッドで指定されたカルチャの規則を使用する、formatProviderパラメーター書式指定文字列を解析するために使用する場合にのみinput標準TimeSpan値の"g"または"G"のいずれかの文字列の書式を設定します。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パラメーターは、IFormatProvider書式指定文字列を解析するために使用する場合に返される文字列の書式設定に関するカルチャに固有の情報を提供する実装inputは標準書式指定文字列です。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:

場合formatProvidernullDateTimeFormatInfo現在のカルチャに関連付けられているオブジェクトを使用します。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. 判断したかどうかinputは、負の符号が存在する場合にのみ負の時間間隔として解釈されます (TimeSpanStyles.None)、常に負の時間間隔として解釈ことか、または (TimeSpanStyles.AssumeNegative)。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) ParseExact(String, String[], IFormatProvider) ParseExact(String, String[], IFormatProvider) 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 String String String

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

formats
String[]

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

formatProvider
IFormatProvider IFormatProvider IFormatProvider IFormatProvider

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

戻り値

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

例外

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. inputで指定された形式のいずれかに正確に従っている必要がありますformats、時間間隔をユーザーが入力された文字列を変換するときに常に、例外処理を使用する必要があります。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 つの標準書式指定子、または必要な書式を定義する 1 つまたは複数のカスタム書式指定子のいずれかの要素で構成されますinputします。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. input メンバーと正確に一致する必要がありますformats解析操作を完了します。input must correspond exactly to a member of formats for the parse operation to succeed. 解析操作が、照合しようとしています。input内の各要素にformats以降では、配列の最初の要素。The parse operation attempts to match input to each element in formats starting with the first element in the array.

重要

ParseExactメソッドで指定されたカルチャの規則を使用する、formatProviderパラメーター書式指定文字列を解析するために使用する場合にのみinput標準TimeSpan値の"g"または"G"のいずれかの文字列の書式を設定します。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パラメーターは、IFormatProvider書式指定文字列を解析するために使用する場合に返される文字列の書式設定に関するカルチャに固有の情報を提供する実装inputは標準書式指定文字列です。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:

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

こちらもご覧ください

ParseExact(String, String, IFormatProvider) ParseExact(String, String, IFormatProvider) ParseExact(String, String, IFormatProvider) 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 String String String

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

format
String String String String

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

formatProvider
IFormatProvider IFormatProvider IFormatProvider IFormatProvider

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

戻り値

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

例外

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. inputの形式に準拠している必要がありますformat正確を使用する例外処理、ユーザーが入力された文字列を時間間隔に変換するときにします。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 つの標準書式指定子、または必要な書式を定義する 1 つまたは複数のカスタム書式指定子を含む文字列inputします。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標準TimeSpan値の"g"または"G"のいずれかの文字列の書式を設定します。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パラメーターは、IFormatProvider場合、返される文字列の書式設定に関するカルチャに固有の情報を提供する実装formatは標準書式指定文字列。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:

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

こちらもご覧ください

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

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

パラメーター

format
ReadOnlySpan<Char>

戻り値

適用対象