Udostępnij za pośrednictwem

TimeSpan.TryParseExact Metoda

  • Odwołanie

Definicja

Przestrzeń nazw:
System
Zestaw:
System.Runtime.dll
Zestaw:
netstandard.dll
Zestaw:
mscorlib.dll

Konwertuje reprezentację ciągu interwału czasu na jego TimeSpan odpowiednik i zwraca wartość wskazującą, czy konwersja zakończyła się pomyślnie. Format reprezentacji ciągu musi być dokładnie zgodny z określonym formatem.

Przeciążenia

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

Konwertuje określoną reprezentację przedziału czasu na równoważną TimeSpan przy użyciu określonych formatów, informacji i stylów formatu specyficznego dla kultury. Format reprezentacji ciągu musi być dokładnie zgodny z jednym z określonych formatów.
TryParseExact(String, String, IFormatProvider, TimeSpanStyles, TimeSpan)

Konwertuje reprezentację ciągu interwału czasu na równoważną TimeSpan przy użyciu określonego formatu, informacji i stylów formatu specyficznego dla kultury. Format reprezentacji ciągu musi być dokładnie zgodny z określonym formatem.
TryParseExact(ReadOnlySpan<Char>, ReadOnlySpan<Char>, IFormatProvider, TimeSpanStyles, TimeSpan)

Konwertuje określoną reprezentację przedziału czasu na równoważną TimeSpan przy użyciu określonego formatu, informacji o formacie specyficznym dla kultury i stylów oraz zwraca wartość wskazującą, czy konwersja zakończyła się pomyślnie. Format reprezentacji ciągu musi być dokładnie zgodny z określonym formatem.
TryParseExact(String, String[], IFormatProvider, TimeSpan)

Konwertuje określoną reprezentację ciągu interwału czasu na jego TimeSpan odpowiednik przy użyciu określonych formatów i informacji o formacie specyficznym dla kultury. Format reprezentacji ciągu musi być dokładnie zgodny z jednym z określonych formatów.
TryParseExact(String, String[], IFormatProvider, TimeSpanStyles, TimeSpan)

Konwertuje określoną reprezentację ciągu interwału czasu na jego TimeSpan odpowiednik przy użyciu określonych formatów, informacji i stylów formatu specyficznego dla kultury. Format reprezentacji ciągu musi być dokładnie zgodny z jednym z określonych formatów.
TryParseExact(ReadOnlySpan<Char>, String[], IFormatProvider, TimeSpan)

Konwertuje określoną reprezentację przedziału czasu na równoważną TimeSpan przy użyciu określonych formatów i informacji o formacie specyficznym dla kultury. Format reprezentacji ciągu musi być dokładnie zgodny z jednym z określonych formatów.
TryParseExact(ReadOnlySpan<Char>, ReadOnlySpan<Char>, IFormatProvider, TimeSpan)

Konwertuje określoną reprezentację przedziału czasu na równoważną TimeSpan przy użyciu określonych informacji o formacie i formacie specyficznym dla kultury. Format reprezentacji ciągu musi być dokładnie zgodny z określonym formatem.
TryParseExact(String, String, IFormatProvider, TimeSpan)

Konwertuje reprezentację ciągu interwału czasu na równoważną TimeSpan przy użyciu określonych informacji o formacie i formacie specyficznym dla kultury. Format reprezentacji ciągu musi być dokładnie zgodny z określonym formatem.

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

Źródło:
TimeSpan.cs
Źródło:
TimeSpan.cs
Źródło:
TimeSpan.cs

Konwertuje określoną reprezentację przedziału czasu na równoważną TimeSpan przy użyciu określonych formatów, informacji i stylów formatu specyficznego dla kultury. Format reprezentacji ciągu musi być dokładnie zgodny z jednym z określonych formatów.

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

Parametry

input
ReadOnlySpan<Char>

Zakres zawierający znaki reprezentujące interwał czasu do konwersji.

formats
String[]

Tablica ciągów formatu standardowego lub niestandardowego, które definiują dopuszczalne formaty input.

formatProvider
IFormatProvider

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

styles
TimeSpanStyles

Co najmniej jedna wartość wyliczenia wskazująca styl input.

result
TimeSpan

Gdy ta metoda zwraca, zawiera obiekt reprezentujący interwał czasu określony przez inputlub Zero, jeśli konwersja nie powiodła się. Ten parametr jest przekazywany niezainicjowany.

Zwraca

Boolean

true, jeśli input została pomyślnie przekonwertowana; w przeciwnym razie false.

Dotyczy

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

Źródło:
TimeSpan.cs
Źródło:
TimeSpan.cs
Źródło:
TimeSpan.cs

Konwertuje reprezentację ciągu interwału czasu na równoważną TimeSpan przy użyciu określonego formatu, informacji i stylów formatu specyficznego dla kultury. Format reprezentacji ciągu musi być dokładnie zgodny z określonym formatem.

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

Parametry

input
String

Ciąg określający interwał czasu, który ma być konwertowany.

format
String

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

formatProvider
IFormatProvider

Obiekt, który udostępnia informacje o formatowaniu specyficznym dla kultury.

styles
TimeSpanStyles

Co najmniej jedna wartość wyliczenia wskazująca styl input.

result
TimeSpan

Gdy ta metoda zwraca, zawiera obiekt reprezentujący interwał czasu określony przez inputlub Zero, jeśli konwersja nie powiodła się. Ten parametr jest przekazywany niezainicjowany.

Zwraca

Boolean

true, jeśli input została pomyślnie przekonwertowana; w przeciwnym razie false.

Przykłady

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

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

Uwagi

Metoda TryParseExact(String, String, IFormatProvider, TimeSpanStyles, TimeSpan) analizuje reprezentację ciągu interwału czasu, który musi być w formacie zdefiniowanym przez parametr format, z wyjątkiem tego, że znaki wiodące i końcowe białych znaków są ignorowane. Ta metoda jest podobna do metody ParseExact(String, String, IFormatProvider, TimeSpanStyles), z tą różnicą, że nie zgłasza wyjątku w przypadku niepowodzenia konwersji.

Parametr format jest ciągiem zawierającym jeden standardowy specyfikator formatu lub co najmniej jeden specyfikator formatu niestandardowego definiujący wymagany format input. Aby uzyskać więcej informacji na temat prawidłowych ciągów formatu, zobacz ciągi formatu Standard TimeSpan i niestandardowe ciągi formatu TimeSpan.

Parametr formatProvider to implementacja IFormatProvider, która udostępnia informacje specyficzne dla kultury dotyczące formatu zwracanego ciągu, jeśli format jest standardowym ciągiem formatu. Parametr formatProvider może być dowolny z następujących:

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

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

Zobacz też

Dotyczy

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

Źródło:
TimeSpan.cs
Źródło:
TimeSpan.cs
Źródło:
TimeSpan.cs

Konwertuje określoną reprezentację przedziału czasu na równoważną TimeSpan przy użyciu określonego formatu, informacji o formacie specyficznym dla kultury i stylów oraz zwraca wartość wskazującą, czy konwersja zakończyła się pomyślnie. Format reprezentacji ciągu musi być dokładnie zgodny z określonym formatem.

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

Parametry

input
ReadOnlySpan<Char>

Zakres zawierający znaki reprezentujące interwał czasu do konwersji.

format
ReadOnlySpan<Char>

Zakres zawierający znaki, które reprezentują standardowy lub niestandardowy ciąg formatu, który definiuje akceptowalny format input.

formatProvider
IFormatProvider

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

styles
TimeSpanStyles

Co najmniej jedna wartość wyliczenia wskazująca styl input.

result
TimeSpan

Gdy ta metoda zwraca, zawiera obiekt reprezentujący interwał czasu określony przez inputlub Zero, jeśli konwersja nie powiodła się. Ten parametr jest przekazywany niezainicjowany.

Zwraca

Boolean

true, jeśli input została pomyślnie przekonwertowana; w przeciwnym razie false.

Dotyczy

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

Źródło:
TimeSpan.cs
Źródło:
TimeSpan.cs
Źródło:
TimeSpan.cs

Konwertuje określoną reprezentację ciągu interwału czasu na jego TimeSpan odpowiednik przy użyciu określonych formatów i informacji o formacie specyficznym dla kultury. Format reprezentacji ciągu musi być dokładnie zgodny z jednym z określonych formatów.

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

Parametry

input
String

Ciąg określający interwał czasu, który ma być konwertowany.

formats
String[]

Tablica ciągów formatu standardowego lub niestandardowego, które definiują dopuszczalne formaty input.

formatProvider
IFormatProvider

Obiekt, który udostępnia informacje o formatowaniu specyficznym dla kultury.

result
TimeSpan

Gdy ta metoda zwraca, zawiera obiekt reprezentujący interwał czasu określony przez inputlub Zero, jeśli konwersja nie powiodła się. Ten parametr jest przekazywany niezainicjowany.

Zwraca

Boolean

true, jeśli input została pomyślnie przekonwertowana; w przeciwnym razie false.

Przykłady

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

Ponadto przykład zmienia sposób, w jaki metody analizowania interwału czasu interpretują pojedynczą cyfrę. Zazwyczaj pojedyncza cyfra jest interpretowana jako liczba dni w interwale czasu. Zamiast tego ciąg formatu niestandardowego %h służy do interpretowania pojedynczej cyfry jako liczby godzin. Aby ta zmiana obowiązywała, należy pamiętać, że ciąg formatu niestandardowego %h musi poprzedzać inne ciągi formatu w tablicy formats.

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

Uwagi

Metoda TryParseExact(String, String[], IFormatProvider, TimeSpan) analizuje ciąg reprezentujący interwał czasu, który musi być w formacie zdefiniowanym przez jeden z ciągów formatu określonych przez parametr formats, z wyjątkiem tego, że wiodące i końcowe znaki odstępu są ignorowane. Ta metoda jest podobna do metody ParseExact(String, String[], IFormatProvider), z tą różnicą, że nie zgłasza wyjątku w przypadku niepowodzenia konwersji.

Parametr formats jest tablicą ciągów, której elementy składają się z jednego standardowego specyfikatora formatu lub co najmniej jednego specyfikatora formatu niestandardowego, które definiują wymagany format input. Aby uzyskać więcej informacji na temat prawidłowych ciągów formatu, zobacz ciągi formatu Standard TimeSpan i niestandardowe ciągi formatu TimeSpan. input musi odpowiadać dokładnie członkowi formats, aby operacja analizy powiodła się. Operacja analizowania próbuje dopasować input do każdego elementu w formats począwszy od pierwszego elementu w tablicy.

Ważny

Metoda TryParseExact używa konwencji kultury określonej przez parametr formatProvider tylko wtedy, gdy ciąg formatu używany do analizowania input jest standardowym ciągiem formatu TimeSpan, którego wartość to "g" lub "G". Standardowe ciągi formatu "c", "t" i "T" używają konwencji formatowania niezmiennej kultury. Niestandardowe ciągi formatu definiują dokładny format ciągu wejściowego i używają znaków literałów, aby oddzielić składniki interwału czasu.

Parametr formatProvider to implementacja IFormatProvider, która dostarcza informacje specyficzne dla kultury dotyczące formatu zwracanego ciągu, jeśli ciąg formatu używany do analizowania input jest standardowym ciągiem formatu. Parametr formatProvider może być dowolny z następujących:

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

Zobacz też

Dotyczy

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

Źródło:
TimeSpan.cs
Źródło:
TimeSpan.cs
Źródło:
TimeSpan.cs

Konwertuje określoną reprezentację ciągu interwału czasu na jego TimeSpan odpowiednik przy użyciu określonych formatów, informacji i stylów formatu specyficznego dla kultury. Format reprezentacji ciągu musi być dokładnie zgodny z jednym z określonych formatów.

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

Parametry

input
String

Ciąg określający interwał czasu, który ma być konwertowany.

formats
String[]

Tablica ciągów formatu standardowego lub niestandardowego, które definiują dopuszczalne formaty input.

formatProvider
IFormatProvider

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

styles
TimeSpanStyles

Co najmniej jedna wartość wyliczenia wskazująca styl input.

result
TimeSpan

Gdy ta metoda zwraca, zawiera obiekt reprezentujący interwał czasu określony przez inputlub Zero, jeśli konwersja nie powiodła się. Ten parametr jest przekazywany niezainicjowany.

Zwraca

Boolean

true, jeśli input została pomyślnie przekonwertowana; w przeciwnym razie false.

Przykłady

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

Ponadto przykład zmienia sposób, w jaki metody analizowania interwału czasu interpretują pojedynczą cyfrę. Zazwyczaj pojedyncza cyfra jest interpretowana jako liczba dni w interwale czasu. Zamiast tego ciąg formatu niestandardowego %h służy do interpretowania pojedynczej cyfry jako liczby godzin. Aby ta zmiana obowiązywała, należy pamiętać, że ciąg formatu niestandardowego %h musi poprzedzać inne ciągi formatu w tablicy formats. Zwróć również uwagę na dane wyjściowe, że flaga TimeSpanStyles.AssumeNegative określona w wywołaniu metody jest używana tylko podczas analizowania ciągu za pomocą tego specyfikatora formatu.

using System;
using System.Globalization;

public class Example
{
   public static void Main()
   {
      string[] inputs = { "3", "16:42", "1:6:52:35.0625", 
                          "1:6:52:35,0625" }; 
      string[] formats = { "%h", "g", "G" };
      TimeSpan interval;
      CultureInfo culture = new CultureInfo("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

Uwagi

Metoda TryParseExact(String, String[], IFormatProvider, TimeSpanStyles, TimeSpan) analizuje ciąg reprezentujący interwał czasu, który musi być w formacie zdefiniowanym przez jeden z ciągów formatu określonych przez parametr formats, z wyjątkiem tego, że wiodące i końcowe znaki odstępu są ignorowane. Ta metoda jest podobna do metody ParseExact(String, String[], IFormatProvider, TimeSpanStyles), z tą różnicą, że nie zgłasza wyjątku w przypadku niepowodzenia konwersji.

Parametr formats jest tablicą ciągów, której elementy składają się z jednego standardowego specyfikatora formatu lub co najmniej jednego specyfikatora formatu niestandardowego, które definiują wymagany format input. Aby uzyskać więcej informacji na temat prawidłowych ciągów formatu, zobacz ciągi formatu Standard TimeSpan i niestandardowe ciągi formatu TimeSpan. input musi odpowiadać dokładnie członkowi formats, aby operacja analizy powiodła się. Operacja analizowania próbuje dopasować input do każdego elementu w formats począwszy od pierwszego elementu w tablicy.

Ważny

Metoda ParseExact używa konwencji kultury określonej przez parametr formatProvider tylko wtedy, gdy ciąg formatu używany do analizowania input jest standardowym ciągiem formatu TimeSpan, którego wartość to "g" lub "G". Standardowe ciągi formatu "c", "t" i "T" używają konwencji formatowania niezmiennej kultury. Niestandardowe ciągi formatu definiują dokładny format ciągu wejściowego i używają znaków literałów, aby oddzielić składniki interwału czasu.

Parametr formatProvider to implementacja IFormatProvider, która dostarcza informacje specyficzne dla kultury dotyczące formatu zwracanego ciągu, jeśli ciąg formatu używany do analizowania input jest standardowym ciągiem formatu. Parametr formatProvider może być dowolny z następujących:

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

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

Zobacz też

Dotyczy

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

Źródło:
TimeSpan.cs
Źródło:
TimeSpan.cs
Źródło:
TimeSpan.cs

Konwertuje określoną reprezentację przedziału czasu na równoważną TimeSpan przy użyciu określonych formatów i informacji o formacie specyficznym dla kultury. Format reprezentacji ciągu musi być dokładnie zgodny z jednym z określonych formatów.

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

Parametry

input
ReadOnlySpan<Char>

Zakres zawierający znaki reprezentujące interwał czasu do konwersji.

formats
String[]

Tablica ciągów formatu standardowego lub niestandardowego, które definiują dopuszczalne formaty input.

formatProvider
IFormatProvider

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

result
TimeSpan

Gdy ta metoda zwraca, zawiera obiekt reprezentujący interwał czasu określony przez inputlub Zero, jeśli konwersja nie powiodła się. Ten parametr jest przekazywany niezainicjowany.

Zwraca

Boolean

true, jeśli input została pomyślnie przekonwertowana; w przeciwnym razie false.

Dotyczy

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

Źródło:
TimeSpan.cs
Źródło:
TimeSpan.cs
Źródło:
TimeSpan.cs

Konwertuje określoną reprezentację przedziału czasu na równoważną TimeSpan przy użyciu określonych informacji o formacie i formacie specyficznym dla kultury. Format reprezentacji ciągu musi być dokładnie zgodny z określonym formatem.

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

Parametry

input
ReadOnlySpan<Char>

Zakres zawierający znaki reprezentujące interwał czasu do konwersji.

format
ReadOnlySpan<Char>

Zakres zawierający znaki reprezentujące ciąg formatu standardowego lub niestandardowego, który definiuje akceptowalny format input.

formatProvider
IFormatProvider

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

result
TimeSpan

Gdy ta metoda zwraca, zawiera obiekt reprezentujący interwał czasu określony przez inputlub Zero, jeśli konwersja nie powiodła się. Ten parametr jest przekazywany niezainicjowany.

Zwraca

Boolean

true, jeśli input została pomyślnie przekonwertowana; w przeciwnym razie false.

Dotyczy

TryParseExact(String, String, IFormatProvider, TimeSpan)

Źródło:
TimeSpan.cs
Źródło:
TimeSpan.cs
Źródło:
TimeSpan.cs

Konwertuje reprezentację ciągu interwału czasu na równoważną TimeSpan przy użyciu określonych informacji o formacie i formacie specyficznym dla kultury. Format reprezentacji ciągu musi być dokładnie zgodny z określonym formatem.

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

Parametry

input
String

Ciąg określający interwał czasu, który ma być konwertowany.

format
String

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

formatProvider
IFormatProvider

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

result
TimeSpan

Gdy ta metoda zwraca, zawiera obiekt reprezentujący interwał czasu określony przez inputlub Zero, jeśli konwersja nie powiodła się. Ten parametr jest przekazywany niezainicjowany.

Zwraca

Boolean

true, jeśli input została pomyślnie przekonwertowana; w przeciwnym razie false.

Przykłady

W poniższym przykładzie użyto metody TryParseExact(String, String, IFormatProvider, TimeSpanStyles, TimeSpan), aby przeanalizować kilka reprezentacji ciągów interwałów czasu przy użyciu różnych ciągów formatu i kultur.

using System;
using System.Globalization;

public class Example
{
   public static void Main()
   {
      string intervalString, format;
      TimeSpan interval;
      CultureInfo culture;
      
      // Parse hour:minute value with "g" specifier current culture.
      intervalString = "17:14";
      format = "g";
      culture = CultureInfo.CurrentCulture;
      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

Uwagi

Metoda TryParseExact(String, String, IFormatProvider, TimeSpan) analizuje reprezentację ciągu interwału czasu, który musi być w formacie zdefiniowanym przez parametr format, z wyjątkiem tego, że znaki wiodące i końcowe białych znaków są ignorowane. Ta metoda jest podobna do metody ParseExact(String, String, IFormatProvider), z tą różnicą, że nie zgłasza wyjątku w przypadku niepowodzenia konwersji.

Parametr format jest ciągiem zawierającym jeden standardowy specyfikator formatu lub co najmniej jeden specyfikator formatu niestandardowego definiujący wymagany format input. Aby uzyskać więcej informacji na temat prawidłowych ciągów formatu, zobacz ciągi formatu Standard TimeSpan i niestandardowe ciągi formatu TimeSpan.

Ważny

Metoda TryParseExact(String, String, IFormatProvider, TimeSpan) używa konwencji kultury określonej przez parametr formatProvider tylko wtedy, gdy format jest standardowym ciągiem formatu TimeSpan, którego wartość to "g" lub "G". Standardowe ciągi formatu "c", "t" i "T" używają konwencji formatowania niezmiennej kultury. Niestandardowe ciągi formatu definiują dokładny format ciągu wejściowego i używają znaków literałów, aby oddzielić składniki interwału czasu.

Parametr formatProvider to implementacja IFormatProvider, która udostępnia informacje specyficzne dla kultury dotyczące formatu zwracanego ciągu, jeśli format jest standardowym ciągiem formatu. Parametr formatProvider może być dowolny z następujących:

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

Zobacz też

Dotyczy