Aracılığıyla paylaş


TimeSpan.ParseExact Yöntem

Tanım

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.

Aşırı Yüklemeler

ParseExact(String, String, IFormatProvider)

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.

ParseExact(String, String[], IFormatProvider)

Belirtilen biçim dizeleri dizisini 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çimlerden biriyle tam olarak eşleşmelidir.

ParseExact(ReadOnlySpan<Char>, ReadOnlySpan<Char>, IFormatProvider, TimeSpanStyles)

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

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

Belirtilen biçimleri, kültüre özgü biçim bilgilerini 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çimlerden biriyle tam olarak eşleşmelidir.

ParseExact(String, String, IFormatProvider, TimeSpanStyles)

Belirtilen biçimi, kültüre özgü biçim bilgilerini 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.

ParseExact(String, String[], IFormatProvider, TimeSpanStyles)

Belirtilen biçimleri, kültüre özgü biçim bilgilerini 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çimlerden biriyle tam olarak eşleşmelidir.

ParseExact(String, String, IFormatProvider)

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 TimeSpan ParseExact(System::String ^ input, System::String ^ format, IFormatProvider ^ formatProvider);
public static TimeSpan ParseExact (string input, string format, IFormatProvider formatProvider);
public static TimeSpan ParseExact (string input, string format, IFormatProvider? formatProvider);
static member ParseExact : string * string * IFormatProvider -> TimeSpan
Public Shared Function ParseExact (input As String, format As String, formatProvider As IFormatProvider) As TimeSpan

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.

Döndürülenler

format ve formatProvidertarafından belirtilen inputkarşılık gelen zaman aralığı.

Özel durumlar

input null.

input geçersiz bir biçime sahip.

input TimeSpan.MinValue veya TimeSpan.MaxValuedeğerinden büyük bir sayıyı temsil eder.

-veya-

input gün, saat, dakika veya saniye bileşenlerinden en az biri geçerli aralığının dışındadır.

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

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;
      try {
         interval = TimeSpan.ParseExact(intervalString, format, culture);
         Console.WriteLine("'{0}' --> {1}", intervalString, interval);
      }
      catch (FormatException) {
         Console.WriteLine("'{0}': Bad Format for '{1}'", 
                           intervalString, format);
      }                     
      catch (OverflowException) {
         Console.WriteLine("'{0}': Overflow", intervalString);
      }      
      
      // Parse hour:minute:second value with "G" specifier.
      intervalString = "17:14:48";
      format = "G";
      culture = CultureInfo.InvariantCulture;
      try {
         interval = TimeSpan.ParseExact(intervalString, format, culture);
         Console.WriteLine("'{0}' --> {1}", intervalString, interval);
      }
      catch (FormatException) {
         Console.WriteLine("'{0}': Bad Format for '{1}'", intervalString, format);
      }   
      catch (OverflowException) {
         Console.WriteLine("'{0}': Overflow", intervalString);
      } 
      
      // Parse hours:minute.second value with "G" specifier 
      // and current (en-US) culture.     
      intervalString = "17:14:48.153";
      format = "G";
      culture = CultureInfo.CurrentCulture;
      try {
         interval = TimeSpan.ParseExact(intervalString, format, culture);
         Console.WriteLine("'{0}' --> {1}", intervalString, interval);
      }   
      catch (FormatException) {
         Console.WriteLine("'{0}': Bad Format for '{1}'", intervalString, format);
      }
      catch (OverflowException) {
         Console.WriteLine("'{0}': Overflow", 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;
      try {
         interval = TimeSpan.ParseExact(intervalString, format, culture);
         Console.WriteLine("'{0}' --> {1}", intervalString, interval);
      }   
      catch (FormatException) {
         Console.WriteLine("'{0}': Bad Format for '{1}'", intervalString, format);
      }   
      catch (OverflowException) {
         Console.WriteLine("'{0}': Overflow", 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");
      try {
         interval = TimeSpan.ParseExact(intervalString, format, culture);
         Console.WriteLine("'{0}' --> {1}", intervalString, interval);
      }
      catch (FormatException) {
         Console.WriteLine("'{0}': Bad Format for '{1}'", intervalString, format);
      }
      catch (OverflowException) {
         Console.WriteLine("'{0}': Overflow", intervalString);
      } 
      
      // Parse days:hours:minute.second value with "G" specifier 
      // and fr-FR culture.     
      intervalString = "3:17:14:48,153";
      format = "G";
      try {
         interval = TimeSpan.ParseExact(intervalString, format, culture);
         Console.WriteLine("'{0}' --> {1}", intervalString, interval);
      }   
      catch (FormatException) {
         Console.WriteLine("'{0}': Bad Format for '{1}'", intervalString, format);
      }
      catch (OverflowException) {
         Console.WriteLine("'{0}': Overflow", intervalString);
      } 

      // Parse a single number using the "c" standard format string. 
      intervalString = "12";
      format = "c";
      try {
         interval = TimeSpan.ParseExact(intervalString, format, null);
         Console.WriteLine("'{0}' --> {1}", intervalString, interval);
      }
      catch (FormatException) {
         Console.WriteLine("'{0}': Bad Format for '{1}'", intervalString, format);
      }
      catch (OverflowException) {
         Console.WriteLine("'{0}': Overflow", intervalString);
      } 
      
      // Parse a single number using the "%h" custom format string. 
      format = "%h";
      try {
         interval = TimeSpan.ParseExact(intervalString, format, null);
         Console.WriteLine("'{0}' --> {1}", intervalString, interval);
      }
      catch (FormatException) {
         Console.WriteLine("'{0}': Bad Format for '{1}'", intervalString, format);
      }
      catch (OverflowException) {
         Console.WriteLine("'{0}': Overflow", intervalString);
      } 
      
      // Parse a single number using the "%s" custom format string. 
      format = "%s";
      try {
         interval = TimeSpan.ParseExact(intervalString, format, null);
         Console.WriteLine("'{0}' --> {1}", intervalString, interval);
      }
      catch (FormatException) {
         Console.WriteLine("'{0}': Bad Format for '{1}'", intervalString, format);
      }
      catch (OverflowException) {
         Console.WriteLine("'{0}': Overflow", intervalString);
      }
   }
}
// The example displays the following output:
//       '17:14' --> 17:14:00
//       '17:14:48': Bad Format for 'G'
//       '17:14:48.153': Bad Format for 'G'
//       '3:17:14:48.153' --> 3.17:14:48.1530000
//       '3:17:14:48.153': Bad Format for 'G'
//       '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
    try
        let interval = TimeSpan.ParseExact(intervalString, format, culture)
        printfn $"'{intervalString}' --> {interval}"
    with 
    | :? FormatException ->
        printfn $"'{intervalString}': Bad Format for '{format}'"
    | :? OverflowException ->
        printfn $"'{intervalString}': Overflow"
    
    // Parse hour:minute:second value with "G" specifier.
    let intervalString = "17:14:48"
    let format = "G"
    let culture = CultureInfo.InvariantCulture
    try
        let interval = TimeSpan.ParseExact(intervalString, format, culture)
        printfn $"'{intervalString}' --> {interval}"
    with
    | :? FormatException ->
        printfn $"'{intervalString}': Bad Format for '{format}'"
    | :? OverflowException ->
        printfn $"'{intervalString}': Overflow"
    
    // 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
    try
        let interval = TimeSpan.ParseExact(intervalString, format, culture)
        printfn $"'{intervalString}' --> {interval}"
    with 
    | :? FormatException ->
        printfn $"'{intervalString}': Bad Format for '{format}'"
    | :? OverflowException ->
        printfn $"'{intervalString}': Overflow"

    // 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
    try
        let interval = TimeSpan.ParseExact(intervalString, format, culture)
        printfn $"'{intervalString}' --> {interval}"
    with 
    | :? FormatException ->
        printfn $"'{intervalString}': Bad Format for '{format}'"
    | :? OverflowException ->
        printfn $"'{intervalString}': Overflow"
        
    // 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 = CultureInfo "fr-FR"
    try
        let interval = TimeSpan.ParseExact(intervalString, format, culture)
        printfn $"'{intervalString}' --> {interval}"
    with 
    | :? FormatException ->
        printfn $"'{intervalString}': Bad Format for '{format}'"
    | :? OverflowException ->
        printfn $"'{intervalString}': Overflow"
    
    // Parse days:hours:minute.second value with "G" specifier 
    // and fr-FR culture.     
    let intervalString = "3:17:14:48,153"
    let format = "G"
    try
        let interval = TimeSpan.ParseExact(intervalString, format, culture)
        printfn $"'{intervalString}' --> {interval}"
    with 
    | :? FormatException ->
        printfn $"'{intervalString}': Bad Format for '{format}'"
    | :? OverflowException ->
        printfn $"'{intervalString}': Overflow"

    // Parse a single number using the "c" standard format string. 
    let intervalString = "12"
    let format = "c"
    try
        let interval = TimeSpan.ParseExact(intervalString, format, null)
        printfn $"'{intervalString}' --> {interval}"
    with
    | :? FormatException ->
        printfn $"'{intervalString}': Bad Format for '{format}'"
    | :? OverflowException ->
        printfn $"'{intervalString}': Overflow"
    
    // Parse a single number using the "%h" custom format string. 
    let format = "%h"
    try
        let interval = TimeSpan.ParseExact(intervalString, format, null)
        printfn $"'{intervalString}' --> {interval}"
    with 
    | :? FormatException ->
        printfn $"'{intervalString}': Bad Format for '{format}'"
    | :? OverflowException ->
        printfn $"'{intervalString}': Overflow"
    
    // Parse a single number using the "%s" custom format string. 
    let format = "%s"
    try
        let interval = TimeSpan.ParseExact(intervalString, format, null)
        printfn $"'{intervalString}' --> {interval}"
    with 
    | :? FormatException ->
        printfn $"'{intervalString}': Bad Format for '{format}'"
    | :? OverflowException ->
        printfn $"'{intervalString}': Overflow"
// The example displays the following output:
//       '17:14' --> 17:14:00
//       '17:14:48': Bad Format for 'G'
//       '17:14:48.153': Bad Format for 'G'
//       '3:17:14:48.153' --> 3.17:14:48.1530000
//       '3:17:14:48.153': Bad Format for 'G'
//       '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
      Try
         interval = TimeSpan.ParseExact(intervalString, format, culture)
         Console.WriteLine("'{0}' --> {1}", intervalString, interval)
      Catch e As FormatException
         Console.WriteLine("'{0}': Bad Format for '{1}'", intervalString, format)
      Catch e As OverflowException
         Console.WriteLine("'{0}': Overflow", intervalString)
      End Try      
      
      ' Parse hour:minute:second value with "G" specifier.
      intervalString = "17:14:48"
      format = "G"
      culture = CultureInfo.InvariantCulture
      Try
         interval = TimeSpan.ParseExact(intervalString, format, culture)
         Console.WriteLine("'{0}' --> {1}", intervalString, interval)
      Catch e As FormatException
         Console.WriteLine("'{0}': Bad Format for '{1}'", intervalString, format)
      Catch e As OverflowException
         Console.WriteLine("'{0}': Overflow", intervalString)
      End Try 
      
      ' Parse hours:minute.second value with "G" specifier 
      ' and current (en-US) culture.     
      intervalString = "17:14:48.153"
      format = "G"
      culture = CultureInfo.CurrentCulture
      Try
         interval = TimeSpan.ParseExact(intervalString, format, culture)
         Console.WriteLine("'{0}' --> {1}", intervalString, interval)
      Catch e As FormatException
         Console.WriteLine("'{0}': Bad Format for '{1}'", intervalString, format)
      Catch e As OverflowException
         Console.WriteLine("'{0}': Overflow", intervalString)
      End Try 

      ' 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
      Try
         interval = TimeSpan.ParseExact(intervalString, format, culture)
         Console.WriteLine("'{0}' --> {1}", intervalString, interval)
      Catch e As FormatException
         Console.WriteLine("'{0}': Bad Format for '{1}'", intervalString, format)
      Catch e As OverflowException
         Console.WriteLine("'{0}': Overflow", intervalString)
      End Try 
            
      ' 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")
      Try
         interval = TimeSpan.ParseExact(intervalString, format, culture)
         Console.WriteLine("'{0}' --> {1}", intervalString, interval)
      Catch e As FormatException
         Console.WriteLine("'{0}': Bad Format for '{1}'", intervalString, format)
      Catch e As OverflowException
         Console.WriteLine("'{0}': Overflow", intervalString)
      End Try 
      
      ' 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")
      Try
         interval = TimeSpan.ParseExact(intervalString, format, culture)
         Console.WriteLine("'{0}' --> {1}", intervalString, interval)
      Catch e As FormatException
         Console.WriteLine("'{0}': Bad Format for '{1}'", intervalString, format)
      Catch e As OverflowException
         Console.WriteLine("'{0}': Overflow", intervalString)
      End Try 

      ' Parse a single number using the "c" standard format string. 
      intervalString = "12"
      format = "c"
      Try
         interval = TimeSpan.ParseExact(intervalString, format, Nothing)
         Console.WriteLine("'{0}' --> {1}", intervalString, interval)
      Catch e As FormatException
         Console.WriteLine("'{0}': Bad Format for '{1}'", intervalString, format)
      Catch e As OverflowException
         Console.WriteLine("'{0}': Overflow", intervalString)
      End Try 
      
      ' Parse a single number using the "%h" custom format string. 
      format = "%h"
      Try
         interval = TimeSpan.ParseExact(intervalString, format, Nothing)
         Console.WriteLine("'{0}' --> {1}", intervalString, interval)
      Catch e As FormatException
         Console.WriteLine("'{0}': Bad Format for '{1}'", intervalString, format)
      Catch e As OverflowException
         Console.WriteLine("'{0}': Overflow", intervalString)
      End Try 
      
      ' Parse a single number using the "%s" custom format string. 
      format = "%s"
      Try
         interval = TimeSpan.ParseExact(intervalString, format, Nothing)
         Console.WriteLine("'{0}' --> {1}", intervalString, interval)
      Catch e As FormatException
         Console.WriteLine("'{0}': Bad Format for '{1}'", intervalString, format)
      Catch e As OverflowException
         Console.WriteLine("'{0}': Overflow", intervalString)
      End Try 
   End Sub
End Module
' The example displays the following output:
'       '17:14' --> 17:14:00
'       '17:14:48': Bad Format for 'G'
'       '17:14:48.153': Bad Format for 'G'
'       '3:17:14:48.153' --> 3.17:14:48.1530000
'       '3:17:14:48.153': Bad Format for 'G'
'       '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

ParseExact(String, String, IFormatProvider) 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. input format biçimine tam olarak uyması gerektiğinden, kullanıcı tarafından bir dize girişini zaman aralığına dönüştürürken her zaman özel durum işlemeyi kullanmalısınız. Özel durum işlemeyi kullanmamak isterseniz bunun yerine TryParseExact(String, String, IFormatProvider, TimeSpan) yöntemini çağırabilirsiniz.

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.

Önemli

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

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:

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

ParseExact(String, String[], IFormatProvider)

Kaynak:
TimeSpan.cs
Kaynak:
TimeSpan.cs
Kaynak:
TimeSpan.cs

Belirtilen biçim dizeleri dizisini 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çimlerden biriyle tam olarak eşleşmelidir.

public:
 static TimeSpan ParseExact(System::String ^ input, cli::array <System::String ^> ^ formats, IFormatProvider ^ formatProvider);
public static TimeSpan ParseExact (string input, string[] formats, IFormatProvider formatProvider);
public static TimeSpan ParseExact (string input, string[] formats, IFormatProvider? formatProvider);
static member ParseExact : string * string[] * IFormatProvider -> TimeSpan
Public Shared Function ParseExact (input As String, formats As String(), formatProvider As IFormatProvider) As TimeSpan

Parametreler

input
String

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

formats
String[]

gerekli inputbiçimini tanımlayan standart veya özel biçim dizelerinden oluşan bir dizi.

formatProvider
IFormatProvider

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

Döndürülenler

formats ve formatProvidertarafından belirtilen inputkarşılık gelen zaman aralığı.

Özel durumlar

input null.

input geçersiz bir biçime sahip.

input TimeSpan.MinValue veya TimeSpan.MaxValuedeğerinden büyük bir sayıyı temsil eder.

-veya-

input gün, saat, dakika veya saniye bileşenlerinden en az biri geçerli aralığının dışındadır.

Örnekler

Aşağıdaki örnek, bir dize dizisinin her öğesini bir TimeSpan değerine dönüştürmek için ParseExact(String, String[], IFormatProvider) 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.

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.

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) {
         try {
            interval = TimeSpan.ParseExact(input, formats, culture);
            Console.WriteLine("{0} --> {1:c}", input, interval);
         }
         catch (FormatException) {
            Console.WriteLine("{0} --> Bad Format", input);
         }      
         catch (OverflowException) {
            Console.WriteLine("{0} --> Overflow", input);   
         }            
      }
   }
}
// The example displays the following output:
//       3 --> 03:00:00
//       16:42 --> 16:42:00
//       1:6:52:35.0625 --> Bad Format
//       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
    try
        let interval = TimeSpan.ParseExact(input, formats, culture)
        printfn $"{input} --> {interval:c}"
    with
    | :? FormatException ->
        printfn $"{input} --> Bad Format"
    | :? OverflowException ->
        printfn $"{input} --> Overflow"
// The example displays the following output:
//       3 --> 03:00:00
//       16:42 --> 16:42:00
//       1:6:52:35.0625 --> Bad Format
//       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
         Try
            interval = TimeSpan.ParseExact(input, formats, culture)
            Console.WriteLine("{0} --> {1:c}", input, interval)   
         Catch e As FormatException
            Console.WriteLine("{0} --> Bad Format", input)   
         Catch e As OverflowException
            Console.WriteLine("{0} --> Overflow", input)   
         End Try            
      Next
   End Sub
End Module
' The example displays the following output:
'       3 --> 3.00:00:00
'       16:42 --> 16:42:00
'       1:6:52:35.0625 --> Bad Format
'       1:6:52:35,0625 --> 1.06:52:35.0625000

Açıklamalar

ParseExact(String, String, IFormatProvider) yöntemi, formats parametresi tarafından tanımlanan biçimlerden birinde olması gereken bir zaman aralığının dize gösterimini ayrıştırırken, baştaki ve sondaki boşluk karakterleri yoksayılır. input formatsbelirtilen biçimlerden birine tam olarak uyması gerektiğinden, kullanıcı tarafından bir dize girişini zaman aralığına dönüştürürken her zaman özel durum işlemeyi kullanmalısınız. Özel durum işlemeyi kullanmamak isterseniz bunun yerine TryParseExact(String, String[], IFormatProvider, TimeSpan) yöntemini çağırabilirsiniz.

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

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.

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:

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

Ayrıca bkz.

Şunlara uygulanır

ParseExact(ReadOnlySpan<Char>, ReadOnlySpan<Char>, IFormatProvider, TimeSpanStyles)

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 karakter aralığını TimeSpan eşdeğerine dönüştürür. Dize gösteriminin biçimi, belirtilen biçimle tam olarak eşleşmelidir.

public static TimeSpan ParseExact (ReadOnlySpan<char> input, ReadOnlySpan<char> format, IFormatProvider? formatProvider, System.Globalization.TimeSpanStyles styles = System.Globalization.TimeSpanStyles.None);
public static TimeSpan ParseExact (ReadOnlySpan<char> input, ReadOnlySpan<char> format, IFormatProvider formatProvider, System.Globalization.TimeSpanStyles styles = System.Globalization.TimeSpanStyles.None);
static member ParseExact : ReadOnlySpan<char> * ReadOnlySpan<char> * IFormatProvider * System.Globalization.TimeSpanStyles -> TimeSpan
Public Shared Function ParseExact (input As ReadOnlySpan(Of Char), format As ReadOnlySpan(Of Char), formatProvider As IFormatProvider, Optional styles As TimeSpanStyles = System.Globalization.TimeSpanStyles.None) As TimeSpan

Parametreler

input
ReadOnlySpan<Char>

Dönüştürülecek zaman aralığını belirten bir yayılma alanı.

format
ReadOnlySpan<Char>

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

inputiçinde bulunabilecek stil öğelerini tanımlayan sabit listesi değerlerinin bit düzeyinde birleşimi.

Döndürülenler

format ve formatProvidertarafından belirtilen inputkarşılık gelen zaman aralığı.

Şunlara uygulanır

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

Kaynak:
TimeSpan.cs
Kaynak:
TimeSpan.cs
Kaynak:
TimeSpan.cs

Belirtilen biçimleri, kültüre özgü biçim bilgilerini 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çimlerden biriyle tam olarak eşleşmelidir.

public static TimeSpan ParseExact (ReadOnlySpan<char> input, string[] formats, IFormatProvider? formatProvider, System.Globalization.TimeSpanStyles styles = System.Globalization.TimeSpanStyles.None);
public static TimeSpan ParseExact (ReadOnlySpan<char> input, string[] formats, IFormatProvider formatProvider, System.Globalization.TimeSpanStyles styles = System.Globalization.TimeSpanStyles.None);
static member ParseExact : ReadOnlySpan<char> * string[] * IFormatProvider * System.Globalization.TimeSpanStyles -> TimeSpan
Public Shared Function ParseExact (input As ReadOnlySpan(Of Char), formats As String(), formatProvider As IFormatProvider, Optional styles As TimeSpanStyles = System.Globalization.TimeSpanStyles.None) As TimeSpan

Parametreler

input
ReadOnlySpan<Char>

Dönüştürülecek zaman aralığını belirten bir yayılma alanı.

formats
String[]

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

formatProvider
IFormatProvider

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

styles
TimeSpanStyles

Girişte bulunabilecek stil öğelerini tanımlayan sabit listesi değerlerinin bit düzeyinde birleşimi.

Döndürülenler

formats, formatProviderve stylestarafından belirtilen inputkarşılık gelen zaman aralığı.

Şunlara uygulanır

ParseExact(String, String, IFormatProvider, TimeSpanStyles)

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 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 TimeSpan ParseExact(System::String ^ input, System::String ^ format, IFormatProvider ^ formatProvider, System::Globalization::TimeSpanStyles styles);
public static TimeSpan ParseExact (string input, string format, IFormatProvider formatProvider, System.Globalization.TimeSpanStyles styles);
public static TimeSpan ParseExact (string input, string format, IFormatProvider? formatProvider, System.Globalization.TimeSpanStyles styles);
static member ParseExact : string * string * IFormatProvider * System.Globalization.TimeSpanStyles -> TimeSpan
Public Shared Function ParseExact (input As String, format As String, formatProvider As IFormatProvider, styles As TimeSpanStyles) As TimeSpan

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

inputiçinde bulunabilecek stil öğelerini tanımlayan sabit listesi değerlerinin bit düzeyinde birleşimi.

Döndürülenler

format, formatProviderve stylestarafından belirtilen inputkarşılık gelen zaman aralığı.

Özel durumlar

styles geçersiz bir TimeSpanStyles değeridir.

input null.

input geçersiz bir biçime sahip.

input TimeSpan.MinValue veya TimeSpan.MaxValuedeğerinden büyük bir sayıyı temsil eder.

-veya-

input gün, saat, dakika veya saniye bileşenlerinden en az biri geçerli aralığının dışındadır.

Ö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;
      try {
         interval = TimeSpan.ParseExact(intervalString, format, 
                                        culture, TimeSpanStyles.AssumeNegative);
         Console.WriteLine("'{0}' ({1}) --> {2}", intervalString, format, interval);
      }   
      catch (FormatException) {
         Console.WriteLine("'{0}': Bad Format for '{1}'", intervalString, format);
      }   
      catch (OverflowException) {
         Console.WriteLine("'{0}': Overflow", intervalString);
      }      
      
      // Parse hour:minute:second value with "g" specifier.
      intervalString = "17:14:48";
      format = "g";
      culture = CultureInfo.InvariantCulture;
      try {
         interval = TimeSpan.ParseExact(intervalString, format, 
                                        culture, TimeSpanStyles.AssumeNegative);
         Console.WriteLine("'{0}' ({1}) --> {2}", intervalString, format, interval);
      }
      catch (FormatException) {
         Console.WriteLine("'{0}': Bad Format for '{1}'", intervalString, format);
      }   
      catch (OverflowException) {
         Console.WriteLine("'{0}': Overflow", intervalString);
      } 
      
      // Parse hours:minute.second value with custom format specifier.     
      intervalString = "17:14:48.153";
      format = @"h\:mm\:ss\.fff";
      culture = null;
      try {
         interval = TimeSpan.ParseExact(intervalString, format, 
                                        culture, TimeSpanStyles.AssumeNegative);
         Console.WriteLine("'{0}' ({1}) --> {2}", intervalString, format, interval);
      }
      catch (FormatException) {
         Console.WriteLine("'{0}': Bad Format for '{1}'", intervalString, format);
      }   
      catch (OverflowException) {
         Console.WriteLine("'{0}': Overflow", 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;
      try {
         interval = TimeSpan.ParseExact(intervalString, format, 
                                        culture, TimeSpanStyles.AssumeNegative);
         Console.WriteLine("'{0}' ({1}) --> {2}", intervalString, format, interval);
      }   
      catch (FormatException) {
         Console.WriteLine("'{0}': Bad Format for '{1}'", intervalString, format);
      }
      catch (OverflowException) {
         Console.WriteLine("'{0}': Overflow", intervalString);
      } 
            
      // 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;
      try {
         interval = TimeSpan.ParseExact(intervalString, format, 
                                        culture, TimeSpanStyles.AssumeNegative);
         Console.WriteLine("'{0}' ({1}) --> {2}", intervalString, format, interval);
      }   
      catch (FormatException) {
         Console.WriteLine("'{0}': Bad Format for '{1}'", intervalString, format);
      }   
      catch (OverflowException) {
         Console.WriteLine("'{0}': Overflow", 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");
      try {
         interval = TimeSpan.ParseExact(intervalString, format, 
                                        culture, TimeSpanStyles.AssumeNegative);
         Console.WriteLine("'{0}' ({1}) --> {2}", intervalString, format, interval);
      }   
      catch (FormatException) {
         Console.WriteLine("'{0}': Bad Format for '{1}'", intervalString, format);
      }   
      catch (OverflowException) {
         Console.WriteLine("'{0}': Overflow", intervalString);
      } 

      // Parse a single number using the "c" standard format string. 
      intervalString = "12";
      format = "c";
      try {
         interval = TimeSpan.ParseExact(intervalString, format, 
                                        null, TimeSpanStyles.AssumeNegative);
         Console.WriteLine("'{0}' ({1}) --> {2}", intervalString, format, interval);
      }   
      catch (FormatException) {
         Console.WriteLine("'{0}': Bad Format for '{1}'", intervalString, format);
      }   
      catch (OverflowException) {
         Console.WriteLine("'{0}': Overflow", intervalString);
      } 
      
      // Parse a single number using the "%h" custom format string. 
      format = "%h";
      try {
         interval = TimeSpan.ParseExact(intervalString, format, 
                                        null, TimeSpanStyles.AssumeNegative);
         Console.WriteLine("'{0}' ({1}) --> {2}", intervalString, format, interval);
      }   
      catch (FormatException) {
         Console.WriteLine("'{0}': Bad Format for '{1}'", intervalString, format);
      }   
      catch (OverflowException) {
         Console.WriteLine("'{0}': Overflow", intervalString);
      } 
      
      // Parse a single number using the "%s" custom format string. 
      format = "%s";
      try {
         interval = TimeSpan.ParseExact(intervalString, format, 
                                        null, TimeSpanStyles.AssumeNegative);
         Console.WriteLine("'{0}' ({1}) --> {2}", intervalString, format, interval);
      }   
      catch (FormatException) {
         Console.WriteLine("'{0}': Bad Format for '{1}'", intervalString, format);
      }   
      catch (OverflowException) {
         Console.WriteLine("'{0}': Overflow", intervalString);
      } 
   }
}
// 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
    try
        let interval = TimeSpan.ParseExact(intervalString, format, culture, TimeSpanStyles.AssumeNegative)
        printfn $"'{intervalString}' ({format}) --> {interval}"
    with 
    | :? FormatException ->
        printfn $"'{intervalString}': Bad Format for '{format}'"
    | :? OverflowException ->
        printfn $"'{intervalString}': Overflow"
    
    // Parse hour:minute:second value with "g" specifier.
    let intervalString = "17:14:48"
    let format = "g"
    let culture = CultureInfo.InvariantCulture
    try
        let interval = TimeSpan.ParseExact(intervalString, format, culture, TimeSpanStyles.AssumeNegative)
        printfn $"'{intervalString}' ({format}) --> {interval}"
    with 
    | :? FormatException ->
        printfn $"'{intervalString}': Bad Format for '{format}'"
    | :? OverflowException ->
        printfn $"'{intervalString}': Overflow"
    
    // Parse hours:minute.second value with custom format specifier.     
    let intervalString = "17:14:48.153"
    let format = @"h\:mm\:ss\.fff"
    let culture = null
    try
        let interval = TimeSpan.ParseExact(intervalString, format, culture, TimeSpanStyles.AssumeNegative)
        printfn $"'{intervalString}' ({format}) --> {interval}"
    with 
    | :? FormatException ->
        printfn $"'{intervalString}': Bad Format for '{format}'"
    | :? OverflowException ->
        printfn $"'{intervalString}': Overflow"

    // 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
    try
        let interval = TimeSpan.ParseExact(intervalString, format, culture, TimeSpanStyles.AssumeNegative)
        printfn $"'{intervalString}' ({format}) --> {interval}"
    with 
    | :? FormatException ->
        printfn $"'{intervalString}': Bad Format for '{format}'"
    | :? OverflowException ->
        printfn $"'{intervalString}': Overflow"
        
    // 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
    try
        let interval = TimeSpan.ParseExact(intervalString, format, culture, TimeSpanStyles.AssumeNegative)
        printfn $"'{intervalString}' ({format}) --> {interval}"
    with 
    | :? FormatException ->
        printfn $"'{intervalString}': Bad Format for '{format}'"
    | :? OverflowException ->
        printfn $"'{intervalString}': Overflow"
    
    // 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")
    try
        let interval = TimeSpan.ParseExact(intervalString, format, culture, TimeSpanStyles.AssumeNegative)
        printfn $"'{intervalString}' ({format}) --> {interval}"
    with 
    | :? FormatException ->
        printfn $"'{intervalString}': Bad Format for '{format}'"
    | :? OverflowException ->
        printfn $"'{intervalString}': Overflow"

    // Parse a single number using the "c" standard format string. 
    let intervalString = "12"
    let format = "c"
    try
        let interval = TimeSpan.ParseExact(intervalString, format, null, TimeSpanStyles.AssumeNegative)
        printfn $"'{intervalString}' ({format}) --> {interval}"
    with 
    | :? FormatException ->
        printfn $"'{intervalString}': Bad Format for '{format}'"
    | :? OverflowException ->
        printfn $"'{intervalString}': Overflow"
    
    // Parse a single number using the "%h" custom format string. 
    let format = "%h"
    try
        let interval = TimeSpan.ParseExact(intervalString, format, null, TimeSpanStyles.AssumeNegative)
        printfn $"'{intervalString}' ({format}) --> {interval}"
    with 
    | :? FormatException ->
        printfn $"'{intervalString}': Bad Format for '{format}'"
    | :? OverflowException ->
        printfn $"'{intervalString}': Overflow"
    
    // Parse a single number using the "%s" custom format string. 
    let format = "%s"
    try
        let interval = TimeSpan.ParseExact(intervalString, format, null, TimeSpanStyles.AssumeNegative)
        printfn $"'{intervalString}' ({format}) --> {interval}"
    with 
    | :? FormatException ->
        printfn $"'{intervalString}': Bad Format for '{format}'"
    | :? OverflowException ->
        printfn $"'{intervalString}': Overflow"
// 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
      Try
         interval = TimeSpan.ParseExact(intervalString, format, 
                                        culture, TimeSpanStyles.AssumeNegative)
         Console.WriteLine("'{0}' ({1}) --> {2}", intervalString, format, interval)
      Catch e As FormatException
         Console.WriteLine("'{0}': Bad Format for '{1}'", intervalString, format)
      Catch e As OverflowException
         Console.WriteLine("'{0}': Overflow", intervalString)
      End Try      
      
      ' Parse hour:minute:second value with "g" specifier.
      intervalString = "17:14:48"
      format = "g"
      culture = CultureInfo.InvariantCulture
      Try
         interval = TimeSpan.ParseExact(intervalString, format, 
                                        culture, TimeSpanStyles.AssumeNegative)
         Console.WriteLine("'{0}' ({1}) --> {2}", intervalString, format, interval)
      Catch e As FormatException
         Console.WriteLine("'{0}': Bad Format for '{1}'", intervalString, format)
      Catch e As OverflowException
         Console.WriteLine("'{0}': Overflow", intervalString)
      End Try 
      
      ' Parse hours:minute.second value with custom format specifier.     
      intervalString = "17:14:48.153"
      format = "h\:mm\:ss\.fff"
      culture = Nothing
      Try
         interval = TimeSpan.ParseExact(intervalString, format, 
                                        culture, TimeSpanStyles.AssumeNegative)
         Console.WriteLine("'{0}' ({1}) --> {2}", intervalString, format, interval)
      Catch e As FormatException
         Console.WriteLine("'{0}': Bad Format for '{1}'", intervalString, format)
      Catch e As OverflowException
         Console.WriteLine("'{0}': Overflow", intervalString)
      End Try 

      ' 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
      Try
         interval = TimeSpan.ParseExact(intervalString, format, 
                                        culture, TimeSpanStyles.AssumeNegative)
         Console.WriteLine("'{0}' ({1}) --> {2}", intervalString, format, interval)
      Catch e As FormatException
         Console.WriteLine("'{0}': Bad Format for '{1}'", intervalString, format)
      Catch e As OverflowException
         Console.WriteLine("'{0}': Overflow", intervalString)
      End Try 
            
      ' 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
      Try
         interval = TimeSpan.ParseExact(intervalString, format, 
                                        culture, TimeSpanStyles.AssumeNegative)
         Console.WriteLine("'{0}' ({1}) --> {2}", intervalString, format, interval)
      Catch e As FormatException
         Console.WriteLine("'{0}': Bad Format for '{1}'", intervalString, format)
      Catch e As OverflowException
         Console.WriteLine("'{0}': Overflow", intervalString)
      End Try 
      
      ' 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")
      Try
         interval = TimeSpan.ParseExact(intervalString, format, 
                                        culture, TimeSpanStyles.AssumeNegative)
         Console.WriteLine("'{0}' ({1}) --> {2}", intervalString, format, interval)
      Catch e As FormatException
         Console.WriteLine("'{0}': Bad Format for '{1}'", intervalString, format)
      Catch e As OverflowException
         Console.WriteLine("'{0}': Overflow", intervalString)
      End Try 

      ' Parse a single number using the "c" standard format string. 
      intervalString = "12"
      format = "c"
      Try
         interval = TimeSpan.ParseExact(intervalString, format, 
                                        Nothing, TimeSpanStyles.AssumeNegative)
         Console.WriteLine("'{0}' ({1}) --> {2}", intervalString, format, interval)
      Catch e As FormatException
         Console.WriteLine("'{0}': Bad Format for '{1}'", intervalString, format)
      Catch e As OverflowException
         Console.WriteLine("'{0}': Overflow", intervalString)
      End Try 
      
      ' Parse a single number using the "%h" custom format string. 
      format = "%h"
      Try
         interval = TimeSpan.ParseExact(intervalString, format, 
                                        Nothing, TimeSpanStyles.AssumeNegative)
         Console.WriteLine("'{0}' ({1}) --> {2}", intervalString, format, interval)
      Catch e As FormatException
         Console.WriteLine("'{0}': Bad Format for '{1}'", intervalString, format)
      Catch e As OverflowException
         Console.WriteLine("'{0}': Overflow", intervalString)
      End Try 
      
      ' Parse a single number using the "%s" custom format string. 
      format = "%s"
      Try
         interval = TimeSpan.ParseExact(intervalString, format, 
                                        Nothing, TimeSpanStyles.AssumeNegative)
         Console.WriteLine("'{0}' ({1}) --> {2}", intervalString, format, interval)
      Catch e As FormatException
         Console.WriteLine("'{0}': Bad Format for '{1}'", intervalString, format)
      Catch e As OverflowException
         Console.WriteLine("'{0}': Overflow", intervalString)
      End Try 
   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

ParseExact 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. input format biçimine tam olarak uyması gerektiğinden, kullanıcı tarafından bir dize girişini zaman aralığına dönüştürürken her zaman özel durum işlemeyi kullanmalısınız. Özel durum işlemeyi kullanmamak isterseniz bunun yerine TryParseExact(String, String, IFormatProvider, TimeSpanStyles, TimeSpan) yöntemini çağırabilirsiniz.

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.

Önemli

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

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:

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

ParseExact(String, String[], IFormatProvider, TimeSpanStyles)

Kaynak:
TimeSpan.cs
Kaynak:
TimeSpan.cs
Kaynak:
TimeSpan.cs

Belirtilen biçimleri, kültüre özgü biçim bilgilerini 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çimlerden biriyle tam olarak eşleşmelidir.

public:
 static TimeSpan ParseExact(System::String ^ input, cli::array <System::String ^> ^ formats, IFormatProvider ^ formatProvider, System::Globalization::TimeSpanStyles styles);
public static TimeSpan ParseExact (string input, string[] formats, IFormatProvider formatProvider, System.Globalization.TimeSpanStyles styles);
public static TimeSpan ParseExact (string input, string[] formats, IFormatProvider? formatProvider, System.Globalization.TimeSpanStyles styles);
static member ParseExact : string * string[] * IFormatProvider * System.Globalization.TimeSpanStyles -> TimeSpan
Public Shared Function ParseExact (input As String, formats As String(), formatProvider As IFormatProvider, styles As TimeSpanStyles) As TimeSpan

Parametreler

input
String

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

formats
String[]

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

formatProvider
IFormatProvider

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

styles
TimeSpanStyles

Girişte bulunabilecek stil öğelerini tanımlayan sabit listesi değerlerinin bit düzeyinde birleşimi.

Döndürülenler

formats, formatProviderve stylestarafından belirtilen inputkarşılık gelen zaman aralığı.

Özel durumlar

styles geçersiz bir TimeSpanStyles değeridir.

input null.

input geçersiz bir biçime sahip.

input TimeSpan.MinValue veya TimeSpan.MaxValuedeğerinden büyük bir sayıyı temsil eder.

-veya-

input gün, saat, dakika veya saniye bileşenlerinden en az biri geçerli aralığının dışındadır.

Örnekler

Aşağıdaki örnek, bir dize dizisinin her öğesini bir TimeSpan değerine dönüştürmek için ParseExact(String, String[], IFormatProvider, TimeSpanStyles) 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("de-DE");
      
      // Parse each string in inputs using formats and the de-DE culture.
      foreach (string input in inputs) {
         try {
            interval = TimeSpan.ParseExact(input, formats, culture,
                                           TimeSpanStyles.AssumeNegative);
            Console.WriteLine("{0} --> {1:c}", input, interval);
         }
         catch (FormatException) {
            Console.WriteLine("{0} --> Bad Format", input);
         }      
         catch (OverflowException) {
            Console.WriteLine("{0} --> Overflow", input);   
         }            
      }
   }
}
// The example displays the following output:
//       3 --> -03:00:00
//       16:42 --> 16:42:00
//       1:6:52:35.0625 --> Bad Format
//       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 "de-DE"

// Parse each string in inputs using formats and the de-DE culture.
for input in inputs do
    try
        let interval = 
            TimeSpan.ParseExact(input, formats, culture, TimeSpanStyles.AssumeNegative)
        printfn $"{input} --> {interval:c}"
    with
    | :? FormatException ->
        printfn $"{input} --> Bad Format"
    | :? OverflowException ->
        printfn $"{input} --> Overflow"
// The example displays the following output:
//       3 --> -03:00:00
//       16:42 --> 16:42:00
//       1:6:52:35.0625 --> Bad Format
//       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 de-DE culture.
      For Each input As String In inputs
         Try
            interval = TimeSpan.ParseExact(input, formats, culture, 
                                           TimeSpanStyles.AssumeNegative)
            Console.WriteLine("{0} --> {1:c}", input, interval)   
         Catch e As FormatException
            Console.WriteLine("{0} --> Bad Format", input)   
         Catch e As OverflowException
            Console.WriteLine("{0} --> Overflow", input)   
         End Try            
      Next
   End Sub
End Module
' The example displays the following output:
'       3 --> -03:00:00
'       16:42 --> 16:42:00
'       1:6:52:35.0625 --> Bad Format
'       1:6:52:35,0625 --> 1.06:52:35.0625000

Açıklamalar

ParseExact(String, String[], IFormatProvider, TimeSpanStyles) yöntemi, formats parametresi tarafından tanımlanan biçimlerden birinde olması gereken bir zaman aralığının dize gösterimini ayrıştırırken, baştaki ve sondaki boşluk karakterleri yoksayılır. input formatsbelirtilen biçimlerden birine tam olarak uyması gerektiğinden, kullanıcı tarafından bir dize girişini zaman aralığına dönüştürürken her zaman özel durum işlemeyi kullanmalısınız. Özel durum işlemeyi kullanmamak isterseniz bunun yerine TryParseExact(String, String[], IFormatProvider, TimeSpanStyles, TimeSpan) yöntemini çağırabilirsiniz.

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

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.

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:

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