TimeSpan.ParseExact Metoda

Odwołanie

Definicja

Przestrzeń nazw:: System

Zestaw:: System.Runtime.dll

Zestaw:: netstandard.dll

Zestaw:: mscorlib.dll

Ważne

Niektóre informacje odnoszą się do produktu w wersji wstępnej, który może zostać znacząco zmodyfikowany przed wydaniem. Firma Microsoft nie udziela żadnych gwarancji, jawnych lub domniemanych, w odniesieniu do informacji podanych w tym miejscu.

Konwertuje reprezentację ciągu interwału czasu na jego TimeSpan odpowiednik. Format ciągu reprezentującego musi dokładnie pasować do wskazanego formatu.

Przeciążenia

ParseExact(String, String, IFormatProvider, TimeSpanStyles)	Konwertuje reprezentację ciągu interwału czasu na jego odpowiednik przy użyciu określonego formatu, informacji o TimeSpan formacie specyficznym dla kultury i stylów. Format ciągu reprezentującego musi dokładnie pasować do wskazanego formatu.
ParseExact(ReadOnlySpan<Char>, String[], IFormatProvider, TimeSpanStyles)	Konwertuje reprezentację ciągu przedziału czasu na jego odpowiednik przy użyciu określonych formatów, informacji o TimeSpan formacie specyficznym dla kultury i stylów. Format ciągu reprezentującego musi dokładnie pasować do jednego ze wskazanych formatów.
ParseExact(String, String[], IFormatProvider, TimeSpanStyles)	Konwertuje reprezentację ciągu interwału czasu na jego odpowiednik przy użyciu określonych formatów, informacji o TimeSpan formacie specyficznym dla kultury i stylów. Format ciągu reprezentującego musi dokładnie pasować do jednego ze wskazanych formatów.
ParseExact(String, String[], IFormatProvider)	Konwertuje reprezentację ciągu interwału czasu na jego odpowiednik przy użyciu określonej tablicy ciągów formatu i informacji o TimeSpan formacie specyficznym dla kultury. Format ciągu reprezentującego musi dokładnie pasować do jednego ze wskazanych formatów.
ParseExact(String, String, IFormatProvider)	Konwertuje reprezentację ciągu interwału czasu na jego odpowiednik przy użyciu określonego formatu i informacji o TimeSpan formacie specyficznym dla kultury. Format ciągu reprezentującego musi dokładnie pasować do wskazanego formatu.
ParseExact(ReadOnlySpan<Char>, ReadOnlySpan<Char>, IFormatProvider, TimeSpanStyles)	Konwertuje zakres znaków przedziału czasu na jego odpowiednik przy użyciu określonego formatu i informacji o TimeSpan formacie specyficznym dla kultury. Format ciągu reprezentującego musi dokładnie pasować do wskazanego formatu.

ParseExact(String, String, IFormatProvider, TimeSpanStyles)

Konwertuje reprezentację ciągu interwału czasu na jego odpowiednik przy użyciu określonego formatu, informacji o TimeSpan formacie specyficznym dla kultury i stylów. Format ciągu reprezentującego musi dokładnie pasować do wskazanego formatu.

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

Parametry

input: String

Ciąg określający przedział czasu, którą należy przekształcić.

format: String

Ciąg formatu standardowego lub niestandardowego, który definiuje wymagany format input .

formatProvider: IFormatProvider

Obiekt, który dostarcza informacje o formatowaniu specyficzne dla kultury.

styles: TimeSpanStyles

Bitowa kombinacja wartości wyliczenia definiująca elementy stylu, które mogą być obecne input w .

Zwraca

TimeSpan

Przedział czasu, który odpowiada input wartości , zgodnie z wartościami , i format formatProvider styles .

Wyjątki

ArgumentException

styles jest nieprawidłową TimeSpanStyles wartością.

ArgumentNullException

input to null.

FormatException

input ma nieprawidłowy format.

OverflowException

input reprezentuje liczbę mniejszą lub MinValue większą niż MaxValue .

-lub- Co najmniej jeden z dni, godzin, minut lub sekund składników w programie input znajduje się poza prawidłowym zakresem.

Przykłady

W poniższym przykładzie użyto metody do analizowania kilku ciągów reprezentacji przedziałów czasu ParseExact(String, String, IFormatProvider) przy użyciu różnych ciągów formatu i kultur. Używa również wartości TimeSpanStyles.AssumeNegative do interpretowania każdego ciągu jako ujemnego interwału czasu. Dane wyjściowe z przykładu ilustrują, że styl ma wpływ na wartość zwracaną tylko wtedy, gdy jest używana TimeSpanStyles.AssumeNegative z niestandardowymi ciągami formatu.

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

Uwagi

Metoda analizuje reprezentację ciągu przedziału czasu, który musi być w formacie zdefiniowanym przez parametr, z tą różnicą, że wiodące i końcowe znaki odstępu ParseExact format są ignorowane. Ponieważ musi być dokładnie zgodny z formatem , należy zawsze używać obsługi wyjątków podczas konwertowania ciągu wejściowego przez użytkownika input format na przedział czasu. Jeśli nie chcesz używać obsługi wyjątków, możesz zamiast tego wywołać TryParseExact(String, String, IFormatProvider, TimeSpanStyles, TimeSpan) metodę .

Parametr jest ciągiem zawierającym jeden specyfikator formatu standardowego lub co najmniej jeden specyfikator formatu niestandardowego, który definiuje format wymagany format input . Aby uzyskać więcej informacji na temat prawidłowych ciągów formatu, zobacz Ciągi formatowe TimeSpan w standardowych i Niestandardowe ciągi formatowe TimeSpan.

Ważne

Metoda używa konwencji kultury określonej przez parametr tylko wtedy, gdy jest ciągiem formatu standardowego, którego wartość to ParseExact formatProvider format TimeSpan "g" lub "G". Standardowe ciągi formatujące „c”, „t” i „T” wykorzystują konwencje formatowania niezmiennej kultury. Niestandardowe ciągi formatujące definiują dokładny format ciągu wejściowego oraz za pomocą znaków literałowych oddzielają składniki przedziału czasu.

Parametr jest implementacją, która dostarcza informacje specyficzne dla kultury dotyczące formatu zwracanych formatProvider IFormatProvider ciągów, jeśli jest format ciągiem formatu standardowego. Parametr formatProvider może być dowolnym z następujących:

Obiekt CultureInfo reprezentujący kulturę, której konwencje formatowania mają być odzwierciedlone w zwracanych ciągach. Obiekt DateTimeFormatInfo zwrócony przez CultureInfo.DateTimeFormat właściwość definiuje formatowanie zwracanego ciągu.
Obiekt DateTimeFormatInfo definiujący formatowanie zwracanego ciągu.
Niestandardowy obiekt, który implementuje IFormatProvider interfejs. Jej IFormatProvider.GetFormat metoda zwraca DateTimeFormatInfo obiekt, który dostarcza informacje o formatowaniu.

Jeśli formatProvider to , używany jest obiekt skojarzony z null DateTimeFormatInfo bieżącą kulturą.

Parametr styles ma wpływ na interpretację ciągów, które są analizowane przy użyciu ciągów formatu niestandardowego. Określa, czy jest interpretowany jako ujemny interwał czasu tylko wtedy, gdy jest obecny znak ujemny ( ), czy też jest on zawsze interpretowany jako ujemny input TimeSpanStyles.None interwał czasu ( TimeSpanStyles.AssumeNegative ). Jeśli nie jest używany, musi zawierać symbol znaku ujemnego literału (na przykład " -"), aby pomyślnie TimeSpanStyles.AssumeNegative format \ ująć ujemny interwał czasu.

Zobacz też

Dotyczy

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

Konwertuje reprezentację ciągu przedziału czasu na jego odpowiednik przy użyciu określonych formatów, informacji o TimeSpan formacie specyficznym dla kultury i stylów. Format ciągu reprezentującego musi dokładnie pasować do jednego ze wskazanych formatów.

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

Parametry

input: ReadOnlySpan<Char>

Zakres określający przedział czasu, który ma zostać przekonwertowany.

formats: String[]

Tablica standardowych lub niestandardowych ciągów formatu, które definiują wymagany format input .

formatProvider: IFormatProvider

Obiekt, który dostarcza informacje o formatowaniu specyficzne dla kultury.

styles: TimeSpanStyles

Bitowa kombinacja wartości wyliczenia definiująca elementy stylu, które mogą być obecne w danych wejściowych.

Zwraca

TimeSpan

Przedział czasu, który odpowiada input wartości , zgodnie z wartościami , i formats formatProvider styles .

Dotyczy

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

Konwertuje reprezentację ciągu interwału czasu na jego odpowiednik przy użyciu określonych formatów, informacji o TimeSpan formacie specyficznym dla kultury i stylów. Format ciągu reprezentującego musi dokładnie pasować do jednego ze wskazanych formatów.

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

Parametry

input: String

Ciąg określający przedział czasu, którą należy przekształcić.

formats: String[]

Tablica standardowych lub niestandardowych ciągów formatu, które definiują wymagany format input .

formatProvider: IFormatProvider

Obiekt, który dostarcza informacje o formatowaniu specyficzne dla kultury.

styles: TimeSpanStyles

Bitowa kombinacja wartości wyliczenia definiująca elementy stylu, które mogą być obecne w danych wejściowych.

Zwraca

TimeSpan

Przedział czasu, który odpowiada input wartości , zgodnie z wartościami , i formats formatProvider styles .

Wyjątki

ArgumentException

styles jest nieprawidłową TimeSpanStyles wartością.

ArgumentNullException

input to null.

FormatException

input ma nieprawidłowy format.

OverflowException

input reprezentuje liczbę mniejszą MinValue lub większą niż MaxValue .

-lub- Co najmniej jeden z dni, godzin, minut lub sekund składników w programie input znajduje się poza prawidłowym zakresem.

Przykłady

Poniższy przykład wywołuje metodę ParseExact(String, String[], IFormatProvider, TimeSpanStyles) , aby przekonwertować każdy element tablicy ciągów na TimeSpan wartość. Ciągi mogą reprezentować przedział czasu w ogólnym formacie krótkim lub długim.

Ponadto w przykładzie zmienił się sposób, w jaki metody analizy przedziałów czasu interpretują pojedyncze cyfry. Zazwyczaj w odstępie czasu pojedyncza cyfra jest interpretowana jako liczba dni. Zamiast tego %h ciąg formatu niestandardowego jest używany do interpretowania pojedynczej cyfry jako liczby godzin. Aby ta zmiana była skuteczna, należy pamiętać, że ciąg formatu niestandardowego musi %h poprzedzać inne ciągi formatu w formats tablicy. Należy również zauważyć z danych wyjściowych, że flaga określona w wywołaniu metody jest używana tylko podczas analizowania ciągu TimeSpanStyles.AssumeNegative przy użyciu tego specyfikatora formatu.

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

Uwagi

Metoda analizuje reprezentację ciągu interwału czasu, który musi być w jednym z formatów zdefiniowanych przez parametr, z tą różnicą, że wiodące i końcowe znaki odstępu są ParseExact(String, String[], IFormatProvider, TimeSpanStyles) formats ignorowane. Ponieważ musi być dokładnie zgodny z jednym z formatów określonych w , należy zawsze używać obsługi wyjątków podczas konwertowania ciągu wejściowego przez użytkownika input formats na przedział czasu. Jeśli nie chcesz używać obsługi wyjątków, możesz zamiast tego wywołać TryParseExact(String, String[], IFormatProvider, TimeSpanStyles, TimeSpan) metodę .

Parametr formats jest tablicą ciągów, której elementy składają się z jednego specyfikatora formatu standardowego lub co najmniej jednego specyfikatora formatu niestandardowego, który definiuje wymagany format input . Aby uzyskać więcej informacji na temat prawidłowych ciągów formatu, zobacz Ciągi formatu Standard TimeSpan i Niestandardowe ciągi formatowe TimeSpan. input Aby operacja analizy zakończyła się pomyślnie, musi odpowiadać dokładnie członowi formats . Operacja analizy próbuje dopasować do każdego elementu w elemencie input formats rozpoczynającym się od pierwszego elementu w tablicy.

Ważne

Metoda używa konwencji kultury określonej przez parametr tylko wtedy, gdy ciąg formatu używany do analizowania jest ciągiem formatu standardowego, którego wartość to ParseExact formatProvider "g" lub input TimeSpan "G". Standardowe ciągi formatujące „c”, „t” i „T” wykorzystują konwencje formatowania niezmiennej kultury. Niestandardowe ciągi formatujące definiują dokładny format ciągu wejściowego oraz za pomocą znaków literałowych oddzielają składniki przedziału czasu.

Parametr jest implementacją, która dostarcza informacje specyficzne dla kultury dotyczące formatu zwracanych ciągów, jeśli ciąg formatu używany do analizy jest ciągiem formatProvider IFormatProvider formatu input standardowego. Parametr formatProvider może być dowolnym z następujących:

Obiekt CultureInfo reprezentujący kulturę, której konwencje formatowania mają być odzwierciedlone w zwracanych ciągach. Obiekt DateTimeFormatInfo zwrócony przez CultureInfo.DateTimeFormat właściwość definiuje formatowanie zwracanego ciągu.
Obiekt DateTimeFormatInfo definiujący formatowanie zwracanego ciągu.
Obiekt niestandardowy, który implementuje IFormatProvider interfejs. Metoda IFormatProvider.GetFormat zwraca obiekt , który dostarcza informacje o DateTimeFormatInfo formatowaniu.

Jeśli formatProvider to , używany jest obiekt skojarzony z null DateTimeFormatInfo bieżącą kulturą.

Parametr styles ma wpływ na interpretację ciągów, które są analizowane przy użyciu ciągów formatu niestandardowego. Określa, czy jest interpretowany jako ujemny interwał czasu tylko wtedy, gdy jest obecny znak ujemny ( ), czy też zawsze jest interpretowany jako ujemny input TimeSpanStyles.None interwał czasu ( TimeSpanStyles.AssumeNegative ). Jeśli nie jest używany, musi zawierać symbol znaku ujemnego literału (na przykład " -"), aby pomyślnie TimeSpanStyles.AssumeNegative format \ ująć w analizę ujemny przedział czasu.

Zobacz też

Dotyczy

ParseExact(String, String[], IFormatProvider)

Konwertuje reprezentację ciągu interwału czasu na jego odpowiednik przy użyciu określonej tablicy ciągów formatu i informacji o TimeSpan formacie specyficznym dla kultury. Format ciągu reprezentującego musi dokładnie pasować do jednego ze wskazanych formatów.

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

Parametry

input: String

Ciąg określający przedział czasu, którą należy przekształcić.

formats: String[]

Tablica ciągów formatu standardowego lub niestandardowego, która definiuje wymagany format input .

formatProvider: IFormatProvider

Obiekt, który dostarcza informacje o formatowaniu specyficzne dla kultury.

Zwraca

TimeSpan

Przedział czasu, który odpowiada input wartości , zgodnie z wartościami i formats formatProvider .

Wyjątki

ArgumentNullException

input to null.

FormatException

input ma nieprawidłowy format.

OverflowException

input reprezentuje liczbę mniejszą lub MinValue większą niż MaxValue .

-lub- Co najmniej jeden z dni, godzin, minut lub sekund składników w programie input znajduje się poza prawidłowym zakresem.

Przykłady

Poniższy przykład wywołuje metodę ParseExact(String, String[], IFormatProvider) , aby przekonwertować każdy element tablicy ciągów na TimeSpan wartość. W przykładzie ciągi są interpretowane przy użyciu konwencji formatowania kultury francuski – Francja ("fr-FR"). Ciągi mogą reprezentować przedział czasu w ogólnym formacie krótkim lub długim.

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

Uwagi

Metoda analizuje reprezentację ciągu przedziału czasu, który musi być w jednym z formatów zdefiniowanych przez parametr, z tą różnicą, że wiodące i końcowe znaki odstępu są ParseExact(String, String, IFormatProvider) formats ignorowane. Ponieważ musi być dokładnie zgodny z jednym z formatów określonych w , należy zawsze używać obsługi wyjątków podczas konwertowania ciągu danych wejściowych przez użytkownika input formats na przedział czasu. Jeśli nie chcesz używać obsługi wyjątków, możesz zamiast tego wywołać TryParseExact(String, String[], IFormatProvider, TimeSpan) metodę .

Parametr jest tablicą ciągów, której elementy składają się z jednego specyfikatora formatu standardowego lub co najmniej jednego specyfikatora formatu niestandardowego formats definiującego wymagany format input . Aby uzyskać więcej informacji na temat prawidłowych ciągów formatu, zobacz Ciągi formatowe TimeSpan w standardowych i Niestandardowe ciągi formatowe TimeSpan. input Aby operacja analizy zakończyła się pomyślnie, musi odpowiadać dokładnie członowi formats . Operacja analizy próbuje dopasować się do input każdego elementu, formats zaczynając od pierwszego elementu w tablicy.

Ważne

Parametr jest implementacją, która dostarcza informacje specyficzne dla kultury dotyczące formatu zwracanych ciągów, jeśli ciąg formatu używany do analizowania jest formatProvider IFormatProvider input ciągiem standardowego formatu. Parametr formatProvider może być dowolnym z następujących:

Obiekt CultureInfo reprezentujący kulturę, której konwencje formatowania mają być odzwierciedlone w zwracanych ciągach. Obiekt DateTimeFormatInfo zwrócony przez CultureInfo.DateTimeFormat właściwość definiuje formatowanie zwracanego ciągu.
Obiekt DateTimeFormatInfo definiujący formatowanie zwracanego ciągu.
Niestandardowy obiekt, który implementuje IFormatProvider interfejs. Jej IFormatProvider.GetFormat metoda zwraca DateTimeFormatInfo obiekt, który dostarcza informacje o formatowaniu.

Jeśli formatProvider to , używany jest obiekt skojarzony z null DateTimeFormatInfo bieżącą kulturą.

Zobacz też

Dotyczy

ParseExact(String, String, IFormatProvider)

Konwertuje reprezentację ciągu interwału czasu na jego odpowiednik przy użyciu określonego formatu i informacji o TimeSpan formacie specyficznym dla kultury. Format ciągu reprezentującego musi dokładnie pasować do wskazanego formatu.

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

Parametry

input: String

Ciąg określający przedział czasu, którą należy przekształcić.

format: String

Ciąg formatu standardowego lub niestandardowego, który definiuje wymagany format input .

formatProvider: IFormatProvider

Obiekt, który dostarcza informacje o formatowaniu specyficzne dla kultury.

Zwraca

TimeSpan

Przedział czasu, który odpowiada input wartości , zgodnie z wartościami i format formatProvider .

Wyjątki

ArgumentNullException

input to null.

FormatException

input ma nieprawidłowy format.

OverflowException

input reprezentuje liczbę mniejszą lub MinValue większą niż MaxValue .

-lub- Co najmniej jeden z dni, godzin, minut lub sekund składników w programie input znajduje się poza prawidłowym zakresem.

Przykłady

W poniższym przykładzie użyto metody do analizowania kilku ciągów reprezentacji przedziałów czasu ParseExact(String, String, IFormatProvider) przy użyciu różnych ciągów formatu i kultur.

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

Uwagi

Metoda analizuje reprezentację ciągu interwału czasu, który musi być w formacie zdefiniowanym przez parametr, z tą różnicą, że wiodące i końcowe znaki odstępu ParseExact(String, String, IFormatProvider) format są ignorowane. Ponieważ input musi być zgodna z formatem dokładnie, należy zawsze używać obsługi wyjątków podczas konwertowania danych wejściowych ciągu przez użytkownika format na przedział czasu. Jeśli nie chcesz używać obsługi wyjątków, możesz zamiast tego wywołać TryParseExact(String, String, IFormatProvider, TimeSpan) metodę .

Parametr jest ciągiem zawierającym pojedynczy specyfikator formatu standardowego lub co najmniej jeden specyfikator formatu niestandardowego, który definiuje format wymagany format input . Aby uzyskać więcej informacji na temat prawidłowych ciągów formatu, zobacz Ciągi formatu Standard TimeSpan i Niestandardowe ciągi formatowe TimeSpan.

Ważne

Metoda używa konwencji kultury określonej przez parametr tylko wtedy, gdy jest ciągiem formatu standardowego, którego wartość ParseExact formatProvider to format TimeSpan "g" lub "G". Standardowe ciągi formatujące „c”, „t” i „T” wykorzystują konwencje formatowania niezmiennej kultury. Niestandardowe ciągi formatujące definiują dokładny format ciągu wejściowego oraz za pomocą znaków literałowych oddzielają składniki przedziału czasu.

Parametr jest implementacją, która dostarcza informacje specyficzne dla kultury dotyczące formatu zwracanych ciągów, jeśli formatProvider IFormatProvider jest format ciągiem formatu standardowego. Parametr formatProvider może być dowolnym z następujących:

Obiekt CultureInfo reprezentujący kulturę, której konwencje formatowania mają być odzwierciedlone w zwracanych ciągach. Obiekt DateTimeFormatInfo zwrócony przez CultureInfo.DateTimeFormat właściwość definiuje formatowanie zwracanego ciągu.
Obiekt DateTimeFormatInfo definiujący formatowanie zwracanego ciągu.
Niestandardowy obiekt, który implementuje IFormatProvider interfejs. Jej IFormatProvider.GetFormat metoda zwraca DateTimeFormatInfo obiekt, który dostarcza informacje o formatowaniu.

Jeśli formatProvider to , używany jest obiekt skojarzony z null DateTimeFormatInfo bieżącą kulturą.

Zobacz też

Dotyczy

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

Konwertuje zakres znaków przedziału czasu na jego odpowiednik przy użyciu określonego formatu i informacji o TimeSpan formacie specyficznym dla kultury. Format ciągu reprezentującego musi dokładnie pasować do wskazanego formatu.

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

Parametry

input: ReadOnlySpan<Char>

Zakres określający przedział czasu, który ma zostać przekonwertowany.

format: ReadOnlySpan<Char>

Ciąg formatu standardowego lub niestandardowego, który definiuje wymagany format input .

formatProvider: IFormatProvider

Obiekt, który dostarcza informacje o formatowaniu specyficzne dla kultury.

styles: TimeSpanStyles

Bitowa kombinacja wartości wyliczenia definiująca elementy stylu, które mogą być obecne input w .

Zwraca

TimeSpan

Przedział czasu, który odpowiada input wartości , zgodnie z wartościami i format formatProvider .

Dotyczy