TimeSpan.ParseExact 메서드

참조

정의

네임스페이스:: System

어셈블리:: System.Runtime.dll

어셈블리:: mscorlib.dll

어셈블리:: netstandard.dll

중요

일부 정보는 릴리스되기 전에 상당 부분 수정될 수 있는 시험판 제품과 관련이 있습니다. Microsoft는 여기에 제공된 정보에 대해 어떠한 명시적이거나 묵시적인 보증도 하지 않습니다.

시간 간격의 문자열 표현을 해당하는 TimeSpan 변환합니다. 문자열 표현의 형식은 지정된 형식과 정확히 일치해야 합니다.

오버로드

ParseExact(String, String, IFormatProvider)	지정된 형식 및 문화권별 형식 정보를 사용하여 시간 간격의 문자열 표현을 해당하는 TimeSpan 변환합니다. 문자열 표현의 형식은 지정된 형식과 정확히 일치해야 합니다.
ParseExact(String, String[], IFormatProvider)	지정된 형식 문자열 배열과 문화권별 서식 정보를 사용하여 시간 간격의 문자열 표현을 해당 TimeSpan 해당 항목으로 변환합니다. 문자열 표현의 형식은 지정된 형식 중 하나와 정확히 일치해야 합니다.
ParseExact(ReadOnlySpan<Char>, ReadOnlySpan<Char>, IFormatProvider, TimeSpanStyles)	지정된 형식 및 문화권별 형식 정보를 사용하여 시간 간격의 문자 범위를 해당하는 TimeSpan 변환합니다. 문자열 표현의 형식은 지정된 형식과 정확히 일치해야 합니다.
ParseExact(ReadOnlySpan<Char>, String[], IFormatProvider, TimeSpanStyles)	지정된 형식, 문화권별 서식 정보 및 스타일을 사용하여 시간 간격의 문자열 표현을 해당 TimeSpan 해당 형식으로 변환합니다. 문자열 표현의 형식은 지정된 형식 중 하나와 정확히 일치해야 합니다.
ParseExact(String, String, IFormatProvider, TimeSpanStyles)	지정된 형식, 문화권별 형식 정보 및 스타일을 사용하여 시간 간격의 문자열 표현을 해당 TimeSpan 해당 형식으로 변환합니다. 문자열 표현의 형식은 지정된 형식과 정확히 일치해야 합니다.
ParseExact(String, String[], IFormatProvider, TimeSpanStyles)	지정된 형식, 문화권별 서식 정보 및 스타일을 사용하여 시간 간격의 문자열 표현을 해당 TimeSpan 해당 형식으로 변환합니다. 문자열 표현의 형식은 지정된 형식 중 하나와 정확히 일치해야 합니다.

ParseExact(String, String, IFormatProvider)

Source:: TimeSpan.cs

Source:: TimeSpan.cs

Source:: TimeSpan.cs

지정된 형식 및 문화권별 형식 정보를 사용하여 시간 간격의 문자열 표현을 해당하는 TimeSpan 변환합니다. 문자열 표현의 형식은 지정된 형식과 정확히 일치해야 합니다.

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

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

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

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

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

매개 변수

input: String

변환할 시간 간격을 지정하는 문자열입니다.

format: String

필요한 input형식을 정의하는 표준 또는 사용자 지정 형식 문자열입니다.

formatProvider: IFormatProvider

문화권별 서식 정보를 제공하는 개체입니다.

반환

TimeSpan

format 및 formatProvider지정된 input해당하는 시간 간격입니다.

예외

ArgumentNullException

input null.

FormatException

input 형식이 잘못되었습니다.

OverflowException

TimeSpan.MinValue 미만이거나 TimeSpan.MaxValue보다 큰 숫자를 나타냅니다.

-또는-

input 일, 시간, 분 또는 초 구성 요소 중 하나 이상이 유효한 범위를 벗어났습니다.

예제

다음 예제에서는 ParseExact(String, String, IFormatProvider) 메서드를 사용하여 다양한 형식 문자열 및 문화권을 사용하여 시간 간격의 여러 문자열 표현을 구문 분석합니다.

using System;
using System.Globalization;

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

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

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

open System
open System.Globalization

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

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

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

Imports System.Globalization

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

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

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

설명

ParseExact(String, String, IFormatProvider) 메서드는 선행 및 후행 공백 문자가 무시된다는 점을 제외하고 format 매개 변수에 정의된 형식이어야 하는 시간 간격의 문자열 표현을 구문 분석합니다. input format 형식을 정확히 준수해야 하므로 사용자가 문자열 입력을 시간 간격으로 변환할 때 항상 예외 처리를 사용해야 합니다. 예외 처리를 사용하지 않으려는 경우 대신 TryParseExact(String, String, IFormatProvider, TimeSpan) 메서드를 호출할 수 있습니다.

format 매개 변수는 단일 표준 형식 지정자 또는 필요한 input형식을 정의하는 하나 이상의 사용자 지정 형식 지정자를 포함하는 문자열입니다. 유효한 형식 문자열에 대한 자세한 내용은 Standard TimeSpan Format Strings 및 Custom TimeSpan Format Strings참조하세요.

중요하다

ParseExact 메서드는 format 값이 "g" 또는 "G"인 표준 TimeSpan 형식 문자열인 경우에만 formatProvider 매개 변수로 지정된 문화권의 규칙을 사용합니다. "c", "t" 및 "T" 표준 형식 문자열은 고정 문화권의 서식 규칙을 사용합니다. 사용자 지정 형식 문자열은 입력 문자열의 정확한 형식을 정의하고 리터럴 문자를 사용하여 시간 간격의 구성 요소를 구분합니다.

formatProvider 매개 변수는 format 표준 형식 문자열인 경우 반환된 문자열의 형식에 대한 문화권별 정보를 제공하는 IFormatProvider 구현입니다. formatProvider 매개 변수는 다음 중 어느 것일 수 있습니다.

반환된 문자열에 서식 규칙을 반영해야 하는 문화권을 나타내는 CultureInfo 개체입니다. CultureInfo.DateTimeFormat 속성에서 반환된 DateTimeFormatInfo 개체는 반환된 문자열의 서식을 정의합니다.
반환된 문자열의 서식을 정의하는 DateTimeFormatInfo 개체입니다.
IFormatProvider 인터페이스를 구현하는 사용자 지정 개체입니다. 해당 IFormatProvider.GetFormat 메서드는 서식 정보를 제공하는 DateTimeFormatInfo 개체를 반환합니다.

formatProvider null경우 현재 문화권과 연결된 DateTimeFormatInfo 개체가 사용됩니다.

추가 정보

표준 TimeSpan 형식 문자열
사용자 지정 TimeSpan 형식 문자열

적용 대상

ParseExact(String, String[], IFormatProvider)

Source:: TimeSpan.cs

Source:: TimeSpan.cs

Source:: TimeSpan.cs

지정된 형식 문자열 배열과 문화권별 서식 정보를 사용하여 시간 간격의 문자열 표현을 해당 TimeSpan 해당 항목으로 변환합니다. 문자열 표현의 형식은 지정된 형식 중 하나와 정확히 일치해야 합니다.

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

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

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

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

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

매개 변수

input: String

변환할 시간 간격을 지정하는 문자열입니다.

formats: String[]

필요한 input형식을 정의하는 표준 또는 사용자 지정 형식 문자열의 배열입니다.

formatProvider: IFormatProvider

문화권별 서식 정보를 제공하는 개체입니다.

반환

TimeSpan

formats 및 formatProvider지정된 input해당하는 시간 간격입니다.

예외

ArgumentNullException

input null.

FormatException

input 형식이 잘못되었습니다.

OverflowException

TimeSpan.MinValue 미만이거나 TimeSpan.MaxValue보다 큰 숫자를 나타냅니다.

-또는-

input 일, 시간, 분 또는 초 구성 요소 중 하나 이상이 유효한 범위를 벗어났습니다.

예제

다음 예제에서는 ParseExact(String, String[], IFormatProvider) 메서드를 호출하여 문자열 배열의 각 요소를 TimeSpan 값으로 변환합니다. 이 예제에서는 프랑스어 - 프랑스("fr-FR") 문화권의 서식 규칙을 사용하여 문자열을 해석합니다. 문자열은 일반적인 짧은 형식 또는 일반 long 형식으로 시간 간격을 나타낼 수 있습니다.

또한 이 예제에서는 시간 간격 구문 분석 메서드가 한 자릿수를 해석하는 방식을 변경합니다. 일반적으로 한 자리는 시간 간격의 일 수로 해석됩니다. 대신 %h 사용자 지정 서식 문자열을 사용하여 한 숫자를 시간 수로 해석합니다. 이 변경 내용이 적용되려면 %h 사용자 지정 서식 문자열이 formats 배열의 다른 형식 문자열 앞에 있어야 합니다.

using System;
using System.Globalization;

public class Example
{
   public static void Main()
   {
      string[] inputs = { "3", "16:42", "1:6:52:35.0625", 
                          "1:6:52:35,0625" }; 
      string[] formats = { "g", "G", "%h"};
      TimeSpan interval;
      CultureInfo culture = new CultureInfo("fr-FR");
      
      // Parse each string in inputs using formats and the fr-FR culture.
      foreach (string input in inputs) {
         try {
            interval = TimeSpan.ParseExact(input, formats, culture);
            Console.WriteLine("{0} --> {1:c}", input, interval);
         }
         catch (FormatException) {
            Console.WriteLine("{0} --> Bad Format", input);
         }      
         catch (OverflowException) {
            Console.WriteLine("{0} --> Overflow", input);   
         }            
      }
   }
}
// The example displays the following output:
//       3 --> 03:00:00
//       16:42 --> 16:42:00
//       1:6:52:35.0625 --> Bad Format
//       1:6:52:35,0625 --> 1.06:52:35.0625000

open System
open System.Globalization

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

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

Imports System.Globalization

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

설명

ParseExact(String, String, IFormatProvider) 메서드는 선행 및 후행 공백 문자가 무시된다는 점을 제외하고 formats 매개 변수에서 정의한 형식 중 하나여야 하는 시간 간격의 문자열 표현을 구문 분석합니다. input formats지정된 형식 중 하나를 정확히 준수해야 하므로 사용자가 문자열 입력을 시간 간격으로 변환할 때 항상 예외 처리를 사용해야 합니다. 예외 처리를 사용하지 않으려는 경우 대신 TryParseExact(String, String[], IFormatProvider, TimeSpan) 메서드를 호출할 수 있습니다.

formats 매개 변수는 요소가 단일 표준 형식 지정자 또는 필요한 input형식을 정의하는 하나 이상의 사용자 지정 형식 지정자로 구성된 문자열 배열입니다. 유효한 형식 문자열에 대한 자세한 내용은 Standard TimeSpan Format Strings 및 Custom TimeSpan Format Strings참조하세요. input 구문 분석 작업이 성공하려면 formats 멤버와 정확히 일치해야 합니다. 구문 분석 작업은 배열의 첫 번째 요소부터 시작하여 formats 각 요소에 input 일치시키려고 시도합니다.

중요하다

ParseExact 메서드는 input 구문 분석하는 데 사용되는 형식 문자열이 값이 "g" 또는 "G"인 표준 TimeSpan 형식 문자열인 경우에만 formatProvider 매개 변수로 지정된 문화권의 규칙을 사용합니다. "c", "t" 및 "T" 표준 형식 문자열은 고정 문화권의 서식 규칙을 사용합니다. 사용자 지정 형식 문자열은 입력 문자열의 정확한 형식을 정의하고 리터럴 문자를 사용하여 시간 간격의 구성 요소를 구분합니다.

formatProvider 매개 변수는 input 구문 분석하는 데 사용되는 형식 문자열이 표준 형식 문자열인 경우 반환된 문자열의 형식에 대한 문화권별 정보를 제공하는 IFormatProvider 구현입니다. formatProvider 매개 변수는 다음 중 어느 것일 수 있습니다.

반환된 문자열에 서식 규칙을 반영해야 하는 문화권을 나타내는 CultureInfo 개체입니다. CultureInfo.DateTimeFormat 속성에서 반환된 DateTimeFormatInfo 개체는 반환된 문자열의 서식을 정의합니다.
반환된 문자열의 서식을 정의하는 DateTimeFormatInfo 개체입니다.
IFormatProvider 인터페이스를 구현하는 사용자 지정 개체입니다. 해당 IFormatProvider.GetFormat 메서드는 서식 정보를 제공하는 DateTimeFormatInfo 개체를 반환합니다.

formatProvider null경우 현재 문화권과 연결된 DateTimeFormatInfo 개체가 사용됩니다.

추가 정보

TryParseExact(String, String[], IFormatProvider, TimeSpan)
표준 TimeSpan 형식 문자열
사용자 지정 TimeSpan 형식 문자열

적용 대상

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

Source:: TimeSpan.cs

Source:: TimeSpan.cs

Source:: TimeSpan.cs

지정된 형식 및 문화권별 형식 정보를 사용하여 시간 간격의 문자 범위를 해당하는 TimeSpan 변환합니다. 문자열 표현의 형식은 지정된 형식과 정확히 일치해야 합니다.

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

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

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

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

매개 변수

input: ReadOnlySpan<Char>

변환할 시간 간격을 지정하는 범위입니다.

format: ReadOnlySpan<Char>

필요한 input형식을 정의하는 표준 또는 사용자 지정 형식 문자열입니다.

formatProvider: IFormatProvider

문화권별 서식 정보를 제공하는 개체입니다.

styles: TimeSpanStyles

input있을 수 있는 스타일 요소를 정의하는 열거형 값의 비트 조합입니다.

반환

TimeSpan

format 및 formatProvider지정된 input해당하는 시간 간격입니다.

적용 대상

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

Source:: TimeSpan.cs

Source:: TimeSpan.cs

Source:: TimeSpan.cs

지정된 형식, 문화권별 서식 정보 및 스타일을 사용하여 시간 간격의 문자열 표현을 해당 TimeSpan 해당 형식으로 변환합니다. 문자열 표현의 형식은 지정된 형식 중 하나와 정확히 일치해야 합니다.

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

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

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

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

매개 변수

input: ReadOnlySpan<Char>

변환할 시간 간격을 지정하는 범위입니다.

formats: String[]

필요한 input형식을 정의하는 표준 또는 사용자 지정 형식 문자열의 배열입니다.

formatProvider: IFormatProvider

문화권별 서식 정보를 제공하는 개체입니다.

styles: TimeSpanStyles

입력에 있을 수 있는 스타일 요소를 정의하는 열거형 값의 비트 조합입니다.

반환

TimeSpan

formats, formatProvider및 styles지정된 input해당하는 시간 간격입니다.

적용 대상

ParseExact(String, String, IFormatProvider, TimeSpanStyles)

Source:: TimeSpan.cs

Source:: TimeSpan.cs

Source:: TimeSpan.cs

지정된 형식, 문화권별 형식 정보 및 스타일을 사용하여 시간 간격의 문자열 표현을 해당 TimeSpan 해당 형식으로 변환합니다. 문자열 표현의 형식은 지정된 형식과 정확히 일치해야 합니다.

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

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

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

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

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

매개 변수

input: String

변환할 시간 간격을 지정하는 문자열입니다.

format: String

필요한 input형식을 정의하는 표준 또는 사용자 지정 형식 문자열입니다.

formatProvider: IFormatProvider

문화권별 서식 정보를 제공하는 개체입니다.

styles: TimeSpanStyles

input있을 수 있는 스타일 요소를 정의하는 열거형 값의 비트 조합입니다.

반환

TimeSpan

format, formatProvider및 styles지정된 input해당하는 시간 간격입니다.

예외

ArgumentException

styles 잘못된 TimeSpanStyles 값입니다.

ArgumentNullException

input null.

FormatException

input 형식이 잘못되었습니다.

OverflowException

TimeSpan.MinValue 미만이거나 TimeSpan.MaxValue보다 큰 숫자를 나타냅니다.

-또는-

input 일, 시간, 분 또는 초 구성 요소 중 하나 이상이 유효한 범위를 벗어났습니다.

예제

다음 예제에서는 ParseExact(String, String, IFormatProvider) 메서드를 사용하여 다양한 형식 문자열 및 문화권을 사용하여 시간 간격의 여러 문자열 표현을 구문 분석합니다. 또한 TimeSpanStyles.AssumeNegative 값을 사용하여 각 문자열을 음수 시간 간격으로 해석합니다. 이 예제의 출력은 TimeSpanStyles.AssumeNegative 스타일이 사용자 지정 형식 문자열과 함께 사용되는 경우에만 반환 값에 영향을 주는 것을 보여 줍니다.

using System;
using System.Globalization;

public class Example
{
   public static void Main()
   {
      string intervalString, format;
      TimeSpan interval;
      CultureInfo culture = null;
      
      // Parse hour:minute value with custom format specifier.
      intervalString = "17:14";
      format = "h\\:mm";
      culture = CultureInfo.CurrentCulture;
      try {
         interval = TimeSpan.ParseExact(intervalString, format, 
                                        culture, TimeSpanStyles.AssumeNegative);
         Console.WriteLine("'{0}' ({1}) --> {2}", intervalString, format, interval);
      }   
      catch (FormatException) {
         Console.WriteLine("'{0}': Bad Format for '{1}'", intervalString, format);
      }   
      catch (OverflowException) {
         Console.WriteLine("'{0}': Overflow", intervalString);
      }      
      
      // Parse hour:minute:second value with "g" specifier.
      intervalString = "17:14:48";
      format = "g";
      culture = CultureInfo.InvariantCulture;
      try {
         interval = TimeSpan.ParseExact(intervalString, format, 
                                        culture, TimeSpanStyles.AssumeNegative);
         Console.WriteLine("'{0}' ({1}) --> {2}", intervalString, format, interval);
      }
      catch (FormatException) {
         Console.WriteLine("'{0}': Bad Format for '{1}'", intervalString, format);
      }   
      catch (OverflowException) {
         Console.WriteLine("'{0}': Overflow", intervalString);
      } 
      
      // Parse hours:minute.second value with custom format specifier.     
      intervalString = "17:14:48.153";
      format = @"h\:mm\:ss\.fff";
      culture = null;
      try {
         interval = TimeSpan.ParseExact(intervalString, format, 
                                        culture, TimeSpanStyles.AssumeNegative);
         Console.WriteLine("'{0}' ({1}) --> {2}", intervalString, format, interval);
      }
      catch (FormatException) {
         Console.WriteLine("'{0}': Bad Format for '{1}'", intervalString, format);
      }   
      catch (OverflowException) {
         Console.WriteLine("'{0}': Overflow", intervalString);
      } 

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

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

open System
open System.Globalization

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

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

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

Imports System.Globalization

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

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

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

설명

ParseExact 메서드는 선행 및 후행 공백 문자가 무시된다는 점을 제외하고 format 매개 변수에 정의된 형식이어야 하는 시간 간격의 문자열 표현을 구문 분석합니다. input format 형식을 정확히 준수해야 하므로 사용자가 문자열 입력을 시간 간격으로 변환할 때 항상 예외 처리를 사용해야 합니다. 예외 처리를 사용하지 않으려는 경우 대신 TryParseExact(String, String, IFormatProvider, TimeSpanStyles, TimeSpan) 메서드를 호출할 수 있습니다.

중요하다

반환된 문자열에 서식 규칙을 반영해야 하는 문화권을 나타내는 CultureInfo 개체입니다. CultureInfo.DateTimeFormat 속성에서 반환된 DateTimeFormatInfo 개체는 반환된 문자열의 서식을 정의합니다.
반환된 문자열의 서식을 정의하는 DateTimeFormatInfo 개체입니다.
IFormatProvider 인터페이스를 구현하는 사용자 지정 개체입니다. 해당 IFormatProvider.GetFormat 메서드는 서식 정보를 제공하는 DateTimeFormatInfo 개체를 반환합니다.

formatProvider null경우 현재 문화권과 연결된 DateTimeFormatInfo 개체가 사용됩니다.

styles 매개 변수는 사용자 지정 형식 문자열을 사용하여 구문 분석되는 문자열의 해석에 영향을 줍니다. input 음수 기호가 있는 경우에만 음수 시간 간격으로 해석되는지(TimeSpanStyles.None) 또는 항상 음수 시간 간격(TimeSpanStyles.AssumeNegative)으로 해석되는지 여부를 결정합니다. TimeSpanStyles.AssumeNegative 사용하지 않는 경우 음수 시간 간격을 성공적으로 구문 분석하려면 format 리터럴 음수 기호(예: "\-")를 포함해야 합니다.

추가 정보

표준 TimeSpan 형식 문자열
사용자 지정 TimeSpan 형식 문자열

적용 대상

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

Source:: TimeSpan.cs

Source:: TimeSpan.cs

Source:: TimeSpan.cs

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

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

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

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

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

매개 변수

input: String

변환할 시간 간격을 지정하는 문자열입니다.

formats: String[]

필요한 input형식을 정의하는 표준 또는 사용자 지정 형식 문자열의 배열입니다.

formatProvider: IFormatProvider

문화권별 서식 정보를 제공하는 개체입니다.

styles: TimeSpanStyles

입력에 있을 수 있는 스타일 요소를 정의하는 열거형 값의 비트 조합입니다.

반환

TimeSpan

formats, formatProvider및 styles지정된 input해당하는 시간 간격입니다.

예외

ArgumentException

styles 잘못된 TimeSpanStyles 값입니다.

ArgumentNullException

input null.

FormatException

input 형식이 잘못되었습니다.

OverflowException

TimeSpan.MinValue 미만이거나 TimeSpan.MaxValue보다 큰 숫자를 나타냅니다.

-또는-

input 일, 시간, 분 또는 초 구성 요소 중 하나 이상이 유효한 범위를 벗어났습니다.

예제

다음 예제에서는 ParseExact(String, String[], IFormatProvider, TimeSpanStyles) 메서드를 호출하여 문자열 배열의 각 요소를 TimeSpan 값으로 변환합니다. 문자열은 일반적인 짧은 형식 또는 일반 long 형식으로 시간 간격을 나타낼 수 있습니다.

using System;
using System.Globalization;

public class Example
{
   public static void Main()
   {
      string[] inputs = { "3", "16:42", "1:6:52:35.0625", 
                          "1:6:52:35,0625" }; 
      string[] formats = { "%h", "g", "G" };
      TimeSpan interval;
      CultureInfo culture = new CultureInfo("de-DE");
      
      // Parse each string in inputs using formats and the de-DE culture.
      foreach (string input in inputs) {
         try {
            interval = TimeSpan.ParseExact(input, formats, culture,
                                           TimeSpanStyles.AssumeNegative);
            Console.WriteLine("{0} --> {1:c}", input, interval);
         }
         catch (FormatException) {
            Console.WriteLine("{0} --> Bad Format", input);
         }      
         catch (OverflowException) {
            Console.WriteLine("{0} --> Overflow", input);   
         }            
      }
   }
}
// The example displays the following output:
//       3 --> -03:00:00
//       16:42 --> 16:42:00
//       1:6:52:35.0625 --> Bad Format
//       1:6:52:35,0625 --> 1.06:52:35.0625000

open System
open System.Globalization

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

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

Imports System.Globalization

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

설명

ParseExact(String, String[], IFormatProvider, TimeSpanStyles) 메서드는 선행 및 후행 공백 문자가 무시된다는 점을 제외하고 formats 매개 변수에서 정의한 형식 중 하나여야 하는 시간 간격의 문자열 표현을 구문 분석합니다. input formats지정된 형식 중 하나를 정확히 준수해야 하므로 사용자가 문자열 입력을 시간 간격으로 변환할 때 항상 예외 처리를 사용해야 합니다. 예외 처리를 사용하지 않으려는 경우 대신 TryParseExact(String, String[], IFormatProvider, TimeSpanStyles, TimeSpan) 메서드를 호출할 수 있습니다.

중요하다

반환된 문자열에 서식 규칙을 반영해야 하는 문화권을 나타내는 CultureInfo 개체입니다. CultureInfo.DateTimeFormat 속성에서 반환된 DateTimeFormatInfo 개체는 반환된 문자열의 서식을 정의합니다.
반환된 문자열의 서식을 정의하는 DateTimeFormatInfo 개체입니다.
IFormatProvider 인터페이스를 구현하는 사용자 지정 개체입니다. 해당 IFormatProvider.GetFormat 메서드는 서식 정보를 제공하는 DateTimeFormatInfo 개체를 반환합니다.

formatProvider null경우 현재 문화권과 연결된 DateTimeFormatInfo 개체가 사용됩니다.

추가 정보

표준 TimeSpan 형식 문자열
사용자 지정 TimeSpan 형식 문자열

적용 대상

다음을 통해 공유

TimeSpan.ParseExact 메서드

정의

오버로드

ParseExact(String, String, IFormatProvider)

매개 변수

반환

예외

예제

설명

추가 정보

적용 대상

ParseExact(String, String[], IFormatProvider)

매개 변수

반환

예외

예제

설명

추가 정보

적용 대상

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

매개 변수

반환

적용 대상

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

매개 변수

반환

적용 대상

ParseExact(String, String, IFormatProvider, TimeSpanStyles)

매개 변수

반환

예외

예제

설명

추가 정보

적용 대상

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

매개 변수

반환

예외

예제

설명

추가 정보

적용 대상

추가 리소스