TimeSpan.TryParseExact Yöntem

Başvuru

Tanım

Ad Alanı:: System

Bütünleştirilmiş Kod:: System.Runtime.dll

Bütünleştirilmiş Kod:: netstandard.dll

Bütünleştirilmiş Kod:: mscorlib.dll

Önemli

Bazı bilgiler ürünün ön sürümüyle ilgilidir ve sürüm öncesinde önemli değişiklikler yapılmış olabilir. Burada verilen bilgilerle ilgili olarak Microsoft açık veya zımni hiçbir garanti vermez.

Bir zaman aralığının dize gösterimini TimeSpan eşdeğerine dönüştürür ve dönüştürmenin başarılı olup olmadığını gösteren bir değer döndürür. Dize gösteriminin biçimi, belirtilen biçimle tam olarak eşleşmelidir.

Aşırı Yüklemeler

TryParseExact(ReadOnlySpan<Char>, String[], IFormatProvider, TimeSpanStyles, TimeSpan)	Belirli biçimleri, kültüre özgü biçim bilgilerini ve stillerini kullanarak bir zaman aralığının belirtilen span gösterimini TimeSpan eşdeğerine dönüştürür. Dize gösteriminin biçimi, belirtilen biçimlerden biriyle tam olarak eşleşmelidir.
TryParseExact(String, String, IFormatProvider, TimeSpanStyles, TimeSpan)	Belirtilen biçim, kültüre özgü biçim bilgileri ve stilleri kullanarak bir zaman aralığının dize gösterimini TimeSpan eşdeğerine dönüştürür. Dize gösteriminin biçimi, belirtilen biçimle tam olarak eşleşmelidir.
TryParseExact(ReadOnlySpan<Char>, ReadOnlySpan<Char>, IFormatProvider, TimeSpanStyles, TimeSpan)	Belirtilen biçimi, kültüre özgü biçim bilgilerini ve stilleri kullanarak bir zaman aralığının belirtilen span gösterimini TimeSpan eşdeğerine dönüştürür ve dönüştürmenin başarılı olup olmadığını gösteren bir değer döndürür. Dize gösteriminin biçimi, belirtilen biçimle tam olarak eşleşmelidir.
TryParseExact(String, String[], IFormatProvider, TimeSpan)	Belirtilen biçimleri ve kültüre özgü biçim bilgilerini kullanarak bir zaman aralığının belirtilen dize gösterimini TimeSpan eşdeğerine dönüştürür. Dize gösteriminin biçimi, belirtilen biçimlerden biriyle tam olarak eşleşmelidir.
TryParseExact(String, String[], IFormatProvider, TimeSpanStyles, TimeSpan)	Belirli biçimleri, kültüre özgü biçim bilgilerini ve stillerini kullanarak bir zaman aralığının belirtilen dize gösterimini TimeSpan eşdeğerine dönüştürür. Dize gösteriminin biçimi, belirtilen biçimlerden biriyle tam olarak eşleşmelidir.
TryParseExact(ReadOnlySpan<Char>, String[], IFormatProvider, TimeSpan)	Belirtilen biçimleri ve kültüre özgü biçim bilgilerini kullanarak bir zaman aralığının belirtilen yayılma alanı gösterimini TimeSpan eşdeğerine dönüştürür. Dize gösteriminin biçimi, belirtilen biçimlerden biriyle tam olarak eşleşmelidir.
TryParseExact(ReadOnlySpan<Char>, ReadOnlySpan<Char>, IFormatProvider, TimeSpan)	Belirtilen biçim ve kültüre özgü biçim bilgilerini kullanarak bir zaman aralığının belirtilen yayılma alanı gösterimini TimeSpan eşdeğerine dönüştürür. Dize gösteriminin biçimi, belirtilen biçimle tam olarak eşleşmelidir.
TryParseExact(String, String, IFormatProvider, TimeSpan)	Belirtilen biçim ve kültüre özgü biçim bilgilerini kullanarak bir zaman aralığının dize gösterimini TimeSpan eşdeğerine dönüştürür. Dize gösteriminin biçimi, belirtilen biçimle tam olarak eşleşmelidir.

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

Kaynak:: TimeSpan.cs

Kaynak:: TimeSpan.cs

Kaynak:: TimeSpan.cs

Belirli biçimleri, kültüre özgü biçim bilgilerini ve stillerini kullanarak bir zaman aralığının belirtilen span gösterimini TimeSpan eşdeğerine dönüştürür. Dize gösteriminin biçimi, belirtilen biçimlerden biriyle tam olarak eşleşmelidir.

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

Parametreler

input: ReadOnlySpan<Char>

Dönüştürülecek zaman aralığını temsil eden karakterleri içeren bir yayılma alanı.

formats: String[]

inputkabul edilebilir biçimlerini tanımlayan standart veya özel biçim dizeleri dizisi.

formatProvider: IFormatProvider

Kültüre özgü biçimlendirme bilgileri sağlayan bir nesne.

styles: TimeSpanStyles

inputstilini gösteren bir veya daha fazla numaralandırma değeri.

result: TimeSpan

Bu yöntem döndürdüğünde, inputtarafından belirtilen zaman aralığını temsil eden bir nesne içerir veya dönüştürme başarısız olursa Zero. Bu parametre başlatılmamış olarak geçirilir.

Döndürülenler

Boolean

input başarıyla dönüştürüldüyse true; aksi takdirde, false.

Şunlara uygulanır

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

Kaynak:: TimeSpan.cs

Kaynak:: TimeSpan.cs

Kaynak:: TimeSpan.cs

Belirtilen biçim, kültüre özgü biçim bilgileri ve stilleri kullanarak bir zaman aralığının dize gösterimini TimeSpan eşdeğerine dönüştürür. Dize gösteriminin biçimi, belirtilen biçimle tam olarak eşleşmelidir.

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

Parametreler

input: String

Dönüştürülecek zaman aralığını belirten dize.

format: String

gerekli inputbiçimini tanımlayan standart veya özel biçim dizesi.

formatProvider: IFormatProvider

Kültüre özgü biçimlendirme bilgileri sağlayan bir nesne.

styles: TimeSpanStyles

inputstilini gösteren bir veya daha fazla numaralandırma değeri.

result: TimeSpan

Döndürülenler

Boolean

input başarıyla dönüştürüldüyse true; aksi takdirde, false.

Örnekler

Aşağıdaki örnek, çeşitli biçim dizelerini ve kültürlerini kullanarak zaman aralıklarının çeşitli dize gösterimlerini ayrıştırmak için ParseExact(String, String, IFormatProvider) yöntemini kullanır. Ayrıca her dizeyi negatif bir zaman aralığı olarak yorumlamak için TimeSpanStyles.AssumeNegative değerini kullanır. Örnekteki çıktı, TimeSpanStyles.AssumeNegative stilinin yalnızca özel biçim dizeleriyle kullanıldığında dönüş değerini etkilediğini gösterir.

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

Açıklamalar

TryParseExact(String, String, IFormatProvider, TimeSpanStyles, TimeSpan) yöntemi, baştaki ve sondaki boşluk karakterlerinin yoksayılması dışında, format parametresi tarafından tanımlanan biçimde olması gereken bir zaman aralığının dize gösterimini ayrıştırıyor. Bu yöntem, dönüştürme başarısız olursa bir özel durum oluşturmaması dışında ParseExact(String, String, IFormatProvider, TimeSpanStyles) yöntemine benzer.

format parametresi, tek bir standart biçim tanımlayıcısı veya gerekli inputbiçimini tanımlayan bir veya daha fazla özel biçim tanımlayıcısı içeren bir dizedir. Geçerli biçim dizeleri hakkında daha fazla bilgi için bkz. Standart TimeSpan Biçim Dizeleri ve Özel TimeSpan Biçim Dizeleri.

formatProvider parametresi, standart bir biçim dizesi format döndürülen dizenin biçimi hakkında kültüre özgü bilgiler sağlayan bir IFormatProvider uygulamasıdır. formatProvider parametresi aşağıdakilerden biri olabilir:

Biçimlendirme kuralları döndürülen dizeye yansıtılacak olan kültürü temsil eden bir CultureInfo nesnesi. CultureInfo.DateTimeFormat özelliği tarafından döndürülen DateTimeFormatInfo nesnesi, döndürülen dizenin biçimlendirmesini tanımlar.
Döndürülen dizenin biçimlendirmesini tanımlayan bir DateTimeFormatInfo nesnesi.
IFormatProvider arabirimini uygulayan özel bir nesne. IFormatProvider.GetFormat yöntemi, biçimlendirme bilgileri sağlayan bir DateTimeFormatInfo nesnesi döndürür.

formatProvider nullise, geçerli kültürle ilişkili DateTimeFormatInfo nesnesi kullanılır.

styles parametresi, özel biçim dizeleri kullanılarak ayrıştırılan dizelerin yorumlanmasını etkiler. input yalnızca negatif bir işaret varsa (TimeSpanStyles.None) veya her zaman negatif zaman aralığı (TimeSpanStyles.AssumeNegative) olarak yorumlanıp yorumlanmayacağını belirler. TimeSpanStyles.AssumeNegative kullanılmazsa, format negatif bir zaman aralığını başarıyla ayrıştırmak için değişmez negatif işaret simgesi ("\-") içermelidir.

Ayrıca bkz.

Standart TimeSpan Biçim Dizelerini
Özel TimeSpan Biçim Dizelerini

Şunlara uygulanır

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

Kaynak:: TimeSpan.cs

Kaynak:: TimeSpan.cs

Kaynak:: TimeSpan.cs

Belirtilen biçimi, kültüre özgü biçim bilgilerini ve stilleri kullanarak bir zaman aralığının belirtilen span gösterimini TimeSpan eşdeğerine dönüştürür ve dönüştürmenin başarılı olup olmadığını gösteren bir değer döndürür. Dize gösteriminin biçimi, belirtilen biçimle tam olarak eşleşmelidir.

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

Parametreler

input: ReadOnlySpan<Char>

Dönüştürülecek zaman aralığını temsil eden karakterleri içeren bir yayılma alanı.

format: ReadOnlySpan<Char>

inputkabul edilebilir biçimini tanımlayan standart veya özel biçim dizesini temsil eden karakter karakterlerini içeren bir yayılma alanı.

formatProvider: IFormatProvider

Kültüre özgü biçimlendirme bilgileri sağlayan bir nesne.

styles: TimeSpanStyles

inputstilini gösteren bir veya daha fazla numaralandırma değeri.

result: TimeSpan

Döndürülenler

Boolean

input başarıyla dönüştürüldüyse true; aksi takdirde, false.

Şunlara uygulanır

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

Kaynak:: TimeSpan.cs

Kaynak:: TimeSpan.cs

Kaynak:: TimeSpan.cs

Belirtilen biçimleri ve kültüre özgü biçim bilgilerini kullanarak bir zaman aralığının belirtilen dize gösterimini TimeSpan eşdeğerine dönüştürür. Dize gösteriminin biçimi, belirtilen biçimlerden biriyle tam olarak eşleşmelidir.

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

Parametreler

input: String

Dönüştürülecek zaman aralığını belirten dize.

formats: String[]

inputkabul edilebilir biçimlerini tanımlayan standart veya özel biçim dizeleri dizisi.

formatProvider: IFormatProvider

Kültüre özgü biçimlendirme bilgileri sağlayan bir nesne.

result: TimeSpan

Döndürülenler

Boolean

input başarıyla dönüştürüldüyse true; aksi takdirde, false.

Örnekler

Aşağıdaki örnek, bir dize dizisinin her öğesini bir TimeSpan değerine dönüştürmek için TryParseExact(String, String[], IFormatProvider, TimeSpan) yöntemini çağırır. Örnek, Fransızca - Fransa ("fr-FR") kültürünün biçimlendirme kurallarını kullanarak dizeleri yorumlar. Dizeler bir zaman aralığını genel kısa biçimde veya genel uzun biçimde temsil edebilir.

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

Açıklamalar

TryParseExact(String, String[], IFormatProvider, TimeSpan) yöntemi, bir zaman aralığının dize gösterimini ayrıştırarak, baştaki ve sondaki boşluk karakterlerinin yoksayılması dışında, formats parametresi tarafından belirtilen biçim dizelerinden biri tarafından tanımlanan biçimde olması gerekir. Bu yöntem, dönüştürme başarısız olursa bir özel durum oluşturmaması dışında ParseExact(String, String[], IFormatProvider) yöntemine benzer.

formats parametresi, öğeleri tek bir standart biçim belirticiden veya gerekli inputbiçimini tanımlayan bir veya daha fazla özel biçim tanımlayıcıdan oluşan bir dize dizisidir. Geçerli biçim dizeleri hakkında daha fazla bilgi için bkz. Standart TimeSpan Biçim Dizeleri ve Özel TimeSpan Biçim Dizeleri. input ayrıştırma işleminin başarılı olması için tam olarak formats üyesine karşılık gelir. Ayrıştırma işlemi, dizideki ilk öğeden başlayarak inputformats içindeki her öğeyle eşleştirmeyi dener.

Önemli

TryParseExact yöntemi, formatProvider parametresi tarafından belirtilen kültürün kurallarını yalnızca input ayrıştırmak için kullanılan biçim dizesinin değeri "g" veya "G" olan standart bir TimeSpan biçim dizesi olması durumunda kullanır. "c", "t" ve "T" standart biçim dizeleri sabit kültürün biçimlendirme kurallarını kullanır. Özel biçim dizeleri, giriş dizesinin tam biçimini tanımlar ve bir zaman aralığının bileşenlerini ayırmak için değişmez karakterler kullanır.

formatProvider parametresi, input ayrıştırmak için kullanılan biçim dizesi standart bir biçim dizesiyse döndürülen dizenin biçimi hakkında kültüre özgü bilgiler sağlayan bir IFormatProvider uygulamasıdır. formatProvider parametresi aşağıdakilerden biri olabilir:

Biçimlendirme kuralları döndürülen dizeye yansıtılacak olan kültürü temsil eden bir CultureInfo nesnesi. CultureInfo.DateTimeFormat özelliği tarafından döndürülen DateTimeFormatInfo nesnesi, döndürülen dizenin biçimlendirmesini tanımlar.
Döndürülen dizenin biçimlendirmesini tanımlayan bir DateTimeFormatInfo nesnesi.
IFormatProvider arabirimini uygulayan özel bir nesne. IFormatProvider.GetFormat yöntemi, biçimlendirme bilgileri sağlayan bir DateTimeFormatInfo nesnesi döndürür.

formatProvider nullise, geçerli kültürle ilişkili DateTimeFormatInfo nesnesi kullanılır.

Ayrıca bkz.

Standart TimeSpan Biçim Dizelerini
Özel TimeSpan Biçim Dizelerini

Şunlara uygulanır

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

Kaynak:: TimeSpan.cs

Kaynak:: TimeSpan.cs

Kaynak:: TimeSpan.cs

Belirli biçimleri, kültüre özgü biçim bilgilerini ve stillerini kullanarak bir zaman aralığının belirtilen dize gösterimini TimeSpan eşdeğerine dönüştürür. Dize gösteriminin biçimi, belirtilen biçimlerden biriyle tam olarak eşleşmelidir.

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

Parametreler

input: String

Dönüştürülecek zaman aralığını belirten dize.

formats: String[]

inputkabul edilebilir biçimlerini tanımlayan standart veya özel biçim dizeleri dizisi.

formatProvider: IFormatProvider

Kültüre özgü biçimlendirme bilgileri sağlayan bir nesne.

styles: TimeSpanStyles

inputstilini gösteren bir veya daha fazla numaralandırma değeri.

result: TimeSpan

Döndürülenler

Boolean

input başarıyla dönüştürüldüyse true; aksi takdirde, false.

Örnekler

Aşağıdaki örnek, bir dize dizisinin her öğesini bir TimeSpan değerine dönüştürmek için TryParseExact(String, String[], IFormatProvider, TimeSpanStyles, TimeSpan) yöntemini çağırır. Dizeler bir zaman aralığını genel kısa biçimde veya genel uzun biçimde temsil edebilir.

Buna ek olarak, örnek zaman aralığı ayrıştırma yöntemlerinin tek bir basamak yorumlama şeklini değiştirir. Normalde tek bir basamak, bir zaman aralığındaki gün sayısı olarak yorumlanır. Bunun yerine, %h özel biçim dizesi, tek bir basayıyı saat sayısı olarak yorumlamak için kullanılır. Bu değişikliğin etkili olması için, %h özel biçim dizesinin formats dizisindeki diğer biçim dizelerinden önce olması gerektiğini unutmayın. Ayrıca çıkışta, yöntem çağrısında belirtilen TimeSpanStyles.AssumeNegative bayrağının yalnızca bu biçim tanımlayıcısıyla bir dize ayrıştırılırken kullanıldığını unutmayın.

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

Açıklamalar

TryParseExact(String, String[], IFormatProvider, TimeSpanStyles, TimeSpan) yöntemi, bir zaman aralığının dize gösterimini ayrıştırarak, baştaki ve sondaki boşluk karakterlerinin yoksayılması dışında, formats parametresi tarafından belirtilen biçim dizelerinden biri tarafından tanımlanan biçimde olması gerekir. Bu yöntem, dönüştürme başarısız olursa bir özel durum oluşturmaması dışında ParseExact(String, String[], IFormatProvider, TimeSpanStyles) yöntemine benzer.

Önemli

ParseExact yöntemi, formatProvider parametresi tarafından belirtilen kültürün kurallarını yalnızca input ayrıştırmak için kullanılan biçim dizesinin değeri "g" veya "G" olan standart bir TimeSpan biçim dizesi olması durumunda kullanır. "c", "t" ve "T" standart biçim dizeleri sabit kültürün biçimlendirme kurallarını kullanır. Özel biçim dizeleri, giriş dizesinin tam biçimini tanımlar ve bir zaman aralığının bileşenlerini ayırmak için değişmez karakterler kullanır.

Biçimlendirme kuralları döndürülen dizeye yansıtılacak olan kültürü temsil eden bir CultureInfo nesnesi. CultureInfo.DateTimeFormat özelliği tarafından döndürülen DateTimeFormatInfo nesnesi, döndürülen dizenin biçimlendirmesini tanımlar.
Döndürülen dizenin biçimlendirmesini tanımlayan bir DateTimeFormatInfo nesnesi.
IFormatProvider arabirimini uygulayan özel bir nesne. IFormatProvider.GetFormat yöntemi, biçimlendirme bilgileri sağlayan bir DateTimeFormatInfo nesnesi döndürür.

formatProvider nullise, geçerli kültürle ilişkili DateTimeFormatInfo nesnesi kullanılır.

Ayrıca bkz.

Standart TimeSpan Biçim Dizelerini
Özel TimeSpan Biçim Dizelerini

Şunlara uygulanır

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

Kaynak:: TimeSpan.cs

Kaynak:: TimeSpan.cs

Kaynak:: TimeSpan.cs

Belirtilen biçimleri ve kültüre özgü biçim bilgilerini kullanarak bir zaman aralığının belirtilen yayılma alanı gösterimini TimeSpan eşdeğerine dönüştürür. Dize gösteriminin biçimi, belirtilen biçimlerden biriyle tam olarak eşleşmelidir.

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

Parametreler

input: ReadOnlySpan<Char>

Dönüştürülecek zaman aralığını temsil eden karakterleri içeren bir yayılma alanı.

formats: String[]

inputkabul edilebilir biçimlerini tanımlayan standart veya özel biçim dizeleri dizisi.

formatProvider: IFormatProvider

Kültüre özgü biçimlendirme bilgileri sağlayan bir nesne.

result: TimeSpan

Döndürülenler

Boolean

input başarıyla dönüştürüldüyse true; aksi takdirde, false.

Şunlara uygulanır

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

Kaynak:: TimeSpan.cs

Kaynak:: TimeSpan.cs

Kaynak:: TimeSpan.cs

Belirtilen biçim ve kültüre özgü biçim bilgilerini kullanarak bir zaman aralığının belirtilen yayılma alanı gösterimini TimeSpan eşdeğerine dönüştürür. Dize gösteriminin biçimi, belirtilen biçimle tam olarak eşleşmelidir.

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

Parametreler

input: ReadOnlySpan<Char>

Dönüştürülecek zaman aralığını temsil eden karakterleri içeren bir yayılma alanı.

format: ReadOnlySpan<Char>

inputkabul edilebilir biçimini tanımlayan standart veya özel biçim dizesini temsil eden karakterleri içeren bir yayılma alanı.

formatProvider: IFormatProvider

Kültüre özgü biçimlendirme bilgileri sağlayan bir nesne.

result: TimeSpan

Döndürülenler

Boolean

input başarıyla dönüştürüldüyse true; aksi takdirde, false.

Şunlara uygulanır

TryParseExact(String, String, IFormatProvider, TimeSpan)

Kaynak:: TimeSpan.cs

Kaynak:: TimeSpan.cs

Kaynak:: TimeSpan.cs

Belirtilen biçim ve kültüre özgü biçim bilgilerini kullanarak bir zaman aralığının dize gösterimini TimeSpan eşdeğerine dönüştürür. Dize gösteriminin biçimi, belirtilen biçimle tam olarak eşleşmelidir.

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

Parametreler

input: String

Dönüştürülecek zaman aralığını belirten dize.

format: String

gerekli inputbiçimini tanımlayan standart veya özel biçim dizesi.

formatProvider: IFormatProvider

Kültüre özgü biçimlendirme bilgileri sağlayan bir nesne.

result: TimeSpan

Döndürülenler

Boolean

input başarıyla dönüştürüldüyse true; aksi takdirde, false.

Örnekler

Aşağıdaki örnek, çeşitli biçim dizelerini ve kültürlerini kullanarak zaman aralıklarının çeşitli dize gösterimlerini ayrıştırmak için TryParseExact(String, String, IFormatProvider, TimeSpanStyles, TimeSpan) yöntemini kullanır.

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

Açıklamalar

TryParseExact(String, String, IFormatProvider, TimeSpan) yöntemi, baştaki ve sondaki boşluk karakterlerinin yoksayılması dışında, format parametresi tarafından tanımlanan biçimde olması gereken bir zaman aralığının dize gösterimini ayrıştırıyor. Bu yöntem, dönüştürme başarısız olursa bir özel durum oluşturmaması dışında ParseExact(String, String, IFormatProvider) yöntemine benzer.

Önemli

TryParseExact(String, String, IFormatProvider, TimeSpan) yöntemi, formatProvider parametresi tarafından belirtilen kültürün kurallarını yalnızca format değeri "g" veya "G" olan standart bir TimeSpan biçim dizesiyse kullanır. "c", "t" ve "T" standart biçim dizeleri sabit kültürün biçimlendirme kurallarını kullanır. Özel biçim dizeleri, giriş dizesinin tam biçimini tanımlar ve bir zaman aralığının bileşenlerini ayırmak için değişmez karakterler kullanır.

Biçimlendirme kuralları döndürülen dizeye yansıtılacak olan kültürü temsil eden bir CultureInfo nesnesi. CultureInfo.DateTimeFormat özelliği tarafından döndürülen DateTimeFormatInfo nesnesi, döndürülen dizenin biçimlendirmesini tanımlar.
Döndürülen dizenin biçimlendirmesini tanımlayan bir DateTimeFormatInfo nesnesi.
IFormatProvider arabirimini uygulayan özel bir nesne. IFormatProvider.GetFormat yöntemi, biçimlendirme bilgileri sağlayan bir DateTimeFormatInfo nesnesi döndürür.

formatProvider nullise, geçerli kültürle ilişkili DateTimeFormatInfo nesnesi kullanılır.

Ayrıca bkz.

Standart TimeSpan Biçim Dizelerini
Özel TimeSpan Biçim Dizelerini

Şunlara uygulanır

Aracılığıyla paylaş

TimeSpan.TryParseExact Yöntem

Tanım

Aşırı Yüklemeler

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

Parametreler

Döndürülenler

Şunlara uygulanır

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

Parametreler

Döndürülenler

Örnekler

Açıklamalar

Ayrıca bkz.

Şunlara uygulanır

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

Parametreler

Döndürülenler

Şunlara uygulanır

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

Parametreler

Döndürülenler

Örnekler

Açıklamalar

Ayrıca bkz.

Şunlara uygulanır

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

Parametreler

Döndürülenler

Örnekler

Açıklamalar

Ayrıca bkz.

Şunlara uygulanır

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

Parametreler

Döndürülenler

Şunlara uygulanır

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

Parametreler

Döndürülenler

Şunlara uygulanır

TryParseExact(String, String, IFormatProvider, TimeSpan)

Parametreler

Döndürülenler

Örnekler

Açıklamalar

Ayrıca bkz.

Şunlara uygulanır

Ek kaynaklar