TimeSpan.TryParseExact Methode

Definition

Konvertiert die Zeichenfolgendarstellung eines Zeitintervalls in die entsprechende TimeSpan und gibt einen Wert zurück, der angibt, ob die Konvertierung erfolgreich durchgeführt wurde. Das Format der Zeichenfolgendarstellung muss einem angegebenen Format genau entsprechen.

Überlädt

TryParseExact(ReadOnlySpan<Char>, ReadOnlySpan<Char>, IFormatProvider, TimeSpanStyles, TimeSpan)

Konvertiert die angegebene Spannendarstellung eines Zeitintervalls unter Verwendung des angegebenen Formats, der kulturspezifischen Formatierungsinformationen und der Stile in die entsprechende TimeSpan und gibt einen Wert zurück, der angibt, ob die Konvertierung erfolgreich abgeschlossen wurde. Das Format der Zeichenfolgendarstellung muss dem angegebenen Format genau entsprechen.

TryParseExact(String, String, IFormatProvider, TimeSpanStyles, TimeSpan)

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.

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

Konvertiert die angegebene Spannendarstellung 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.

TryParseExact(String, String[], IFormatProvider, TimeSpan)

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

TryParseExact(String, String[], IFormatProvider, TimeSpanStyles, TimeSpan)

Konvertiert die angegebene 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.

TryParseExact(ReadOnlySpan<Char>, String[], IFormatProvider, TimeSpan)

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

TryParseExact(ReadOnlySpan<Char>, ReadOnlySpan<Char>, IFormatProvider, TimeSpan)

Konvertiert die angegebene Spannendarstellung 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.

TryParseExact(String, String, IFormatProvider, TimeSpan)

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.

TryParseExact(ReadOnlySpan<Char>, ReadOnlySpan<Char>, IFormatProvider, TimeSpanStyles, TimeSpan)

Konvertiert die angegebene Spannendarstellung eines Zeitintervalls unter Verwendung des angegebenen Formats, der kulturspezifischen Formatierungsinformationen und der Stile in die entsprechende TimeSpan und gibt einen Wert zurück, der angibt, ob die Konvertierung erfolgreich abgeschlossen wurde. Das Format der Zeichenfolgendarstellung muss dem angegebenen Format genau entsprechen.

public:
 static bool TryParseExact(ReadOnlySpan<char> input, ReadOnlySpan<char> format, IFormatProvider ^ formatProvider, System::Globalization::TimeSpanStyles styles, [Runtime::InteropServices::Out] TimeSpan % result);
public static bool TryParseExact (ReadOnlySpan<char> input, ReadOnlySpan<char> format, IFormatProvider? formatProvider, System.Globalization.TimeSpanStyles styles, out TimeSpan result);
public static bool TryParseExact (ReadOnlySpan<char> input, ReadOnlySpan<char> format, IFormatProvider formatProvider, System.Globalization.TimeSpanStyles styles, out TimeSpan result);
static member TryParseExact : ReadOnlySpan<char> * ReadOnlySpan<char> * IFormatProvider * System.Globalization.TimeSpanStyles * TimeSpan -> bool
Public Shared Function TryParseExact (input As ReadOnlySpan(Of Char), format As ReadOnlySpan(Of Char), formatProvider As IFormatProvider, styles As TimeSpanStyles, ByRef result As TimeSpan) As Boolean

Parameter

input
ReadOnlySpan<Char>

Eine Spanne mit den Zeichen, die ein zu konvertierendes Zeitintervall darstellen.

format
ReadOnlySpan<Char>

Eine Spanne, die die Zeichen enthält, die eine standardmäßig festgelegte oder benutzerdefinierte Formatzeichenfolge darstellen, die das akzeptable Format von input definiert.

formatProvider
IFormatProvider

Ein Objekt, das kulturspezifische Formatierungsinformationen bereitstellt.

styles
TimeSpanStyles

Ein oder mehrere Enumerationswerte, die den Stil von input angeben.

result
TimeSpan

Diese Methode gibt entweder ein Objekt zurück, das das durch input angegebene Zeitintervall darstellt, oder Zero, wenn die Konvertierung nicht ausgeführt werden konnte. Dieser Parameter wird nicht initialisiert übergeben.

Gibt zurück

Boolean

true, wenn input erfolgreich konvertiert wurde, andernfalls false.

Gilt für

TryParseExact(String, String, IFormatProvider, TimeSpanStyles, TimeSpan)

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 bool TryParseExact(System::String ^ input, System::String ^ format, IFormatProvider ^ formatProvider, System::Globalization::TimeSpanStyles styles, [Runtime::InteropServices::Out] TimeSpan % result);
public static bool TryParseExact (string input, string format, IFormatProvider formatProvider, System.Globalization.TimeSpanStyles styles, out TimeSpan result);
public static bool TryParseExact (string? input, string? format, IFormatProvider? formatProvider, System.Globalization.TimeSpanStyles styles, out TimeSpan result);
public static bool TryParseExact (string? input, string format, IFormatProvider? formatProvider, System.Globalization.TimeSpanStyles styles, out TimeSpan result);
static member TryParseExact : string * string * IFormatProvider * System.Globalization.TimeSpanStyles * TimeSpan -> bool
Public Shared Function TryParseExact (input As String, format As String, formatProvider As IFormatProvider, styles As TimeSpanStyles, ByRef result As TimeSpan) As Boolean

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

Ein oder mehrere Enumerationswerte, die den Stil von input angeben.

result
TimeSpan

Diese Methode gibt entweder ein Objekt zurück, das das durch input angegebene Zeitintervall darstellt, oder Zero, wenn die Konvertierung nicht ausgeführt werden konnte. Dieser Parameter wird nicht initialisiert übergeben.

Gibt zurück

Boolean

true, wenn input erfolgreich konvertiert wurde, andernfalls false.

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 des Beispiels veranschaulicht, dass sich der TimeSpanStyles.AssumeNegative Stil nur auf den Rückgabewert auswirkt, wenn er 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;
      if (TimeSpan.TryParseExact(intervalString, format, 
                                 culture, TimeSpanStyles.AssumeNegative, out interval))
         Console.WriteLine("'{0}' ({1}) --> {2}", intervalString, format, interval);
      else   
         Console.WriteLine("Unable to parse '{0}' using format {1}",
                           intervalString, format);
      
      // Parse hour:minute:second value with "g" specifier.
      intervalString = "17:14:48";
      format = "g";
      culture = CultureInfo.InvariantCulture;
      if (TimeSpan.TryParseExact(intervalString, format, 
                                 culture, TimeSpanStyles.AssumeNegative, out interval))
         Console.WriteLine("'{0}' ({1}) --> {2}", intervalString, format, interval);
      else
         Console.WriteLine("Unable to parse '{0}' using format {1}",
                           intervalString, format);
      
      // Parse hours:minute.second value with custom format specifier.     
      intervalString = "17:14:48.153";
      format = @"h\:mm\:ss\.fff";
      culture = null;
      if (TimeSpan.TryParseExact(intervalString, format, 
                                 culture, TimeSpanStyles.AssumeNegative, out interval))
         Console.WriteLine("'{0}' ({1}) --> {2}", intervalString, format, interval);
      else
         Console.WriteLine("Unable to parse '{0}' using format {1}",
                           intervalString, format);   

      // 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;
      if (TimeSpan.TryParseExact(intervalString, format, 
                                 culture, TimeSpanStyles.AssumeNegative, out interval))
         Console.WriteLine("'{0}' ({1}) --> {2}", intervalString, format, interval);
      else   
         Console.WriteLine("Unable to parse '{0}' using format {1}",
                           intervalString, format);   
            
      // 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;
      if (TimeSpan.TryParseExact(intervalString, format, 
                                 culture, TimeSpanStyles.AssumeNegative, out interval))
         Console.WriteLine("'{0}' ({1}) --> {2}", intervalString, format, interval);
      else   
         Console.WriteLine("Unable to parse '{0}' using format {1}",
                           intervalString, format);
      
      // 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");
      if (TimeSpan.TryParseExact(intervalString, format, 
                                 culture, TimeSpanStyles.AssumeNegative, out interval))
         Console.WriteLine("'{0}' ({1}) --> {2}", intervalString, format, interval);
      else   
         Console.WriteLine("Unable to parse '{0}' using format {1}",
                           intervalString, format);

      // Parse a single number using the "c" standard format string. 
      intervalString = "12";
      format = "c";
      if (TimeSpan.TryParseExact(intervalString, format, 
                                 null, TimeSpanStyles.AssumeNegative, out interval))
         Console.WriteLine("'{0}' ({1}) --> {2}", intervalString, format, interval);
      else   
         Console.WriteLine("Unable to parse '{0}' using format {1}",
                           intervalString, format);
      
      // Parse a single number using the "%h" custom format string. 
      format = "%h";
      if (TimeSpan.TryParseExact(intervalString, format, 
                                 null, TimeSpanStyles.AssumeNegative, out interval))
         Console.WriteLine("'{0}' ({1}) --> {2}", intervalString, format, interval);
      else   
         Console.WriteLine("Unable to parse '{0}' using format {1}",
                           intervalString, format);
      
      // Parse a single number using the "%s" custom format string. 
      format = "%s";
      if (TimeSpan.TryParseExact(intervalString, format, 
                                 null, TimeSpanStyles.AssumeNegative, out interval))
         Console.WriteLine("'{0}' ({1}) --> {2}", intervalString, format, interval);
      else   
         Console.WriteLine("Unable to parse '{0}' using format {1}",
                           intervalString, format);
   }
}
// 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
    match TimeSpan.TryParseExact(intervalString, format, culture, TimeSpanStyles.AssumeNegative) with
    | true, interval ->
        printfn $"'{intervalString}' ({format}) --> {interval}"
    | _ ->   
        printfn $"Unable to parse '{intervalString}' using format {format}" 
    
    // Parse hour:minute:second value with "g" specifier.
    let intervalString = "17:14:48"
    let format = "g"
    let culture = CultureInfo.InvariantCulture
    match TimeSpan.TryParseExact(intervalString, format, culture, TimeSpanStyles.AssumeNegative) with
    | true, interval ->
        printfn $"'{intervalString}' ({format}) --> {interval}"
    | _ ->
        printfn $"Unable to parse '{intervalString}' using format {format}" 
    
    // Parse hours:minute.second value with custom format specifier.     
    let intervalString = "17:14:48.153"
    let format = @"h\:mm\:ss\.fff"
    let culture = null
    match TimeSpan.TryParseExact(intervalString, format, culture, TimeSpanStyles.AssumeNegative) with
    | true, interval ->
        printfn $"'{intervalString}' ({format}) --> {interval}"
    | _ ->
        printfn $"Unable to parse '{intervalString}' using format {format}"    

    // 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
    match TimeSpan.TryParseExact(intervalString, format, culture, TimeSpanStyles.AssumeNegative) with
    | true, interval ->
        printfn $"'{intervalString}' ({format}) --> {interval}"
    | _ ->   
        printfn $"Unable to parse '{intervalString}' using format {format}"    
        
    // 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
    match TimeSpan.TryParseExact(intervalString, format, culture, TimeSpanStyles.AssumeNegative) with
    | true, interval ->
        printfn $"'{intervalString}' ({format}) --> {interval}"
    | _ ->   
        printfn $"Unable to parse '{intervalString}' using format {format}" 
    
    // 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")
    match TimeSpan.TryParseExact(intervalString, format, culture, TimeSpanStyles.AssumeNegative) with
    | true, interval ->
        printfn $"'{intervalString}' ({format}) --> {interval}"
    | _ ->   
        printfn $"Unable to parse '{intervalString}' using format {format}" 

    // Parse a single number using the "c" standard format string. 
    let intervalString = "12"
    let format = "c"
    match TimeSpan.TryParseExact(intervalString, format, null, TimeSpanStyles.AssumeNegative) with
    | true, interval ->
        printfn $"'{intervalString}' ({format}) --> {interval}"
    | _ ->   
        printfn $"Unable to parse '{intervalString}' using format {format}" 
    
    // Parse a single number using the "%h" custom format string. 
    let format = "%h"
    match TimeSpan.TryParseExact(intervalString, format, null, TimeSpanStyles.AssumeNegative) with
    | true, interval ->
        printfn $"'{intervalString}' ({format}) --> {interval}"
    | _ ->   
        printfn $"Unable to parse '{intervalString}' using format {format}" 
    
    // Parse a single number using the "%s" custom format string. 
    let format = "%s"
    match TimeSpan.TryParseExact(intervalString, format, null, TimeSpanStyles.AssumeNegative) with
    | true, interval ->
        printfn $"'{intervalString}' ({format}) --> {interval}"
    | _ ->   
        printfn $"Unable to parse '{intervalString}' using format {format}" 
// 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
      If TimeSpan.TryParseExact(intervalString, format, 
                                culture, TimeSpanStyles.AssumeNegative, interval) Then
         Console.WriteLine("'{0}' ({1}) --> {2}", intervalString, format, interval)
      Else
         Console.WriteLine("Unable to parse '{0}' using format {1}",
                           intervalString, format)   
      End If
      
      ' Parse hour:minute:second value with "g" specifier.
      intervalString = "17:14:48"
      format = "g"
      culture = CultureInfo.InvariantCulture
      If TimeSpan.TryParseExact(intervalString, format, 
                                culture, TimeSpanStyles.AssumeNegative, interval) Then
         Console.WriteLine("'{0}' ({1}) --> {2}", intervalString, format, interval)
      Else
         Console.WriteLine("Unable to parse '{0}' using format {1}",
                           intervalString, format)   
      End If
      
      ' Parse hours:minute.second value with custom format specifier.     
      intervalString = "17:14:48.153"
      format = "h\:mm\:ss\.fff"
      culture = Nothing
      If TimeSpan.TryParseExact(intervalString, format, 
                                culture, TimeSpanStyles.AssumeNegative, interval) Then
         Console.WriteLine("'{0}' ({1}) --> {2}", intervalString, format, interval)
      Else
         Console.WriteLine("Unable to parse '{0}' using format {1}",
                           intervalString, format)   
      End If 

      ' 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
      If TimeSpan.TryParseExact(intervalString, format, 
                                culture, TimeSpanStyles.AssumeNegative, interval) Then
         Console.WriteLine("'{0}' ({1}) --> {2}", intervalString, format, interval)
      Else
         Console.WriteLine("Unable to parse '{0}' using format {1}",
                           intervalString, format)   
      End If 
            
      ' 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
      If TimeSpan.TryParseExact(intervalString, format, 
                                culture, TimeSpanStyles.AssumeNegative, interval) Then
         Console.WriteLine("'{0}' ({1}) --> {2}", intervalString, format, interval)
      Else
         Console.WriteLine("Unable to parse '{0}' using format {1}",
                           intervalString, format)   
      End If 
      
      ' 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")
      If TimeSpan.TryParseExact(intervalString, format, 
                                culture, TimeSpanStyles.AssumeNegative, interval) Then
         Console.WriteLine("'{0}' ({1}) --> {2}", intervalString, format, interval)
      Else
         Console.WriteLine("Unable to parse '{0}' using format {1}",
                           intervalString, format)
      End If 

      ' Parse a single number using the "c" standard format string. 
      intervalString = "12"
      format = "c"
      If TimeSpan.TryParseExact(intervalString, format, 
                                Nothing, TimeSpanStyles.AssumeNegative, interval) Then
         Console.WriteLine("'{0}' ({1}) --> {2}", intervalString, format, interval)
      Else
         Console.WriteLine("Unable to parse '{0}' using format {1}",
                           intervalString, format)   
      End If 
      
      ' Parse a single number using the "%h" custom format string. 
      format = "%h"
      If TimeSpan.TryParseExact(intervalString, format, 
                                Nothing, TimeSpanStyles.AssumeNegative, interval) Then
         Console.WriteLine("'{0}' ({1}) --> {2}", intervalString, format, interval)
      Else
         Console.WriteLine("Unable to parse '{0}' using format {1}",
                           intervalString, format)   
      End If 
      
      ' Parse a single number using the "%s" custom format string. 
      format = "%s"
      If TimeSpan.TryParseExact(intervalString, format, 
                                Nothing, TimeSpanStyles.AssumeNegative, interval) Then
         Console.WriteLine("'{0}' ({1}) --> {2}", intervalString, format, interval)
      Else
         Console.WriteLine("Unable to parse '{0}' using format {1}",
                           intervalString, format)   
      End If 
   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 TryParseExact(String, String, IFormatProvider, TimeSpanStyles, TimeSpan) -Methode analysiert die Zeichenfolgendarstellung eines Zeitintervalls, das im vom -Parameter definierten Format vorliegen muss, mit der format Ausnahme, dass führende und nachfolgende Leerzeichen ignoriert werden. Diese Methode ähnelt der -Methode, mit der ParseExact(String, String, IFormatProvider, TimeSpanStyles) Ausnahme, dass sie keine Ausnahme auslöst, wenn die Konvertierung fehlschlägt.

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-Formatzeichenfolgen und benutzerdefinierte TimeSpan-Formatzeichenfolgen.

Der formatProvider Parameter ist eine IFormatProvider Implementierung, die kulturspezifische Informationen über das Format der zurückgegebenen Zeichenfolge bereitstellt, wenn format es sich um eine Standardformatzeichenfolge handelt. Der formatProvider Parameter kann einer der folgenden Sein:

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

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

Siehe auch

Gilt für

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

Konvertiert die angegebene Spannendarstellung 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 bool TryParseExact(ReadOnlySpan<char> input, cli::array <System::String ^> ^ formats, IFormatProvider ^ formatProvider, System::Globalization::TimeSpanStyles styles, [Runtime::InteropServices::Out] TimeSpan % result);
public static bool TryParseExact (ReadOnlySpan<char> input, string?[]? formats, IFormatProvider? formatProvider, System.Globalization.TimeSpanStyles styles, out TimeSpan result);
public static bool TryParseExact (ReadOnlySpan<char> input, string[] formats, IFormatProvider formatProvider, System.Globalization.TimeSpanStyles styles, out TimeSpan result);
public static bool TryParseExact (ReadOnlySpan<char> input, string[] formats, IFormatProvider? formatProvider, System.Globalization.TimeSpanStyles styles, out TimeSpan result);
static member TryParseExact : ReadOnlySpan<char> * string[] * IFormatProvider * System.Globalization.TimeSpanStyles * TimeSpan -> bool
Public Shared Function TryParseExact (input As ReadOnlySpan(Of Char), formats As String(), formatProvider As IFormatProvider, styles As TimeSpanStyles, ByRef result As TimeSpan) As Boolean

Parameter

input
ReadOnlySpan<Char>

Eine Spanne mit den Zeichen, die ein zu konvertierendes Zeitintervall darstellen.

formats
String[]

Ein Array von standardmäßigen oder benutzerdefinierten Formatierungszeichenfolgen, die die zulässigen Formate von input definieren.

formatProvider
IFormatProvider

Ein Objekt, das kulturspezifische Formatierungsinformationen bereitstellt.

styles
TimeSpanStyles

Ein oder mehrere Enumerationswerte, die den Stil von input angeben.

result
TimeSpan

Diese Methode gibt entweder ein Objekt zurück, das das durch input angegebene Zeitintervall darstellt, oder Zero, wenn die Konvertierung nicht ausgeführt werden konnte. Dieser Parameter wird nicht initialisiert übergeben.

Gibt zurück

Boolean

true, wenn input erfolgreich konvertiert wurde, andernfalls false.

Gilt für

TryParseExact(String, String[], IFormatProvider, TimeSpan)

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

public:
 static bool TryParseExact(System::String ^ input, cli::array <System::String ^> ^ formats, IFormatProvider ^ formatProvider, [Runtime::InteropServices::Out] TimeSpan % result);
public static bool TryParseExact (string input, string[] formats, IFormatProvider formatProvider, out TimeSpan result);
public static bool TryParseExact (string? input, string?[]? formats, IFormatProvider? formatProvider, out TimeSpan result);
public static bool TryParseExact (string? input, string[] formats, IFormatProvider? formatProvider, out TimeSpan result);
static member TryParseExact : string * string[] * IFormatProvider * TimeSpan -> bool
Public Shared Function TryParseExact (input As String, formats As String(), formatProvider As IFormatProvider, ByRef result As TimeSpan) As Boolean

Parameter

input
String

Eine Zeichenfolge, die das zu konvertierende Zeitintervall angibt.

formats
String[]

Ein Array von standardmäßigen oder benutzerdefinierten Formatierungszeichenfolgen, die die zulässigen Formate von input definieren.

formatProvider
IFormatProvider

Ein Objekt, das kulturspezifische Formatierungsinformationen bereitstellt.

result
TimeSpan

Diese Methode gibt entweder ein Objekt zurück, das das durch input angegebene Zeitintervall darstellt, oder Zero, wenn die Konvertierung nicht ausgeführt werden konnte. Dieser Parameter wird nicht initialisiert übergeben.

Gibt zurück

Boolean

true, wenn input erfolgreich konvertiert wurde, andernfalls false.

Beispiele

Im folgenden Beispiel wird die TryParseExact(String, String[], IFormatProvider, TimeSpan) -Methode aufgerufen, um jedes Element eines Zeichenfolgenarrays in einen TimeSpan Wert zu konvertieren. 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 langen Format darstellen.

Darüber hinaus ändert das Beispiel die Art und Weise, wie die Methoden der Zeitintervallanalyse eine einzelne Ziffer interpretieren. Normalerweise wird eine einzelne Ziffer als Anzahl von Tagen 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 werden 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) {
         if(TimeSpan.TryParseExact(input, formats, culture, out interval))
            Console.WriteLine("{0} --> {1:c}", input, interval);
         else
            Console.WriteLine("Unable to parse {0}", input);   
      }
   }
}
// The example displays the following output:
//       3 --> 03:00:00
//       16:42 --> 16:42:00
//       Unable to parse 1:6:52:35.0625
//       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
    match TimeSpan.TryParseExact(input, formats, culture) with
    | true, interval ->
        printfn $"{input} --> {interval:c}"
    | _ ->
        printfn $"Unable to parse {input}"
// The example displays the following output:
//       3 --> 03:00:00
//       16:42 --> 16:42:00
//       Unable to parse 1:6:52:35.0625
//       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
         If TimeSpan.TryParseExact(input, formats, culture, interval) Then
            Console.WriteLine("{0} --> {1:c}", input, interval)   
         Else
            Console.WriteLine("Unable to parse {0}", input)   
         End If            
      Next
   End Sub
End Module
' The example displays the following output:
'       3 --> 03:00:00
'       16:42 --> 16:42:00
'       Unable to parse 1:6:52:35.0625
'       1:6:52:35,0625 --> 1.06:52:35.0625000

Hinweise

Die TryParseExact(String, String[], IFormatProvider, TimeSpan) -Methode analysiert die Zeichenfolgendarstellung eines Zeitintervalls, das in dem Format vorliegen muss, das durch eine der vom Parameter angegebenen Formatzeichenfolgen definiert werden muss, mit der formats Ausnahme, dass führende und nachfolgende Leerzeichen ignoriert werden. Diese Methode ähnelt der -Methode, mit der ParseExact(String, String[], IFormatProvider) Ausnahme, dass sie keine Ausnahme auslöst, wenn die Konvertierung fehlschlägt.

Der formats Parameter ist ein Zeichenfolgenarray, dessen Elemente entweder aus einem einzelnen 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-Formatzeichenfolgen und benutzerdefinierte TimeSpan-Formatzeichenfolgen. input muss genau einem Member von formats entsprechen, damit der Analysevorgang erfolgreich ist. Der Analysevorgang versucht, mit jedem Element formats ab dem ersten Element im Array abzugleicheninput.

Wichtig

Die TryParseExact -Methode verwendet die Konventionen der kultur, die durch den formatProvider -Parameter angegeben werden, nur, wenn die zum Analysieren input verwendete Formatzeichenfolge eine Standardformatzeichenfolge TimeSpan 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 einer der folgenden Sein:

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

Siehe auch

Gilt für

TryParseExact(String, String[], IFormatProvider, TimeSpanStyles, TimeSpan)

Konvertiert die angegebene 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 bool TryParseExact(System::String ^ input, cli::array <System::String ^> ^ formats, IFormatProvider ^ formatProvider, System::Globalization::TimeSpanStyles styles, [Runtime::InteropServices::Out] TimeSpan % result);
public static bool TryParseExact (string input, string[] formats, IFormatProvider formatProvider, System.Globalization.TimeSpanStyles styles, out TimeSpan result);
public static bool TryParseExact (string? input, string?[]? formats, IFormatProvider? formatProvider, System.Globalization.TimeSpanStyles styles, out TimeSpan result);
public static bool TryParseExact (string? input, string[] formats, IFormatProvider? formatProvider, System.Globalization.TimeSpanStyles styles, out TimeSpan result);
static member TryParseExact : string * string[] * IFormatProvider * System.Globalization.TimeSpanStyles * TimeSpan -> bool
Public Shared Function TryParseExact (input As String, formats As String(), formatProvider As IFormatProvider, styles As TimeSpanStyles, ByRef result As TimeSpan) As Boolean

Parameter

input
String

Eine Zeichenfolge, die das zu konvertierende Zeitintervall angibt.

formats
String[]

Ein Array von standardmäßigen oder benutzerdefinierten Formatierungszeichenfolgen, die die zulässigen Formate von input definieren.

formatProvider
IFormatProvider

Ein Objekt, das kulturspezifische Formatierungsinformationen bereitstellt.

styles
TimeSpanStyles

Ein oder mehrere Enumerationswerte, die den Stil von input angeben.

result
TimeSpan

Diese Methode gibt entweder ein Objekt zurück, das das durch input angegebene Zeitintervall darstellt, oder Zero, wenn die Konvertierung nicht ausgeführt werden konnte. Dieser Parameter wird nicht initialisiert übergeben.

Gibt zurück

Boolean

true, wenn input erfolgreich konvertiert wurde, andernfalls false.

Beispiele

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

Darüber hinaus ändert das Beispiel die Art und Weise, wie die Methoden der Zeitintervallanalyse eine einzelne Ziffer interpretieren. Normalerweise wird eine einzelne Ziffer als die Anzahl von Tagen 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 werden muss, damit diese Änderung wirksam ist. Beachten Sie außerdem in der Ausgabe, dass das TimeSpanStyles.AssumeNegative im Methodenaufruf angegebene Flag nur beim Analysieren einer Zeichenfolge mit 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("fr-FR");
      
      // Parse each string in inputs using formats and the fr-FR culture.
      foreach (string input in inputs) {
         if(TimeSpan.TryParseExact(input, formats, culture, 
                                   TimeSpanStyles.AssumeNegative, out interval))
            Console.WriteLine("{0} --> {1:c}", input, interval);
         else
            Console.WriteLine("Unable to parse {0}", input);   
      }
   }
}
// The example displays the following output:
//       3 --> -03:00:00
//       16:42 --> 16:42:00
//       Unable to parse 1:6:52:35.0625
//       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 "fr-FR"

// Parse each string in inputs using formats and the fr-FR culture.
for input in inputs do
    match TimeSpan.TryParseExact(input, formats, culture, TimeSpanStyles.AssumeNegative) with
    | true, interval ->
        printfn $"{input} --> {interval:c}"
    | _ ->
        printfn $"Unable to parse {input}"
// The example displays the following output:
//       3 --> -03:00:00
//       16:42 --> 16:42:00
//       Unable to parse 1:6:52:35.0625
//       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 fr-FR culture.
      For Each input As String In inputs
         If TimeSpan.TryParseExact(input, formats, culture, 
                                   TimeSpanStyles.AssumeNegative, interval) Then
            Console.WriteLine("{0} --> {1:c}", input, interval)   
         Else
            Console.WriteLine("Unable to parse {0}", input)   
         End If            
      Next
   End Sub
End Module
' The example displays the following output:
'       3 --> -03:00:00
'       16:42 --> 16:42:00
'       Unable to parse 1:6:52:35.0625
'       1:6:52:35,0625 --> 1.06:52:35.0625000

Hinweise

Die TryParseExact(String, String[], IFormatProvider, TimeSpanStyles, TimeSpan) -Methode analysiert die Zeichenfolgendarstellung eines Zeitintervalls, das sich in dem Format befinden muss, das durch eine der vom Parameter angegebenen Formatzeichenfolgen definiert werden muss, mit der formats Ausnahme, dass führende und nachfolgende Leerzeichen ignoriert werden. Diese Methode ähnelt der Methode, mit dem ParseExact(String, String[], IFormatProvider, TimeSpanStyles) Unterschied, dass sie keine Ausnahme auslöst, wenn die Konvertierung fehlschlägt.

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

Wichtig

Die ParseExact -Methode verwendet die Konventionen der kultur, die durch den formatProvider -Parameter angegeben werden, nur, wenn die zum Analysieren input verwendete Formatzeichenfolge eine Standardformatzeichenfolge TimeSpan 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 einer der folgenden Sein:

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

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

Siehe auch

Gilt für

TryParseExact(ReadOnlySpan<Char>, String[], IFormatProvider, TimeSpan)

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

public:
 static bool TryParseExact(ReadOnlySpan<char> input, cli::array <System::String ^> ^ formats, IFormatProvider ^ formatProvider, [Runtime::InteropServices::Out] TimeSpan % result);
public static bool TryParseExact (ReadOnlySpan<char> input, string?[]? formats, IFormatProvider? formatProvider, out TimeSpan result);
public static bool TryParseExact (ReadOnlySpan<char> input, string[] formats, IFormatProvider formatProvider, out TimeSpan result);
public static bool TryParseExact (ReadOnlySpan<char> input, string[] formats, IFormatProvider? formatProvider, out TimeSpan result);
static member TryParseExact : ReadOnlySpan<char> * string[] * IFormatProvider * TimeSpan -> bool
Public Shared Function TryParseExact (input As ReadOnlySpan(Of Char), formats As String(), formatProvider As IFormatProvider, ByRef result As TimeSpan) As Boolean

Parameter

input
ReadOnlySpan<Char>

Eine Spanne mit den Zeichen, die ein zu konvertierendes Zeitintervall darstellen.

formats
String[]

Ein Array von standardmäßigen oder benutzerdefinierten Formatierungszeichenfolgen, die die zulässigen Formate von input definieren.

formatProvider
IFormatProvider

Ein Objekt, das kulturspezifische Formatierungsinformationen bereitstellt.

result
TimeSpan

Diese Methode gibt entweder ein Objekt zurück, das das durch input angegebene Zeitintervall darstellt, oder Zero, wenn die Konvertierung nicht ausgeführt werden konnte. Dieser Parameter wird nicht initialisiert übergeben.

Gibt zurück

Boolean

true, wenn input erfolgreich konvertiert wurde, andernfalls false.

Gilt für

TryParseExact(ReadOnlySpan<Char>, ReadOnlySpan<Char>, IFormatProvider, TimeSpan)

Konvertiert die angegebene Spannendarstellung 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 bool TryParseExact(ReadOnlySpan<char> input, ReadOnlySpan<char> format, IFormatProvider ^ formatProvider, [Runtime::InteropServices::Out] TimeSpan % result);
public static bool TryParseExact (ReadOnlySpan<char> input, ReadOnlySpan<char> format, IFormatProvider? formatProvider, out TimeSpan result);
public static bool TryParseExact (ReadOnlySpan<char> input, ReadOnlySpan<char> format, IFormatProvider formatProvider, out TimeSpan result);
static member TryParseExact : ReadOnlySpan<char> * ReadOnlySpan<char> * IFormatProvider * TimeSpan -> bool
Public Shared Function TryParseExact (input As ReadOnlySpan(Of Char), format As ReadOnlySpan(Of Char), formatProvider As IFormatProvider, ByRef result As TimeSpan) As Boolean

Parameter

input
ReadOnlySpan<Char>

Eine Spanne mit den Zeichen, die ein zu konvertierendes Zeitintervall darstellen.

format
ReadOnlySpan<Char>

Eine Spanne, die die Zeichen enthält, die eine standardmäßig festgelegte oder benutzerdefinierte Formatzeichenfolge darstellen, die das akzeptable Format von input definiert.

formatProvider
IFormatProvider

Ein Objekt, das kulturspezifische Formatierungsinformationen bereitstellt.

result
TimeSpan

Diese Methode gibt entweder ein Objekt zurück, das das durch input angegebene Zeitintervall darstellt, oder Zero, wenn die Konvertierung nicht ausgeführt werden konnte. Dieser Parameter wird nicht initialisiert übergeben.

Gibt zurück

Boolean

true, wenn input erfolgreich konvertiert wurde, andernfalls false.

Gilt für

TryParseExact(String, String, IFormatProvider, TimeSpan)

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 bool TryParseExact(System::String ^ input, System::String ^ format, IFormatProvider ^ formatProvider, [Runtime::InteropServices::Out] TimeSpan % result);
public static bool TryParseExact (string input, string format, IFormatProvider formatProvider, out TimeSpan result);
public static bool TryParseExact (string? input, string? format, IFormatProvider? formatProvider, out TimeSpan result);
public static bool TryParseExact (string? input, string format, IFormatProvider? formatProvider, out TimeSpan result);
static member TryParseExact : string * string * IFormatProvider * TimeSpan -> bool
Public Shared Function TryParseExact (input As String, format As String, formatProvider As IFormatProvider, ByRef result As TimeSpan) As Boolean

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.

result
TimeSpan

Diese Methode gibt entweder ein Objekt zurück, das das durch input angegebene Zeitintervall darstellt, oder Zero, wenn die Konvertierung nicht ausgeführt werden konnte. Dieser Parameter wird nicht initialisiert übergeben.

Gibt zurück

Boolean

true, wenn input erfolgreich konvertiert wurde, andernfalls false.

Beispiele

Im folgenden Beispiel wird die TryParseExact(String, String, IFormatProvider, TimeSpanStyles, TimeSpan) -Methode verwendet, um mehrere Zeichenfolgendarstellungen von Zeitintervallen mit verschiedenen 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;
      if (TimeSpan.TryParseExact(intervalString, format, culture, out interval))
         Console.WriteLine("'{0}' --> {1}", intervalString, interval);
      else
         Console.WriteLine("Unable to parse {0}", intervalString);
      
      // Parse hour:minute:second value with "G" specifier.
      intervalString = "17:14:48";
      format = "G";
      culture = CultureInfo.InvariantCulture;
      if (TimeSpan.TryParseExact(intervalString, format, culture, out interval))
         Console.WriteLine("'{0}' --> {1}", intervalString, interval);
      else
         Console.WriteLine("Unable to parse {0}", intervalString);
      
      // Parse hours:minute.second value with "G" specifier 
      // and current (en-US) culture.     
      intervalString = "17:14:48.153";
      format = "G";
      culture = CultureInfo.CurrentCulture;
      if (TimeSpan.TryParseExact(intervalString, format, culture, out interval))
         Console.WriteLine("'{0}' --> {1}", intervalString, interval);
      else
         Console.WriteLine("Unable to parse {0}", 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;
      if (TimeSpan.TryParseExact(intervalString, format, culture, out interval))
         Console.WriteLine("'{0}' --> {1}", intervalString, interval);
      else
         Console.WriteLine("Unable to parse {0}", 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");
      if (TimeSpan.TryParseExact(intervalString, format, culture, out interval))
         Console.WriteLine("'{0}' --> {1}", intervalString, interval);
      else
         Console.WriteLine("Unable to parse {0}", intervalString);
      
      // Parse days:hours:minute.second value with "G" specifier 
      // and fr-FR culture.     
      intervalString = "3:17:14:48,153";
      format = "G";
      if (TimeSpan.TryParseExact(intervalString, format, culture, out interval))
         Console.WriteLine("'{0}' --> {1}", intervalString, interval);
      else
         Console.WriteLine("Unable to parse {0}", intervalString);

      // Parse a single number using the "c" standard format string. 
      intervalString = "12";
      format = "c";
      if (TimeSpan.TryParseExact(intervalString, format, null, out interval))
         Console.WriteLine("'{0}' --> {1}", intervalString, interval);
      else
         Console.WriteLine("Unable to parse {0}", intervalString);
      
      // Parse a single number using the "%h" custom format string. 
      format = "%h";
      if (TimeSpan.TryParseExact(intervalString, format, null, out interval))
         Console.WriteLine("'{0}' --> {1}", intervalString, interval);
      else
         Console.WriteLine("Unable to parse {0}", intervalString);
      
      // Parse a single number using the "%s" custom format string. 
      format = "%s";
      if (TimeSpan.TryParseExact(intervalString, format, null, out interval))
         Console.WriteLine("'{0}' --> {1}", intervalString, interval);
      else
         Console.WriteLine("Unable to parse {0}", intervalString);
   }
}
// The example displays the following output:
//       '17:14' --> 17:14:00
//       Unable to parse 17:14:48
//       Unable to parse 17:14:48.153
//       '3:17:14:48.153' --> 3.17:14:48.1530000
//       Unable to parse 3:17:14:48.153
//       '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
    match TimeSpan.TryParseExact(intervalString, format, culture) with
    | true, interval ->
        printfn $"'{intervalString}' --> {interval}"
    | _ ->
        printfn $"Unable to parse {intervalString}"
    
    // Parse hour:minute:second value with "G" specifier.
    let intervalString = "17:14:48"
    let format = "G"
    let culture = CultureInfo.InvariantCulture
    match TimeSpan.TryParseExact(intervalString, format, culture) with
    | true, interval ->
        printfn $"'{intervalString}' --> {interval}"
    | _ ->
        printfn $"Unable to parse {intervalString}"
    
    // 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
    match TimeSpan.TryParseExact(intervalString, format, culture) with
    | true, interval ->
        printfn $"'{intervalString}' --> {interval}"
    | _ ->
        printfn $"Unable to parse {intervalString}"

    // 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
    match TimeSpan.TryParseExact(intervalString, format, culture) with
    | true, interval ->
        printfn $"'{intervalString}' --> {interval}"
    | _ ->
        printfn $"Unable to parse {intervalString}"
        
    // 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")
    match TimeSpan.TryParseExact(intervalString, format, culture) with
    | true, interval ->
        printfn $"'{intervalString}' --> {interval}"
    | _ ->
        printfn $"Unable to parse {intervalString}"
    
    // Parse days:hours:minute.second value with "G" specifier 
    // and fr-FR culture.     
    let intervalString = "3:17:14:48,153"
    let format = "G"
    match TimeSpan.TryParseExact(intervalString, format, culture) with
    | true, interval ->
        printfn $"'{intervalString}' --> {interval}"
    | _ ->
        printfn $"Unable to parse {intervalString}"

    // Parse a single number using the "c" standard format string. 
    let intervalString = "12"
    let format = "c"
    match TimeSpan.TryParseExact(intervalString, format, null) with
    | true, interval ->
        printfn $"'{intervalString}' --> {interval}"
    | _ ->
        printfn $"Unable to parse {intervalString}"
    
    // Parse a single number using the "%h" custom format string. 
    let format = "%h"
    match TimeSpan.TryParseExact(intervalString, format, null) with
    | true, interval ->
        printfn $"'{intervalString}' --> {interval}"
    | _ ->
        printfn $"Unable to parse {intervalString}"
    
    // Parse a single number using the "%s" custom format string. 
    let format = "%s"
    match TimeSpan.TryParseExact(intervalString, format, null) with
    | true, interval ->
        printfn $"'{intervalString}' --> {interval}"
    | _ ->
        printfn $"Unable to parse {intervalString}"
// The example displays the following output:
//       '17:14' --> 17:14:00
//       Unable to parse 17:14:48
//       Unable to parse 17:14:48.153
//       '3:17:14:48.153' --> 3.17:14:48.1530000
//       Unable to parse 3:17:14:48.153
//       '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
      If TimeSpan.TryParseExact(intervalString, format, culture, interval) Then
         Console.WriteLine("'{0}' --> {1}", intervalString, interval)
      Else
         Console.WriteLine("Unable to parse {0}", intervalString)
      End If
      
      ' Parse hour:minute:second value with "G" specifier.
      intervalString = "17:14:48"
      format = "G"
      culture = CultureInfo.InvariantCulture
      If TimeSpan.TryParseExact(intervalString, format, culture, interval) Then
         Console.WriteLine("'{0}' --> {1}", intervalString, interval)
      Else
         Console.WriteLine("Unable to parse {0}", intervalString)
      End If

      ' Parse hours:minute.second value with "G" specifier 
      ' and current (en-US) culture.     
      intervalString = "17:14:48.153"
      format = "G"
      culture = CultureInfo.CurrentCulture
      If TimeSpan.TryParseExact(intervalString, format, culture, interval) Then
         Console.WriteLine("'{0}' --> {1}", intervalString, interval)
      Else
         Console.WriteLine("Unable to parse {0}", intervalString)
      End If

      ' 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
      If TimeSpan.TryParseExact(intervalString, format, culture, interval) Then
         Console.WriteLine("'{0}' --> {1}", intervalString, interval)
      Else
         Console.WriteLine("Unable to parse {0}", intervalString)
      End If
            
      ' 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")
      If TimeSpan.TryParseExact(intervalString, format, culture, interval) Then
         Console.WriteLine("'{0}' --> {1}", intervalString, interval)
      Else
         Console.WriteLine("Unable to parse {0}", intervalString)
      End If
      
      ' 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")
      If TimeSpan.TryParseExact(intervalString, format, culture, interval) Then
         Console.WriteLine("'{0}' --> {1}", intervalString, interval)
      Else
         Console.WriteLine("Unable to parse {0}", intervalString)
      End If

      ' Parse a single number using the "c" standard format string. 
      intervalString = "12"
      format = "c"
      If TimeSpan.TryParseExact(intervalString, format, Nothing, interval)
         Console.WriteLine("'{0}' --> {1}", intervalString, interval)
      Else
         Console.WriteLine("Unable to parse {0}", intervalString)
      End If
      
      ' Parse a single number using the "%h" custom format string. 
      format = "%h"
      If TimeSpan.TryParseExact(intervalString, format, Nothing, interval)
         Console.WriteLine("'{0}' --> {1}", intervalString, interval)
      Else
         Console.WriteLine("Unable to parse {0}", intervalString)
      End If
      
      ' Parse a single number using the "%s" custom format string. 
      format = "%s"
      If TimeSpan.TryParseExact(intervalString, format, Nothing, interval) Then
         Console.WriteLine("'{0}' --> {1}", intervalString, interval)
      Else
         Console.WriteLine("Unable to parse {0}", intervalString)
      End If
   End Sub
End Module
' The example displays the following output:
'       '17:14' --> 17:14:00
'       Unable to parse 17:14:48
'       Unable to parse 17:14:48.153
'       '3:17:14:48.153' --> 3.17:14:48.1530000
'       Unable to parse 3:17:14:48.153
'       '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 TryParseExact(String, String, IFormatProvider, TimeSpan) -Methode analysiert die Zeichenfolgendarstellung eines Zeitintervalls, das in dem vom Parameter definierten Format vorliegen muss, mit der format Ausnahme, dass führende und nachfolgende Leerzeichen ignoriert werden. Diese Methode ähnelt der Methode, mit dem ParseExact(String, String, IFormatProvider) Unterschied, dass sie keine Ausnahme auslöst, wenn die Konvertierung fehlschlägt.

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-Formatzeichenfolgen und benutzerdefinierte TimeSpan-Formatzeichenfolgen.

Wichtig

Die TryParseExact(String, String, IFormatProvider, TimeSpan) -Methode verwendet die Konventionen der vom formatProvider -Parameter angegebenen Kultur nur, wenn es sich um format eine Standardformatzeichenfolge TimeSpan handelt, 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 es sich um eine Standardformatzeichenfolge handelt. Der formatProvider Parameter kann einer der folgenden Sein:

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

Siehe auch

Gilt für