TimeSpan.ParseExact Methode

Referenz

Definition

Namespace:: System

Assembly:: System.Runtime.dll

Assembly:: mscorlib.dll

Assembly:: netstandard.dll

Wichtig

Einige Informationen beziehen sich auf Vorabversionen, die vor dem Release ggf. grundlegend überarbeitet werden. Microsoft übernimmt hinsichtlich der hier bereitgestellten Informationen keine Gewährleistungen, seien sie ausdrücklich oder konkludent.

Konvertiert die Zeichenfolgendarstellung eines Zeitintervalls in dessen TimeSpan Entsprechung. Das Format der Zeichenfolgendarstellung muss genau mit einem angegebenen Format übereinstimmen.

Überlädt

ParseExact(String, String, IFormatProvider)	Konvertiert die Zeichenfolgendarstellung eines Zeitintervalls in seine TimeSpan Entsprechung mithilfe der angegebenen Format- und kulturspezifischen Formatinformationen. Das Format der Zeichenfolgendarstellung muss exakt mit dem angegebenen Format übereinstimmen.
ParseExact(String, String[], IFormatProvider)	Konvertiert die Zeichenfolgendarstellung eines Zeitintervalls in seine TimeSpan Entsprechung mithilfe des angegebenen Arrays von Formatzeichenfolgen und kulturspezifischen Formatinformationen. Das Format der Zeichenfolgendarstellung muss genau mit einem der angegebenen Formate übereinstimmen.
ParseExact(ReadOnlySpan<Char>, ReadOnlySpan<Char>, IFormatProvider, TimeSpanStyles)	Konvertiert die Zeichenspanne eines Zeitintervalls in die TimeSpan Entsprechung mithilfe der angegebenen Format- und kulturspezifischen Formatinformationen. Das Format der Zeichenfolgendarstellung muss exakt mit dem angegebenen Format übereinstimmen.
ParseExact(ReadOnlySpan<Char>, String[], IFormatProvider, TimeSpanStyles)	Konvertiert die Zeichenfolgendarstellung eines Zeitintervalls in seine TimeSpan Entsprechung mithilfe der angegebenen Formate, kulturspezifischen Formatinformationen und Formatvorlagen. Das Format der Zeichenfolgendarstellung muss genau mit einem der angegebenen Formate übereinstimmen.
ParseExact(String, String, IFormatProvider, TimeSpanStyles)	Konvertiert die Zeichenfolgendarstellung eines Zeitintervalls in seine TimeSpan Entsprechung mithilfe der angegebenen Format-, kulturspezifischen Formatinformationen und Formatvorlagen. Das Format der Zeichenfolgendarstellung muss exakt mit dem angegebenen Format übereinstimmen.
ParseExact(String, String[], IFormatProvider, TimeSpanStyles)	Konvertiert die Zeichenfolgendarstellung eines Zeitintervalls in seine TimeSpan Entsprechung mithilfe der angegebenen Formate, kulturspezifischen Formatinformationen und Formatvorlagen. Das Format der Zeichenfolgendarstellung muss genau mit einem der angegebenen Formate übereinstimmen.

ParseExact(String, String, IFormatProvider)

Quelle:: TimeSpan.cs

Quelle:: TimeSpan.cs

Quelle:: TimeSpan.cs

Konvertiert die Zeichenfolgendarstellung eines Zeitintervalls in seine TimeSpan Entsprechung mithilfe der angegebenen Format- und kulturspezifischen Formatinformationen. Das Format der Zeichenfolgendarstellung muss exakt mit dem angegebenen Format übereinstimmen.

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 Standard- oder benutzerdefinierte Formatzeichenfolge, die das erforderliche Format von inputdefiniert.

formatProvider: IFormatProvider

Ein Objekt, das kulturspezifische Formatierungsinformationen bereitstellt.

Gibt zurück

TimeSpan

Ein Zeitintervall, das inputentspricht, wie durch format und formatProviderangegeben.

Ausnahmen

ArgumentNullException

input ist null.

FormatException

input weist ein ungültiges Format auf.

OverflowException

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

-oder-

Mindestens eine der Komponenten für Tage, Stunden, Minuten oder Sekunden in input liegt außerhalb des gültigen Bereichs.

Beispiele

using System;
using System.Globalization;

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

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

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

open System
open System.Globalization

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

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

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

Imports System.Globalization

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

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

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

Hinweise

Die ParseExact(String, String, IFormatProvider)-Methode analysiert die Zeichenfolgendarstellung eines Zeitintervalls, das sich im vom parameter format definierten Format befinden muss, außer dass führende und nachfolgende Leerzeichen ignoriert werden. Da input exakt dem Format von format entsprechen muss, sollten Sie beim Konvertieren einer Zeichenfolgeneingabe durch den Benutzer immer eine Ausnahmebehandlung in ein Zeitintervall 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 inputdefinieren. Weitere Informationen zu gültigen Formatzeichenfolgen finden Sie unter Standard TimeSpan Format Strings und Custom TimeSpan Format Strings.

Wichtig

Die ParseExact-Methode verwendet die Konventionen der kultur, die vom formatProvider Parameter angegeben wird, nur, wenn format eine Standardformatzeichenfolge TimeSpan Formatzeichenfolge ist, deren Wert entweder "g" oder "G" lautet. 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:

Ein CultureInfo-Objekt, das die Kultur darstellt, deren Formatierungskonventionen in der zurückgegebenen Zeichenfolge widergespiegelt werden sollen. Das von der CultureInfo.DateTimeFormat -Eigenschaft zurückgegebene DateTimeFormatInfo -Objekt definiert die Formatierung der zurückgegebenen Zeichenfolge.
Ein DateTimeFormatInfo-Objekt, das die Formatierung der zurückgegebenen Zeichenfolge definiert.
Ein benutzerdefiniertes Objekt, das die IFormatProvider Schnittstelle implementiert. Die IFormatProvider.GetFormat-Methode gibt ein DateTimeFormatInfo Objekt zurück, das Formatierungsinformationen bereitstellt.

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

Weitere Informationen

Gilt für:

ParseExact(String, String[], IFormatProvider)

Quelle:: TimeSpan.cs

Quelle:: TimeSpan.cs

Quelle:: TimeSpan.cs

Konvertiert die Zeichenfolgendarstellung eines Zeitintervalls in seine TimeSpan Entsprechung mithilfe des angegebenen Arrays von Formatzeichenfolgen und kulturspezifischen Formatinformationen. Das Format der Zeichenfolgendarstellung muss genau mit einem der angegebenen Formate übereinstimmen.

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 von Standard- oder benutzerdefinierten Formatzeichenfolgen, die das erforderliche Format von inputdefiniert.

formatProvider: IFormatProvider

Ein Objekt, das kulturspezifische Formatierungsinformationen bereitstellt.

Gibt zurück

TimeSpan

Ein Zeitintervall, das inputentspricht, wie durch formats und formatProviderangegeben.

Ausnahmen

ArgumentNullException

input ist null.

FormatException

input weist ein ungültiges Format auf.

OverflowException

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

-oder-

Mindestens eine der Komponenten für Tage, Stunden, Minuten oder Sekunden in input liegt außerhalb des gültigen Bereichs.

Beispiele

Im folgenden Beispiel wird die ParseExact(String, String[], IFormatProvider)-Methode aufgerufen, um jedes Element eines Zeichenfolgenarrays in einen TimeSpan Wert zu konvertieren. Im Beispiel werden die Zeichenfolgen mit den Formatierungskonventionen der Kultur Französisch - Frankreich ("fr-FR") interpretiert. Die Zeichenfolgen können ein Zeitintervall entweder im allgemeinen kurzen Format oder im allgemeinen langen Format darstellen.

Darüber hinaus ändert das Beispiel die Art und Weise, in der die Zeitintervallanalysemethoden eine einzelne Ziffer interpretieren. Normalerweise wird eine einzelne Ziffer als Die Anzahl der Tage in einem Zeitintervall interpretiert. Stattdessen wird die %h benutzerdefinierte Formatzeichenfolge verwendet, um eine einzelne Ziffer als Anzahl von Stunden zu interpretieren. Beachten Sie, dass die %h benutzerdefinierte Formatzeichenfolge den anderen Formatzeichenfolgen im formats Array vorangestellt sein muss, damit diese Änderung wirksam 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

open System
open System.Globalization

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

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

Imports System.Globalization

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

Hinweise

Die ParseExact(String, String, IFormatProvider)-Methode analysiert die Zeichenfolgendarstellung eines Zeitintervalls, das sich in einem der formate befinden muss, die vom parameter formats definiert werden, mit der Ausnahme, dass führende und nachfolgende Leerzeichen ignoriert werden. Da input genau einem der formate entsprechen muss, die in formatsangegeben sind, sollten Sie beim Konvertieren einer Zeichenfolgeneingabe durch den Benutzer immer eine Ausnahmebehandlung in ein Zeitintervall verwenden. Wenn Sie die Ausnahmebehandlung nicht verwenden möchten, können Sie stattdessen die TryParseExact(String, String[], IFormatProvider, TimeSpan)-Methode aufrufen.

Der formats Parameter ist ein Zeichenfolgenarray, dessen Elemente entweder aus einem einzigen Standardformatbezeichner oder einem oder mehreren benutzerdefinierten Formatbezeichnern bestehen, die das erforderliche Format von inputdefinieren. Weitere Informationen zu gültigen Formatzeichenfolgen finden Sie unter Standard TimeSpan Format Strings und Custom TimeSpan Format Strings. input muss genau einem Element von formats entsprechen, damit der Analysevorgang erfolgreich ausgeführt werden kann. Der Analysevorgang versucht, input jedem Element in formats ab dem ersten Element im Array zuzuordnen.

Wichtig

Die ParseExact-Methode verwendet die Konventionen der Kultur, die vom parameter formatProvider angegeben wird, nur, wenn die zum Analysieren input verwendete Formatzeichenfolge eine Standardformatzeichenfolge TimeSpan Formatzeichenfolge 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 die zum Analysieren input verwendete Formatzeichenfolge eine Standardformatzeichenfolge ist. Der formatProvider-Parameter kann eine der folgenden Sein:

Ein CultureInfo-Objekt, das die Kultur darstellt, deren Formatierungskonventionen in der zurückgegebenen Zeichenfolge widergespiegelt werden sollen. Das von der CultureInfo.DateTimeFormat -Eigenschaft zurückgegebene DateTimeFormatInfo -Objekt definiert die Formatierung der zurückgegebenen Zeichenfolge.
Ein DateTimeFormatInfo-Objekt, das die Formatierung der zurückgegebenen Zeichenfolge definiert.
Ein benutzerdefiniertes Objekt, das die IFormatProvider Schnittstelle implementiert. Die IFormatProvider.GetFormat-Methode gibt ein DateTimeFormatInfo Objekt zurück, das Formatierungsinformationen bereitstellt.

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

Weitere Informationen

Gilt für:

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

Quelle:: TimeSpan.cs

Quelle:: TimeSpan.cs

Quelle:: TimeSpan.cs

Konvertiert die Zeichenspanne eines Zeitintervalls in die TimeSpan Entsprechung mithilfe der angegebenen Format- und kulturspezifischen Formatinformationen. Das Format der Zeichenfolgendarstellung muss exakt mit dem angegebenen Format übereinstimmen.

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>

Ein Bereich, der das zu konvertierende Zeitintervall angibt.

format: ReadOnlySpan<Char>

Eine Standard- oder benutzerdefinierte Formatzeichenfolge, die das erforderliche Format von inputdefiniert.

formatProvider: IFormatProvider

Ein Objekt, das kulturspezifische Formatierungsinformationen bereitstellt.

styles: TimeSpanStyles

Eine bitweise Kombination von Enumerationswerten, die die Formatvorlagenelemente definieren, die in inputvorhanden sein können.

Gibt zurück

TimeSpan

Ein Zeitintervall, das inputentspricht, wie durch format und formatProviderangegeben.

Gilt für:

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

Quelle:: TimeSpan.cs

Quelle:: TimeSpan.cs

Quelle:: TimeSpan.cs

Konvertiert die Zeichenfolgendarstellung eines Zeitintervalls in seine TimeSpan Entsprechung mithilfe der angegebenen Formate, kulturspezifischen Formatinformationen und Formatvorlagen. Das Format der Zeichenfolgendarstellung muss genau mit einem der angegebenen Formate übereinstimmen.

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>

Ein Bereich, der das zu konvertierende Zeitintervall angibt.

formats: String[]

Ein Array von Standard- oder benutzerdefinierten Formatzeichenfolgen, die das erforderliche Format von inputdefinieren.

formatProvider: IFormatProvider

Ein Objekt, das kulturspezifische Formatierungsinformationen bereitstellt.

styles: TimeSpanStyles

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

Gibt zurück

TimeSpan

Ein Zeitintervall, das inputentspricht, wie durch formats, formatProviderund stylesangegeben.

Gilt für:

ParseExact(String, String, IFormatProvider, TimeSpanStyles)

Quelle:: TimeSpan.cs

Quelle:: TimeSpan.cs

Quelle:: TimeSpan.cs

Konvertiert die Zeichenfolgendarstellung eines Zeitintervalls in seine TimeSpan Entsprechung mithilfe der angegebenen Format-, kulturspezifischen Formatinformationen und Formatvorlagen. Das Format der Zeichenfolgendarstellung muss exakt mit dem angegebenen Format übereinstimmen.

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 Standard- oder benutzerdefinierte Formatzeichenfolge, die das erforderliche Format von inputdefiniert.

formatProvider: IFormatProvider

Ein Objekt, das kulturspezifische Formatierungsinformationen bereitstellt.

styles: TimeSpanStyles

Eine bitweise Kombination von Enumerationswerten, die die Formatvorlagenelemente definieren, die in inputvorhanden sein können.

Gibt zurück

TimeSpan

Ein Zeitintervall, das inputentspricht, wie durch format, formatProviderund stylesangegeben.

Ausnahmen

ArgumentException

styles ist ein ungültiger TimeSpanStyles Wert.

ArgumentNullException

input ist null.

FormatException

input weist ein ungültiges Format auf.

OverflowException

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

-oder-

Mindestens eine der Komponenten für Tage, Stunden, Minuten oder Sekunden in input liegt außerhalb des gültigen Bereichs.

Beispiele

Im folgenden Beispiel wird die ParseExact(String, String, IFormatProvider)-Methode verwendet, um mehrere Zeichenfolgendarstellungen von Zeitintervallen mithilfe verschiedener Formatzeichenfolgen und Kulturen zu analysieren. Außerdem wird der TimeSpanStyles.AssumeNegative Wert verwendet, um jede Zeichenfolge als negatives Zeitintervall zu interpretieren. Die Ausgabe aus dem Beispiel veranschaulicht, dass sich die TimeSpanStyles.AssumeNegative Formatvorlage nur auf den Rückgabewert auswirkt, wenn sie mit 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

open System
open System.Globalization

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

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

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

Imports System.Globalization

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

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

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

Hinweise

Die ParseExact-Methode analysiert die Zeichenfolgendarstellung eines Zeitintervalls, das sich im vom parameter format definierten Format befinden muss, außer dass führende und nachfolgende Leerzeichen ignoriert werden. Da input exakt dem Format von format entsprechen muss, sollten Sie beim Konvertieren einer Zeichenfolgeneingabe durch den Benutzer immer eine Ausnahmebehandlung in ein Zeitintervall verwenden. Wenn Sie die Ausnahmebehandlung nicht verwenden möchten, können Sie stattdessen die TryParseExact(String, String, IFormatProvider, TimeSpanStyles, TimeSpan)-Methode aufrufen.

Wichtig

Ein CultureInfo-Objekt, das die Kultur darstellt, deren Formatierungskonventionen in der zurückgegebenen Zeichenfolge widergespiegelt werden sollen. Das von der CultureInfo.DateTimeFormat -Eigenschaft zurückgegebene DateTimeFormatInfo -Objekt definiert die Formatierung der zurückgegebenen Zeichenfolge.
Ein DateTimeFormatInfo-Objekt, das die Formatierung der zurückgegebenen Zeichenfolge definiert.
Ein benutzerdefiniertes Objekt, das die IFormatProvider Schnittstelle implementiert. Die IFormatProvider.GetFormat-Methode gibt ein DateTimeFormatInfo Objekt zurück, das Formatierungsinformationen bereitstellt.

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

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

Weitere Informationen

Gilt für:

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

Quelle:: TimeSpan.cs

Quelle:: TimeSpan.cs

Quelle:: TimeSpan.cs

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

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

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

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

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

Parameter

input: String

Eine Zeichenfolge, die das zu konvertierende Zeitintervall angibt.

formats: String[]

Ein Array von Standard- oder benutzerdefinierten Formatzeichenfolgen, die das erforderliche Format von inputdefinieren.

formatProvider: IFormatProvider

Ein Objekt, das kulturspezifische Formatierungsinformationen bereitstellt.

styles: TimeSpanStyles

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

Gibt zurück

TimeSpan

Ein Zeitintervall, das inputentspricht, wie durch formats, formatProviderund stylesangegeben.

Ausnahmen

ArgumentException

styles ist ein ungültiger TimeSpanStyles Wert.

ArgumentNullException

input ist null.

FormatException

input weist ein ungültiges Format auf.

OverflowException

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

-oder-

Mindestens eine der Komponenten für Tage, Stunden, Minuten oder Sekunden in input liegt außerhalb des gültigen Bereichs.

Beispiele

Im folgenden Beispiel wird die ParseExact(String, String[], IFormatProvider, TimeSpanStyles)-Methode aufgerufen, um jedes Element eines Zeichenfolgenarrays in einen TimeSpan Wert zu konvertieren. Die Zeichenfolgen können ein Zeitintervall entweder im allgemeinen kurzen Format oder im allgemeinen langen Format darstellen.

using System;
using System.Globalization;

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

open System
open System.Globalization

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

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

Imports System.Globalization

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

Hinweise

Die ParseExact(String, String[], IFormatProvider, TimeSpanStyles)-Methode analysiert die Zeichenfolgendarstellung eines Zeitintervalls, das sich in einem der formate befinden muss, die vom parameter formats definiert werden, mit der Ausnahme, dass führende und nachfolgende Leerzeichen ignoriert werden. Da input genau einem der formate entsprechen muss, die in formatsangegeben sind, sollten Sie beim Konvertieren einer Zeichenfolgeneingabe durch den Benutzer immer eine Ausnahmebehandlung in ein Zeitintervall verwenden. Wenn Sie die Ausnahmebehandlung nicht verwenden möchten, können Sie stattdessen die TryParseExact(String, String[], IFormatProvider, TimeSpanStyles, TimeSpan)-Methode aufrufen.

Wichtig

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

Ein CultureInfo-Objekt, das die Kultur darstellt, deren Formatierungskonventionen in der zurückgegebenen Zeichenfolge widergespiegelt werden sollen. Das von der CultureInfo.DateTimeFormat -Eigenschaft zurückgegebene DateTimeFormatInfo -Objekt definiert die Formatierung der zurückgegebenen Zeichenfolge.
Ein DateTimeFormatInfo-Objekt, das die Formatierung der zurückgegebenen Zeichenfolge definiert.
Ein benutzerdefiniertes Objekt, das die IFormatProvider Schnittstelle implementiert. Die IFormatProvider.GetFormat-Methode gibt ein DateTimeFormatInfo Objekt zurück, das Formatierungsinformationen bereitstellt.

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

Weitere Informationen

Gilt für:

Teilen über

TimeSpan.ParseExact Methode

Definition

Überlädt

ParseExact(String, String, IFormatProvider)

Parameter

Gibt zurück

Ausnahmen

Beispiele

Hinweise

Weitere Informationen

Gilt für:

ParseExact(String, String[], IFormatProvider)

Parameter

Gibt zurück

Ausnahmen

Beispiele

Hinweise

Weitere Informationen

Gilt für:

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

Parameter

Gibt zurück

Gilt für:

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

Parameter

Gibt zurück

Gilt für:

ParseExact(String, String, IFormatProvider, TimeSpanStyles)

Parameter

Gibt zurück

Ausnahmen

Beispiele

Hinweise

Weitere Informationen

Gilt für:

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

Parameter

Gibt zurück

Ausnahmen

Beispiele

Hinweise

Weitere Informationen

Gilt für:

Zusätzliche Ressourcen