TimeSpan.TryParseExact Methode

Definition

Konvertiert die Zeichenfolgendarstellung eines Zeitintervalls in dessen TimeSpan Entsprechung und gibt einen Wert zurück, der angibt, ob die Konvertierung erfolgreich war. Das Format der Zeichenfolgendarstellung muss genau mit einem angegebenen Format übereinstimmen.

Überlädt

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

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

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

Konvertiert die Zeichenfolgendarstellung eines Zeitintervalls in dessen TimeSpan Entsprechung mithilfe des angegebenen Formats, kulturspezifischer Formatinformationen und Formatvorlagen. Das Format der Zeichenfolgendarstellung muss exakt mit dem angegebenen Format übereinstimmen.

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

Konvertiert die angegebene Spannweitendarstellung eines Zeitintervalls in dessen TimeSpan Äquivalent mithilfe der angegebenen Format-, kulturspezifischen Formatinformationen und Formatvorlagen und gibt einen Wert zurück, der angibt, ob die Konvertierung erfolgreich war. Das Format der Zeichenfolgendarstellung muss exakt mit dem angegebenen Format übereinstimmen.

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

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

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

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

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

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

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

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

TryParseExact(String, String, IFormatProvider, TimeSpan)

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.

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

Quelle:
TimeSpan.cs
Quelle:
TimeSpan.cs
Quelle:
TimeSpan.cs

Konvertiert die angegebene Spannweitendarstellung 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 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, die die Zeichen enthält, die ein Zeitintervall darstellen, das konvertiert werden soll.

formats
String[]

Ein Array von Standard- oder benutzerdefinierten Formatzeichenfolgen, die die zulässigen Formate von inputdefinieren.

formatProvider
IFormatProvider

Ein Objekt, das kulturspezifische Formatierungsinformationen bereitstellt.

styles
TimeSpanStyles

Mindestens ein Enumerationswert, der das Format der inputangibt.

result
TimeSpan

Wenn diese Methode zurückgegeben wird, enthält ein Objekt, das das durch inputangegebene Zeitintervall darstellt, oder Zero, wenn die Konvertierung fehlgeschlagen ist. Dieser Parameter wird nicht initialisiert übergeben.

Gibt zurück

true, wenn input erfolgreich konvertiert wurde; andernfalls false.

Gilt für:

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

Quelle:
TimeSpan.cs
Quelle:
TimeSpan.cs
Quelle:
TimeSpan.cs

Konvertiert die Zeichenfolgendarstellung eines Zeitintervalls in dessen TimeSpan Entsprechung mithilfe des angegebenen Formats, kulturspezifischer Formatinformationen und Formatvorlagen. Das Format der Zeichenfolgendarstellung muss exakt mit dem angegebenen Format übereinstimmen.

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

formatProvider
IFormatProvider

Ein Objekt, das kulturspezifische Formatierungsinformationen bereitstellt.

styles
TimeSpanStyles

Mindestens ein Enumerationswert, der das Format der inputangibt.

result
TimeSpan

Wenn diese Methode zurückgegeben wird, enthält ein Objekt, das das durch inputangegebene Zeitintervall darstellt, oder Zero, wenn die Konvertierung fehlgeschlagen ist. Dieser Parameter wird nicht initialisiert übergeben.

Gibt zurück

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 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;
      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 sich im vom parameter format definierten Format befinden muss, außer dass führende und nachfolgende Leerzeichen ignoriert werden. Diese Methode ähnelt der ParseExact(String, String, IFormatProvider, TimeSpanStyles)-Methode, mit der Ausnahme, dass keine Ausnahme ausgelöst wird, 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 Format Strings und Custom TimeSpan Format Strings.

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

Wenn 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:

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

Quelle:
TimeSpan.cs
Quelle:
TimeSpan.cs
Quelle:
TimeSpan.cs

Konvertiert die angegebene Spannweitendarstellung eines Zeitintervalls in dessen TimeSpan Äquivalent mithilfe der angegebenen Format-, kulturspezifischen Formatinformationen und Formatvorlagen und gibt einen Wert zurück, der angibt, ob die Konvertierung erfolgreich war. Das Format der Zeichenfolgendarstellung muss exakt mit dem angegebenen Format übereinstimmen.

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, die die Zeichen enthält, die ein Zeitintervall darstellen, das konvertiert werden soll.

format
ReadOnlySpan<Char>

Eine Spanne mit den Zeichen, die eine Standard- oder benutzerdefinierte Formatzeichenfolge darstellen, die das akzeptable Format von inputdefiniert.

formatProvider
IFormatProvider

Ein Objekt, das kulturspezifische Formatierungsinformationen bereitstellt.

styles
TimeSpanStyles

Mindestens ein Enumerationswert, der das Format der inputangibt.

result
TimeSpan

Wenn diese Methode zurückgegeben wird, enthält ein Objekt, das das durch inputangegebene Zeitintervall darstellt, oder Zero, wenn die Konvertierung fehlgeschlagen ist. Dieser Parameter wird nicht initialisiert übergeben.

Gibt zurück

true, wenn input erfolgreich konvertiert wurde; andernfalls false.

Gilt für:

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

Quelle:
TimeSpan.cs
Quelle:
TimeSpan.cs
Quelle:
TimeSpan.cs

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

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 Standard- oder benutzerdefinierten Formatzeichenfolgen, die die zulässigen Formate von inputdefinieren.

formatProvider
IFormatProvider

Ein Objekt, das kulturspezifische Formatierungsinformationen bereitstellt.

result
TimeSpan

Wenn diese Methode zurückgegeben wird, enthält ein Objekt, das das durch inputangegebene Zeitintervall darstellt, oder Zero, wenn die Konvertierung fehlgeschlagen ist. Dieser Parameter wird nicht initialisiert übergeben.

Gibt zurück

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 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) {
         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 sich im Format befinden muss, das durch eine der vom parameter formats angegebenen Formatzeichenfolgen definiert ist, mit der Ausnahme, dass führende und nachfolgende Leerzeichen ignoriert werden. Diese Methode ähnelt der ParseExact(String, String[], IFormatProvider)-Methode, mit der Ausnahme, dass keine Ausnahme ausgelöst wird, wenn die Konvertierung fehlschlägt.

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 TryParseExact-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:

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

Weitere Informationen

Gilt für:

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

Quelle:
TimeSpan.cs
Quelle:
TimeSpan.cs
Quelle:
TimeSpan.cs

Konvertiert die angegebene 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 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 Standard- oder benutzerdefinierten Formatzeichenfolgen, die die zulässigen Formate von inputdefinieren.

formatProvider
IFormatProvider

Ein Objekt, das kulturspezifische Formatierungsinformationen bereitstellt.

styles
TimeSpanStyles

Mindestens ein Enumerationswert, der das Format der inputangibt.

result
TimeSpan

Wenn diese Methode zurückgegeben wird, enthält ein Objekt, das das durch inputangegebene Zeitintervall darstellt, oder Zero, wenn die Konvertierung fehlgeschlagen ist. Dieser Parameter wird nicht initialisiert übergeben.

Gibt zurück

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 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. Beachten Sie außerdem aus der Ausgabe, dass das im Methodenaufruf angegebene TimeSpanStyles.AssumeNegative 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 im Format befinden muss, das durch eine der vom parameter formats angegebenen Formatzeichenfolgen definiert ist, mit der Ausnahme, dass führende und nachfolgende Leerzeichen ignoriert werden. Diese Methode ähnelt der ParseExact(String, String[], IFormatProvider, TimeSpanStyles)-Methode, mit der Ausnahme, dass keine Ausnahme ausgelöst wird, wenn die Konvertierung fehlschlägt.

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:

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:

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

Quelle:
TimeSpan.cs
Quelle:
TimeSpan.cs
Quelle:
TimeSpan.cs

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

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, die die Zeichen enthält, die ein Zeitintervall darstellen, das konvertiert werden soll.

formats
String[]

Ein Array von Standard- oder benutzerdefinierten Formatzeichenfolgen, die die zulässigen Formate von inputdefinieren.

formatProvider
IFormatProvider

Ein Objekt, das kulturspezifische Formatierungsinformationen bereitstellt.

result
TimeSpan

Wenn diese Methode zurückgegeben wird, enthält ein Objekt, das das durch inputangegebene Zeitintervall darstellt, oder Zero, wenn die Konvertierung fehlgeschlagen ist. Dieser Parameter wird nicht initialisiert übergeben.

Gibt zurück

true, wenn input erfolgreich konvertiert wurde; andernfalls false.

Gilt für:

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

Quelle:
TimeSpan.cs
Quelle:
TimeSpan.cs
Quelle:
TimeSpan.cs

Konvertiert die angegebene Spannweitendarstellung 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 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, die die Zeichen enthält, die ein Zeitintervall darstellen, das konvertiert werden soll.

format
ReadOnlySpan<Char>

Ein Bereich mit den Zeichen, die eine Standard- oder benutzerdefinierte Formatzeichenfolge darstellen, die das akzeptable Format von inputdefiniert.

formatProvider
IFormatProvider

Ein Objekt, das kulturspezifische Formatierungsinformationen bereitstellt.

result
TimeSpan

Wenn diese Methode zurückgegeben wird, enthält ein Objekt, das das durch inputangegebene Zeitintervall darstellt, oder Zero, wenn die Konvertierung fehlgeschlagen ist. Dieser Parameter wird nicht initialisiert übergeben.

Gibt zurück

true, wenn input erfolgreich konvertiert wurde; andernfalls false.

Gilt für:

TryParseExact(String, String, IFormatProvider, TimeSpan)

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

formatProvider
IFormatProvider

Ein Objekt, das kulturspezifische Formatierungsinformationen bereitstellt.

result
TimeSpan

Wenn diese Methode zurückgegeben wird, enthält ein Objekt, das das durch inputangegebene Zeitintervall darstellt, oder Zero, wenn die Konvertierung fehlgeschlagen ist. Dieser Parameter wird nicht initialisiert übergeben.

Gibt zurück

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 mithilfe verschiedener Formatzeichenfolgen und Kulturen zu analysieren.

using System;
using System.Globalization;

public class Example
{
   public static void Main()
   {
      string intervalString, format;
      TimeSpan interval;
      CultureInfo culture;
      
      // Parse hour:minute value with "g" specifier current culture.
      intervalString = "17:14";
      format = "g";
      culture = CultureInfo.CurrentCulture;
      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 sich im vom parameter format definierten Format befinden muss, außer dass führende und nachfolgende Leerzeichen ignoriert werden. Diese Methode ähnelt der ParseExact(String, String, IFormatProvider)-Methode, mit der Ausnahme, dass keine Ausnahme ausgelöst wird, 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 Format Strings und Custom TimeSpan Format Strings.

Wichtig

Die TryParseExact(String, String, IFormatProvider, TimeSpan)-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:

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

Weitere Informationen

Gilt für: