TimeSpan.ParseExact Methode

Definition

Konvertiert die Zeichenfolgendarstellung eines Zeitintervalls in die entsprechende TimeSpan. Das Format der Zeichenfolgendarstellung muss einem angegebenen Format genau entsprechen.

Überlädt

ParseExact(String, String, IFormatProvider, TimeSpanStyles)

Konvertiert die Zeichenfolgendarstellung eines Zeitintervalls unter Verwendung des angegebenen Formats, der kulturspezifischen Formatierungsinformationen und Stile in die entsprechende TimeSpan. Das Format der Zeichenfolgendarstellung muss dem angegebenen Format genau entsprechen.

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

Konvertiert die Zeichenfolgendarstellung eines Zeitintervalls unter Verwendung der angegebenen Formate, der kulturspezifischen Formatierungsinformationen und Stile in die entsprechende TimeSpan. Das Format der Zeichenfolgendarstellung muss einem der angegebenen Formate genau entsprechen.

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

Konvertiert die Zeichenfolgendarstellung eines Zeitintervalls unter Verwendung der angegebenen Formate, der kulturspezifischen Formatierungsinformationen und Stile in die entsprechende TimeSpan. Das Format der Zeichenfolgendarstellung muss einem der angegebenen Formate genau entsprechen.

ParseExact(String, String[], IFormatProvider)

Konvertiert die Zeichenfolgendarstellung eines Zeitintervalls unter Verwendung des angegebenen Arrays von Formatierungszeichenfolgen und der kulturspezifischen Formatierungsinformationen in die entsprechende TimeSpan. Das Format der Zeichenfolgendarstellung muss einem der angegebenen Formate genau entsprechen.

ParseExact(String, String, IFormatProvider)

Konvertiert die Zeichenfolgendarstellung eines Zeitintervalls unter Verwendung des angegebenen Formats und der kulturspezifischen Formatierungsinformationen in die entsprechende TimeSpan. Das Format der Zeichenfolgendarstellung muss dem angegebenen Format genau entsprechen.

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

Konvertiert die Zeichenspanne eines Zeitintervalls unter Verwendung des angegebenen Formats und der kulturspezifischen Formatierungsinformationen in die entsprechende TimeSpan. Das Format der Zeichenfolgendarstellung muss dem angegebenen Format genau entsprechen.

ParseExact(String, String, IFormatProvider, TimeSpanStyles)

Konvertiert die Zeichenfolgendarstellung eines Zeitintervalls unter Verwendung des angegebenen Formats, der kulturspezifischen Formatierungsinformationen und Stile in die entsprechende TimeSpan. Das Format der Zeichenfolgendarstellung muss dem angegebenen Format genau entsprechen.

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

Parameter

input
String

Eine Zeichenfolge, die das zu konvertierende Zeitintervall angibt.

format
String

Eine standardmäßige oder benutzerdefinierte Formatierungszeichenfolge, die das erforderliche Format von input definiert.

formatProvider
IFormatProvider

Ein Objekt, das kulturspezifische Formatierungsinformationen bereitstellt.

styles
TimeSpanStyles

Eine bitweise Kombination von Enumerationswerten, die die Stilelemente definiert, die in der input vorhanden sein können.

Gibt zurück

TimeSpan

Ein Zeitintervall, das input entspricht, wie von format, formatProvider und styles angegeben.

Ausnahmen

styles ist ein ungültiger TimeSpanStyles-Wert.

input ist null.

Das Format von input ist ungültig.

input stellt eine Zahl dar, die kleiner als MinValue oder größer als MaxValue ist.

- oder - Mindestens eine der Komponenten für Tage, Stunden, Minuten oder Sekunden in input liegt außerhalb des zulässigen Bereichs.

Beispiele

Im folgenden Beispiel wird die -Methode ParseExact(String, String, IFormatProvider) verwendet, um mehrere Zeichenfolgendarstellungen von Zeitintervallen mithilfe verschiedener Formatzeichenfolgen und Kulturen zu analysieren. Außerdem wird der Wert TimeSpanStyles.AssumeNegative verwendet, um jede Zeichenfolge als negatives Zeitintervall zu interpretieren. Die Ausgabe des Beispiels veranschaulicht, dass der Stil den Rückgabewert nur beeinflusst, wenn er mit TimeSpanStyles.AssumeNegative benutzerdefinierten Formatzeichenfolgen verwendet wird.

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

Hinweise

Die -Methode analysiert die Zeichenfolgendarstellung eines Zeitintervalls, das in dem vom -Parameter definierten Format vorliegen muss, mit der Ausnahme, dass führende und nachrangige Leerzeichen ParseExact format ignoriert werden. Da genau dem Format von entsprechen muss, sollten Sie immer die Ausnahmebehandlung verwenden, wenn Sie eine Zeichenfolgeneingabe des Benutzers in input format ein Zeitintervall konvertieren. Wenn Sie die Ausnahmebehandlung nicht verwenden möchten, können Sie stattdessen die TryParseExact(String, String, IFormatProvider, TimeSpanStyles, TimeSpan) -Methode aufrufen.

Der -Parameter ist eine Zeichenfolge, die entweder einen einzelnen Standardformatbezeichner oder einen oder mehrere benutzerdefinierte Formatbezeichner enthält, die das format erforderliche Format von input definieren. Weitere Informationen zu gültigen Formatzeichenfolgen finden Sie unter TimeSpan-Standardformatzeichenfolgen und Benutzerdefinierte TimeSpan-Formatzeichenfolgen.

Wichtig

Die -Methode verwendet die Konventionen der vom -Parameter angegebenen Kultur nur, wenn eine Standardformatzeichenfolge ist, deren Wert ParseExact formatProvider entweder format TimeSpan "g" oder "G" ist. Die Standardformatzeichenfolgen "c", "t" und "T" verwenden die Formatierungskonventionen der invarianten Kultur. Benutzerdefinierte Formatzeichenfolgen definieren das genaue Format der Eingabezeichenfolge und verwenden Literalzeichen, um die Komponenten eines Zeitintervalls zu trennen.

Der -Parameter ist eine Implementierung, die kulturspezifische Informationen zum Format der zurückgegebenen Zeichenfolge liefert, formatProvider IFormatProvider wenn eine format Standardformatzeichenfolge ist. Der formatProvider -Parameter kann eine der folgenden Sein:

Wenn formatProvider null ist, wird DateTimeFormatInfo das -Objekt verwendet, das der aktuellen Kultur zugeordnet ist.

Der styles -Parameter wirkt sich auf die Interpretation von Zeichenfolgen aus, die mit benutzerdefinierten Formatzeichenfolgen analysiert werden. Sie bestimmt, ob nur dann als negatives Zeitintervall interpretiert wird, wenn ein negatives Vorzeichen vorhanden ist ( ), oder ob es immer als negatives Zeitintervall input TimeSpanStyles.None interpretiert wird ( TimeSpanStyles.AssumeNegative ). Wenn nicht verwendet wird, muss ein literales negatives Vorzeichen (z. B. " -") enthalten, um ein TimeSpanStyles.AssumeNegative format \ negatives Zeitintervall erfolgreich zu analysieren.

Siehe auch

Gilt für

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

Konvertiert die Zeichenfolgendarstellung eines Zeitintervalls unter Verwendung der angegebenen Formate, der kulturspezifischen Formatierungsinformationen und Stile in die entsprechende TimeSpan. Das Format der Zeichenfolgendarstellung muss einem der angegebenen Formate genau entsprechen.

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

Parameter

input
ReadOnlySpan<Char>

Eine Spanne, die das zu konvertierende Zeitintervall angibt.

formats
String[]

Ein Array standardmäßiger oder benutzerdefinierter Formatierungszeichenfolgen, die das erforderliche Format von input definieren.

formatProvider
IFormatProvider

Ein Objekt, das kulturspezifische Formatierungsinformationen bereitstellt.

styles
TimeSpanStyles

Eine bitweise Kombination von Enumerationswerten, die die Stilelemente definiert, die in der Eingabe vorhanden sein können.

Gibt zurück

TimeSpan

Ein Zeitintervall, das input entspricht, wie von formats, formatProvider und styles angegeben.

Gilt für

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

Konvertiert die Zeichenfolgendarstellung eines Zeitintervalls unter Verwendung der angegebenen Formate, der kulturspezifischen Formatierungsinformationen und Stile in die entsprechende TimeSpan. Das Format der Zeichenfolgendarstellung muss einem der angegebenen Formate genau entsprechen.

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

Parameter

input
String

Eine Zeichenfolge, die das zu konvertierende Zeitintervall angibt.

formats
String[]

Ein Array standardmäßiger oder benutzerdefinierter Formatierungszeichenfolgen, die das erforderliche Format von input definieren.

formatProvider
IFormatProvider

Ein Objekt, das kulturspezifische Formatierungsinformationen bereitstellt.

styles
TimeSpanStyles

Eine bitweise Kombination von Enumerationswerten, die die Stilelemente definiert, die in der Eingabe vorhanden sein können.

Gibt zurück

TimeSpan

Ein Zeitintervall, das input entspricht, wie von formats, formatProvider und styles angegeben.

Ausnahmen

styles ist ein ungültiger TimeSpanStyles-Wert.

input ist null.

Das Format von input ist ungültig.

input stellt eine Zahl dar, die kleiner als MinValue oder größer als MaxValue ist.

- oder - Mindestens eine der Komponenten für Tage, Stunden, Minuten oder Sekunden in input liegt außerhalb des zulässigen Bereichs.

Beispiele

Im folgenden Beispiel wird die -Methode ParseExact(String, String[], IFormatProvider, TimeSpanStyles) zum Konvertieren jedes Elements eines Zeichenfolgenarrays in einen -Wert TimeSpan aufruft. Die Zeichenfolgen können ein Zeitintervall entweder im allgemeinen Kurzformat oder im allgemeinen long-Format darstellen.

Darüber hinaus ändert das Beispiel die Art und Weise, in der die Analysemethoden für das Zeitintervall eine einzelne Ziffer interpretieren. Normalerweise wird eine einzelne Ziffer als Anzahl von Tagen in einem Zeitintervall interpretiert. Stattdessen wird die benutzerdefinierte Formatzeichenfolge verwendet, um eine einzelne Ziffer als %h Anzahl von Stunden zu interpretieren. Beachten Sie, dass die benutzerdefinierte Formatzeichenfolge den anderen Formatzeichenfolgen im Array voraus sein muss, damit diese Änderung %h wirksam formats ist. Beachten Sie außerdem aus der Ausgabe, dass das im Methodenaufruf angegebene Flag nur beim Analyse einer Zeichenfolge mit TimeSpanStyles.AssumeNegative diesem Formatbezeichner verwendet wird.

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

Hinweise

Die -Methode analysiert die Zeichenfolgendarstellung eines Zeitintervalls, das in einem der vom -Parameter definierten Formate vorliegen muss, mit der Ausnahme, dass führende und nachende Leerzeichen ParseExact(String, String[], IFormatProvider, TimeSpanStyles) formats ignoriert werden. Da genau einem der in angegebenen Formate entsprechen muss, sollten Sie immer die Ausnahmebehandlung verwenden, wenn Sie eine Zeichenfolgeneingabe des Benutzers in ein input formats Zeitintervall konvertieren. Wenn Sie die Ausnahmebehandlung nicht verwenden möchten, können Sie stattdessen die TryParseExact(String, String[], IFormatProvider, TimeSpanStyles, TimeSpan) -Methode aufrufen.

Der -Parameter ist ein Zeichenfolgenarray, dessen Elemente entweder aus einem einzelnen Standardformatbezeichner oder einem oder mehreren benutzerdefinierten Formatbezeichnern bestehen, die das erforderliche formats Format von input definieren. Weitere Informationen zu gültigen Formatzeichenfolgen finden Sie unter TimeSpan-Standardformatzeichenfolgen und Benutzerdefinierte TimeSpan-Formatzeichenfolgen. input muss genau einem Member von entsprechen, formats damit der Analysevorgang erfolgreich ist. Der Analysevorgang versucht, mit jedem input Element in zu formats übereinstimmen, beginnend mit dem ersten Element im Array.

Wichtig

Die -Methode verwendet die Konventionen der vom -Parameter angegebenen Kultur nur, wenn es sich bei der zu analysierenden Formatzeichenfolge um eine Standardformatzeichenfolge handelt, deren Wert ParseExact formatProvider entweder "g" oder input TimeSpan "G" ist. Die Standardformatzeichenfolgen "c", "t" und "T" verwenden die Formatierungskonventionen der invarianten Kultur. Benutzerdefinierte Formatzeichenfolgen definieren das genaue Format der Eingabezeichenfolge und verwenden Literalzeichen, um die Komponenten eines Zeitintervalls zu trennen.

Der -Parameter ist eine Implementierung, die kulturspezifische Informationen zum Format der zurückgegebenen Zeichenfolge liefert, wenn die formatierte Zeichenfolge, die zum Analysieren verwendet wird, eine formatProvider IFormatProvider input Standardformatzeichenfolge ist. Der formatProvider -Parameter kann eine der folgenden Sein:

Wenn formatProvider null ist, wird DateTimeFormatInfo das -Objekt verwendet, das der aktuellen Kultur zugeordnet ist.

Der styles -Parameter wirkt sich auf die Interpretation von Zeichenfolgen aus, die mit benutzerdefinierten Formatzeichenfolgen analysiert werden. Sie bestimmt, ob nur dann als negatives Zeitintervall interpretiert wird, wenn ein negatives Vorzeichen vorhanden ist ( ), oder ob es immer als negatives Zeitintervall input TimeSpanStyles.None interpretiert wird ( TimeSpanStyles.AssumeNegative ). Wenn nicht verwendet wird, muss ein literales negatives Vorzeichen (z. B. " -") enthalten, um ein TimeSpanStyles.AssumeNegative format \ negatives Zeitintervall erfolgreich zu analysieren.

Siehe auch

Gilt für

ParseExact(String, String[], IFormatProvider)

Konvertiert die Zeichenfolgendarstellung eines Zeitintervalls unter Verwendung des angegebenen Arrays von Formatierungszeichenfolgen und der kulturspezifischen Formatierungsinformationen in die entsprechende TimeSpan. Das Format der Zeichenfolgendarstellung muss einem der angegebenen Formate genau entsprechen.

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

Parameter

input
String

Eine Zeichenfolge, die das zu konvertierende Zeitintervall angibt.

formats
String[]

Ein Array standardmäßiger oder benutzerdefinierter Formatierungszeichenfolgen, das das erforderliche Format von input definiert.

formatProvider
IFormatProvider

Ein Objekt, das kulturspezifische Formatierungsinformationen bereitstellt.

Gibt zurück

TimeSpan

Ein Zeitintervall, das input entspricht, wie von formats und formatProvider angegeben.

Ausnahmen

input ist null.

Das Format von input ist ungültig.

input stellt eine Zahl dar, die kleiner als MinValue oder größer als MaxValue ist.

- oder - Mindestens eine der Komponenten für Tage, Stunden, Minuten oder Sekunden in input liegt außerhalb des zulässigen Bereichs.

Beispiele

Im folgenden Beispiel wird die -Methode ParseExact(String, String[], IFormatProvider) zum Konvertieren jedes Elements eines Zeichenfolgenarrays in einen -Wert TimeSpan aufruft. Im Beispiel werden die Zeichenfolgen mithilfe der Formatierungskonventionen der Kultur Französisch-Frankreich ("fr-FR") interpretiert. Die Zeichenfolgen können ein Zeitintervall entweder im allgemeinen Kurzformat oder im allgemeinen long-Format darstellen.

Darüber hinaus ändert das Beispiel die Art und Weise, in der die Analysemethoden für das Zeitintervall eine einzelne Ziffer interpretieren. Normalerweise wird eine einzelne Ziffer als Anzahl von Tagen in einem Zeitintervall interpretiert. Stattdessen wird die benutzerdefinierte Formatzeichenfolge verwendet, um eine einzelne Ziffer als %h Anzahl von Stunden zu interpretieren. Beachten Sie, dass die benutzerdefinierte Formatzeichenfolge den anderen Formatzeichenfolgen im Array voraus sein muss, damit diese Änderung %h wirksam formats ist.

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

Hinweise

Die -Methode analysiert die Zeichenfolgendarstellung eines Zeitintervalls, das in einem der vom -Parameter definierten Formate vorliegen muss, mit der Ausnahme, dass führende und nachende Leerzeichen ParseExact(String, String, IFormatProvider) formats ignoriert werden. Da genau einem der in angegebenen Formate entsprechen muss, sollten Sie immer die Ausnahmebehandlung verwenden, wenn Sie eine Zeichenfolgeneingabe des Benutzers in ein input formats Zeitintervall konvertieren. Wenn Sie die Ausnahmebehandlung nicht verwenden möchten, können Sie stattdessen die TryParseExact(String, String[], IFormatProvider, TimeSpan) -Methode aufrufen.

Der -Parameter ist ein Zeichenfolgenarray, dessen Elemente entweder aus einem einzelnen Standardformatbezeichner oder einem oder mehreren benutzerdefinierten Formatbezeichnern bestehen, die das erforderliche formats Format von input definieren. Weitere Informationen zu gültigen Formatzeichenfolgen finden Sie unter TimeSpan-Standardformatzeichenfolgen und Benutzerdefinierte TimeSpan-Formatzeichenfolgen. input muss genau einem Member von entsprechen, formats damit der Analysevorgang erfolgreich ist. Der Analysevorgang versucht, mit jedem input Element in zu formats übereinstimmen, beginnend mit dem ersten Element im Array.

Wichtig

Die -Methode verwendet die Konventionen der vom -Parameter angegebenen Kultur nur, wenn es sich bei der zu analysierenden Formatzeichenfolge um eine Standardformatzeichenfolge handelt, deren Wert ParseExact formatProvider entweder "g" oder input TimeSpan "G" ist. Die Standardformatzeichenfolgen "c", "t" und "T" verwenden die Formatierungskonventionen der invarianten Kultur. Benutzerdefinierte Formatzeichenfolgen definieren das genaue Format der Eingabezeichenfolge und verwenden Literalzeichen, um die Komponenten eines Zeitintervalls zu trennen.

Der -Parameter ist eine Implementierung, die kulturspezifische Informationen zum Format der zurückgegebenen Zeichenfolge liefert, wenn die formatierte Zeichenfolge, die zum Analysieren verwendet wird, eine formatProvider IFormatProvider input Standardformatzeichenfolge ist. Der formatProvider -Parameter kann eine der folgenden Sein:

Wenn formatProvider null ist, wird DateTimeFormatInfo das -Objekt verwendet, das der aktuellen Kultur zugeordnet ist.

Siehe auch

Gilt für

ParseExact(String, String, IFormatProvider)

Konvertiert die Zeichenfolgendarstellung eines Zeitintervalls unter Verwendung des angegebenen Formats und der kulturspezifischen Formatierungsinformationen in die entsprechende TimeSpan. Das Format der Zeichenfolgendarstellung muss dem angegebenen Format genau entsprechen.

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

Parameter

input
String

Eine Zeichenfolge, die das zu konvertierende Zeitintervall angibt.

format
String

Eine standardmäßige oder benutzerdefinierte Formatierungszeichenfolge, die das erforderliche Format von input definiert.

formatProvider
IFormatProvider

Ein Objekt, das kulturspezifische Formatierungsinformationen bereitstellt.

Gibt zurück

TimeSpan

Ein Zeitintervall, das input entspricht, wie von format und formatProvider angegeben.

Ausnahmen

input ist null.

Das Format von input ist ungültig.

input stellt eine Zahl dar, die kleiner als MinValue oder größer als MaxValue ist.

- oder - Mindestens eine der Komponenten für Tage, Stunden, Minuten oder Sekunden in input liegt außerhalb des zulässigen Bereichs.

Beispiele

Im folgenden Beispiel wird die -Methode ParseExact(String, String, IFormatProvider) verwendet, um mehrere Zeichenfolgendarstellungen von Zeitintervallen mithilfe verschiedener Formatzeichenfolgen und Kulturen zu analysieren.

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

Hinweise

Die ParseExact(String, String, IFormatProvider) -Methode analysiert die Zeichenfolgendarstellung eines Zeitintervalls, das in dem vom -Parameter definierten Format liegen format muss, mit der Ausnahme, dass führende und nachfolgende Leerzeichen ignoriert werden. Da input genau dem Format von entsprechen format muss, sollten Sie beim Konvertieren einer Zeichenfolgeneingabe durch den Benutzer in ein Zeitintervall immer die Ausnahmebehandlung verwenden. Wenn Sie die Ausnahmebehandlung nicht verwenden möchten, können Sie stattdessen die TryParseExact(String, String, IFormatProvider, TimeSpan) -Methode aufrufen.

Der format -Parameter ist eine Zeichenfolge, die entweder einen einzelnen Standardformatbezeichner oder einen oder mehrere benutzerdefinierte Formatbezeichner enthält, die das erforderliche Format von input definieren. Weitere Informationen zu gültigen Formatzeichenfolgen finden Sie unter Standard-TimeSpan-Formatzeichenfolgen und Benutzerdefinierte TimeSpan-Formatzeichenfolgen.

Wichtig

Die ParseExact -Methode verwendet die Konventionen der vom -Parameter angegebenen Kultur formatProvider nur, wenn format eine TimeSpan Standardformatzeichenfolge ist, deren Wert entweder "g" oder "G" ist. Die Standardformatzeichenfolgen "c", "t" und "T" verwenden die Formatierungskonventionen der invarianten Kultur. Benutzerdefinierte Formatzeichenfolgen definieren das genaue Format der Eingabezeichenfolge und verwenden Literalzeichen, um die Komponenten eines Zeitintervalls zu trennen.

Der formatProvider -Parameter ist eine IFormatProvider Implementierung, die kulturspezifische Informationen zum Format der zurückgegebenen Zeichenfolge bereitstellt, wenn format eine Standardformatzeichenfolge ist. Der formatProvider -Parameter kann eine der folgenden Sein:

Wenn formatProvider null ist, wird DateTimeFormatInfo das -Objekt verwendet, das der aktuellen Kultur zugeordnet ist.

Siehe auch

Gilt für

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

Konvertiert die Zeichenspanne eines Zeitintervalls unter Verwendung des angegebenen Formats und der kulturspezifischen Formatierungsinformationen in die entsprechende TimeSpan. Das Format der Zeichenfolgendarstellung muss dem angegebenen Format genau entsprechen.

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

Parameter

input
ReadOnlySpan<Char>

Eine Spanne, die das zu konvertierende Zeitintervall angibt.

format
ReadOnlySpan<Char>

Eine standardmäßige oder benutzerdefinierte Formatierungszeichenfolge, die das erforderliche Format von input definiert.

formatProvider
IFormatProvider

Ein Objekt, das kulturspezifische Formatierungsinformationen bereitstellt.

styles
TimeSpanStyles

Eine bitweise Kombination von Enumerationswerten, die die Stilelemente definiert, die in der input vorhanden sein können.

Gibt zurück

TimeSpan

Ein Zeitintervall, das input entspricht, wie von format und formatProvider angegeben.

Gilt für