TimeSpan.TryParseExact Metoda

Odwołanie

Definicja

Przestrzeń nazw:: System

Zestaw:: System.Runtime.dll

Zestaw:: netstandard.dll

Zestaw:: mscorlib.dll

Ważne

Niektóre informacje odnoszą się do produktu w wersji wstępnej, który może zostać znacząco zmodyfikowany przed wydaniem. Firma Microsoft nie udziela żadnych gwarancji, jawnych lub domniemanych, w odniesieniu do informacji podanych w tym miejscu.

Konwertuje reprezentację ciągu przedziału czasu na odpowiednik TimeSpan i zwraca wartość wskazującą, czy konwersja zakończyła się pomyślnie. Format ciągu reprezentującego musi dokładnie pasować do wskazanego formatu.

Przeciążenia

TryParseExact(ReadOnlySpan<Char>, ReadOnlySpan<Char>, IFormatProvider, TimeSpanStyles, TimeSpan)	Konwertuje określoną reprezentację przedziału czasu na odpowiednik 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 ciągu reprezentującego musi dokładnie pasować do wskazanego formatu.
TryParseExact(String, String, IFormatProvider, TimeSpanStyles, TimeSpan)	Konwertuje reprezentację ciągu interwału czasu na jego TimeSpan odpowiednik przy użyciu określonego formatu, informacji i stylów formatu specyficznego dla kultury. Format ciągu reprezentującego musi dokładnie pasować do wskazanego formatu.
TryParseExact(ReadOnlySpan<Char>, String[], IFormatProvider, TimeSpanStyles, TimeSpan)	Konwertuje określoną reprezentację przedziału czasu na odpowiednik TimeSpan przy użyciu określonych formatów, informacji i stylów formatu specyficznego dla kultury. Format ciągu reprezentującego musi dokładnie pasować do jednego ze wskazanych formatów.
TryParseExact(String, String[], IFormatProvider, TimeSpan)	Konwertuje określoną reprezentację ciągu przedziału czasu na jego TimeSpan odpowiednik przy użyciu określonych formatów i informacji o formacie specyficznym dla kultury. Format ciągu reprezentującego musi dokładnie pasować do jednego ze wskazanych 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 ciągu reprezentującego musi dokładnie pasować do jednego ze wskazanych formatów.
TryParseExact(ReadOnlySpan<Char>, String[], IFormatProvider, TimeSpan)	Konwertuje określoną reprezentację przedziału czasu na równoważne TimeSpan przy użyciu określonych formatów i informacji o formacie specyficznym dla kultury. Format ciągu reprezentującego musi dokładnie pasować do jednego ze wskazanych formatów.
TryParseExact(ReadOnlySpan<Char>, ReadOnlySpan<Char>, IFormatProvider, TimeSpan)	Konwertuje określoną reprezentację przedziału czasu na odpowiednik TimeSpan przy użyciu określonego formatu i informacji o formacie specyficznym dla kultury. Format ciągu reprezentującego musi dokładnie pasować do wskazanego formatu.
TryParseExact(String, String, IFormatProvider, TimeSpan)	Konwertuje reprezentację ciągu przedziału czasu na jego TimeSpan odpowiednik przy użyciu określonego formatu i informacji o formacie specyficznym dla kultury. Format ciągu reprezentującego musi dokładnie pasować do wskazanego formatu.

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

Konwertuje określoną reprezentację przedziału czasu na odpowiednik 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 ciągu reprezentującego musi dokładnie pasować do wskazanego formatu.

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 reprezentujące ciąg formatu standardowego lub niestandardowego, który definiuje akceptowalny format .input

formatProvider: IFormatProvider

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

styles: TimeSpanStyles

Co najmniej jedna wartość wyliczenia wskazująca inputstyl .

result: TimeSpan

Gdy ta metoda zwraca wartość , zawiera obiekt, który reprezentuje interwał czasu określony przez input, lub Zero jeśli konwersja nie powiodła się. Ten parametr jest przekazywany jako niezainicjowany.

Zwraca

Boolean

truejeśli input pomyślnie przekonwertowano; w przeciwnym razie . false

Dotyczy

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

Konwertuje reprezentację ciągu interwału czasu na jego TimeSpan odpowiednik przy użyciu określonego formatu, informacji i stylów formatu specyficznego dla kultury. Format ciągu reprezentującego musi dokładnie pasować do wskazanego formatu.

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 przedział czasu, którą należy przekształcić.

format: String

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

formatProvider: IFormatProvider

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

styles: TimeSpanStyles

Co najmniej jedna wartość wyliczenia wskazująca inputstyl .

result: TimeSpan

Zwraca

Boolean

truejeśli input pomyślnie przekonwertowano; w przeciwnym razie . false

Przykłady

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

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 format parametr, z tą różnicą, że znaki wiodące i końcowe odstępów są ignorowane. Ta metoda jest podobna ParseExact(String, String, IFormatProvider, TimeSpanStyles) do metody , z tą różnicą, że nie zgłasza wyjątku, jeśli konwersja nie powiedzie się.

Parametr format jest ciągiem zawierającym jeden specyfikator formatu standardowego 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 jest implementacją IFormatProvider , która dostarcza informacje specyficzne dla kultury dotyczące formatu zwracanego ciągu, jeśli format jest standardowym ciągiem formatu. Parametr formatProvider może być dowolnym z następujących:

CultureInfo Obiekt reprezentujący kulturę, której konwencje formatowania mają zostać odzwierciedlone w zwracanym ciągu. Obiekt DateTimeFormatInfo zwracany przez CultureInfo.DateTimeFormat właściwość definiuje formatowanie zwracanego ciągu.
DateTimeFormatInfo Obiekt, który definiuje formatowanie zwracanego ciągu.
Obiekt niestandardowy, który implementuje IFormatProvider interfejs. Metoda IFormatProvider.GetFormat zwraca DateTimeFormatInfo obiekt, który dostarcza informacje o formatowaniu.

Jeśli formatProvider parametr ma nullwartość , DateTimeFormatInfo używany jest obiekt 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) lub czy jest zawsze interpretowany jako ujemny interwał czasu (TimeSpanStyles.AssumeNegative). Jeśli TimeSpanStyles.AssumeNegative nie jest używany, format musi zawierać symbol znaku ujemnego literału (np. "\-"), aby pomyślnie przeanalizować ujemny interwał czasu.

Zobacz też

Dotyczy

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

Konwertuje określoną reprezentację przedziału czasu na odpowiednik TimeSpan przy użyciu określonych formatów, informacji i stylów formatu specyficznego dla kultury. Format ciągu reprezentującego musi dokładnie pasować do jednego ze wskazanych 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ą akceptowalne formaty .input

formatProvider: IFormatProvider

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

styles: TimeSpanStyles

Co najmniej jedna wartość wyliczenia wskazująca inputstyl .

result: TimeSpan

Zwraca

Boolean

truejeśli input pomyślnie przekonwertowano; w przeciwnym razie . false

Dotyczy

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

Konwertuje określoną reprezentację ciągu przedziału czasu na jego TimeSpan odpowiednik przy użyciu określonych formatów i informacji o formacie specyficznym dla kultury. Format ciągu reprezentującego musi dokładnie pasować do jednego ze wskazanych 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 przedział czasu, którą należy przekształcić.

formats: String[]

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

formatProvider: IFormatProvider

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

result: TimeSpan

Zwraca

Boolean

truejeśli input pomyślnie przekonwertowano; 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 TimeSpan wartość. W tym przykładzie ciągi są interpretowane przy użyciu konwencji formatowania kultury Francuskiej - Francja ("fr-FR"). Ciągi mogą reprezentować przedział czasu w ogólnym formacie krótkim lub długim.

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 reprezentację ciągu interwału czasu, który musi być w formacie zdefiniowanym przez jeden z ciągów formatu określonych przez formats parametr, z tą różnicą, że znaki wiodące i końcowe białych znaków są ignorowane. Ta metoda jest podobna ParseExact(String, String[], IFormatProvider) do metody , z tą różnicą, że nie zgłasza wyjątku, jeśli konwersja nie powiedzie się.

Parametr formats jest tablicą ciągów, której elementy składają się z jednego specyfikatora formatu standardowego 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 operacji analizy, aby operacja analizy powiodła się. Operacja analizy próbuje dopasować input do każdego elementu, formats zaczynając od pierwszego elementu w tablicy.

Ważne

Metoda TryParseExact używa konwencji kultury określonej przez formatProvider parametr tylko wtedy, gdy ciąg formatu używany do analizowania input jest standardowym TimeSpan ciągiem formatu, którego wartość to "g" lub "G". Standardowe ciągi formatujące „c”, „t” i „T” wykorzystują konwencje formatowania niezmiennej kultury. Niestandardowe ciągi formatujące definiują dokładny format ciągu wejściowego oraz za pomocą znaków literałowych oddzielają składniki przedziału czasu.

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

CultureInfo Obiekt reprezentujący kulturę, której konwencje formatowania mają zostać odzwierciedlone w zwracanym ciągu. Obiekt DateTimeFormatInfo zwracany przez CultureInfo.DateTimeFormat właściwość definiuje formatowanie zwracanego ciągu.
DateTimeFormatInfo Obiekt, który definiuje formatowanie zwracanego ciągu.
Obiekt niestandardowy, który implementuje IFormatProvider interfejs. Metoda IFormatProvider.GetFormat zwraca DateTimeFormatInfo obiekt, który dostarcza informacje o formatowaniu.

Jeśli formatProvider parametr ma nullwartość , DateTimeFormatInfo używany jest obiekt skojarzony z bieżącą kulturą.

Zobacz też

Dotyczy

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 ciągu reprezentującego musi dokładnie pasować do jednego ze wskazanych 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 przedział czasu, którą należy przekształcić.

formats: String[]

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

formatProvider: IFormatProvider

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

styles: TimeSpanStyles

Co najmniej jedna wartość wyliczenia wskazująca inputstyl .

result: TimeSpan

Zwraca

Boolean

truejeśli input pomyślnie przekonwertowano; 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 TimeSpan wartość. Ciągi mogą reprezentować przedział czasu w ogólnym formacie krótkim lub długim.

Ponadto w przykładzie zmienił się sposób, w jaki metody analizy przedziałów czasu interpretują pojedyncze cyfry. Zazwyczaj w odstępie czasu pojedyncza cyfra jest interpretowana jako liczba dni. %h Zamiast tego ciąg formatu niestandardowego służy do interpretowania pojedynczej cyfry jako liczby godzin. Aby ta zmiana obowiązywała, należy pamiętać, że %h ciąg formatu niestandardowego musi poprzedzać inne ciągi formatu w tablicy formats . Zwróć również uwagę na dane wyjściowe, że TimeSpanStyles.AssumeNegative flaga określona w wywołaniu metody jest używana tylko w przypadku 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 reprezentację ciągu interwału czasu, który musi być w formacie zdefiniowanym przez jeden z ciągów formatu określonych przez formats parametr, z tą różnicą, że znaki wiodące i końcowe białych znaków są ignorowane. Ta metoda jest podobna ParseExact(String, String[], IFormatProvider, TimeSpanStyles) do metody , z tą różnicą, że nie zgłasza wyjątku, jeśli konwersja nie powiedzie się.

Ważne

Metoda ParseExact używa konwencji kultury określonej przez formatProvider parametr tylko wtedy, gdy ciąg formatu używany do analizowania input jest standardowym TimeSpan ciągiem formatu, którego wartość to "g" lub "G". Standardowe ciągi formatujące „c”, „t” i „T” wykorzystują konwencje formatowania niezmiennej kultury. Niestandardowe ciągi formatujące definiują dokładny format ciągu wejściowego oraz za pomocą znaków literałowych oddzielają składniki przedziału czasu.

CultureInfo Obiekt reprezentujący kulturę, której konwencje formatowania mają zostać odzwierciedlone w zwracanym ciągu. Obiekt DateTimeFormatInfo zwracany przez CultureInfo.DateTimeFormat właściwość definiuje formatowanie zwracanego ciągu.
DateTimeFormatInfo Obiekt, który definiuje formatowanie zwracanego ciągu.
Obiekt niestandardowy, który implementuje IFormatProvider interfejs. Metoda IFormatProvider.GetFormat zwraca DateTimeFormatInfo obiekt, który udostępnia informacje o formatowaniu.

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

Parametr styles ma wpływ 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 interwał czasu (TimeSpanStyles.AssumeNegative). Jeśli TimeSpanStyles.AssumeNegative nie jest używany, format musi zawierać symbol znaku ujemnego literału (np. "\-"), aby pomyślnie przeanalizować ujemny interwał czasu.

Zobacz też

Dotyczy

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

Konwertuje określoną reprezentację przedziału czasu na równoważne TimeSpan przy użyciu określonych formatów i informacji o formacie specyficznym dla kultury. Format ciągu reprezentującego musi dokładnie pasować do jednego ze wskazanych 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ą akceptowalne formaty .input

formatProvider: IFormatProvider

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

result: TimeSpan

Zwraca

Boolean

truejeśli input pomyślnie przekonwertowano; w przeciwnym razie . false

Dotyczy

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

Konwertuje określoną reprezentację przedziału czasu na odpowiednik TimeSpan przy użyciu określonego formatu i informacji o formacie specyficznym dla kultury. Format ciągu reprezentującego musi dokładnie pasować do wskazanego formatu.

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 inputformat .

formatProvider: IFormatProvider

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

result: TimeSpan

Zwraca

Boolean

truejeśli input pomyślnie przekonwertowano; w przeciwnym razie . false

Dotyczy

TryParseExact(String, String, IFormatProvider, TimeSpan)

Konwertuje reprezentację ciągu przedziału czasu na jego TimeSpan odpowiednik przy użyciu określonego formatu i informacji o formacie specyficznym dla kultury. Format ciągu reprezentującego musi dokładnie pasować do wskazanego formatu.

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 przedział czasu, którą należy przekształcić.

format: String

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

formatProvider: IFormatProvider

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

result: TimeSpan

Zwraca

Boolean

truejeśli input pomyślnie przekonwertowano; w przeciwnym razie . false

Przykłady

W poniższym przykładzie użyto TryParseExact(String, String, IFormatProvider, TimeSpanStyles, TimeSpan) metody , 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 format parametr, z tą różnicą, że znaki wiodące i końcowe odstępów są ignorowane. Ta metoda jest podobna ParseExact(String, String, IFormatProvider) do metody , z tą różnicą, że nie zgłasza wyjątku, jeśli konwersja nie powiedzie się.

Ważne

Metoda TryParseExact(String, String, IFormatProvider, TimeSpan) używa konwencji kultury określonej przez formatProvider parametr tylko wtedy, gdy format jest standardowym TimeSpan ciągiem formatu, którego wartość to "g" lub "G". Standardowe ciągi formatujące „c”, „t” i „T” wykorzystują konwencje formatowania niezmiennej kultury. Niestandardowe ciągi formatujące definiują dokładny format ciągu wejściowego oraz za pomocą znaków literałowych oddzielają składniki przedziału czasu.

CultureInfo Obiekt reprezentujący kulturę, której konwencje formatowania mają zostać odzwierciedlone w zwracanym ciągu. Obiekt DateTimeFormatInfo zwracany przez CultureInfo.DateTimeFormat właściwość definiuje formatowanie zwracanego ciągu.
DateTimeFormatInfo Obiekt, który definiuje formatowanie zwracanego ciągu.
Obiekt niestandardowy, który implementuje IFormatProvider interfejs. Metoda IFormatProvider.GetFormat zwraca DateTimeFormatInfo obiekt, który dostarcza informacje o formatowaniu.

Jeśli formatProvider parametr ma nullwartość , DateTimeFormatInfo używany jest obiekt skojarzony z bieżącą kulturą.

Zobacz też

Dotyczy