DateTime.ParseExact Yöntem

Başvuru

Tanım

Ad Alanı:: System

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

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

Bütünleştirilmiş Kod:: netstandard.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 tarih ve saatin belirtilen dize gösterimini eşdeğerine DateTime dönüştürür. Dize gösteriminin biçimi, belirtilen biçimle tam olarak eşleşmelidir veya bir özel durum oluşturulur.

Aşırı Yüklemeler

ParseExact(String, String, IFormatProvider)	Belirtilen biçim ve kültüre özgü biçim bilgilerini kullanarak bir tarih ve saatin belirtilen dize gösterimini eşdeğerine DateTime dönüştürür. Dize gösteriminin biçimi belirtilen biçimle tam olarak eşleşmelidir.
ParseExact(ReadOnlySpan<Char>, ReadOnlySpan<Char>, IFormatProvider, DateTimeStyles)	Belirtilen biçimi, kültüre özgü biçim bilgilerini ve stili kullanarak bir tarih ve saatin belirtilen span gösterimini eşdeğerine DateTime dönüştürür. Dize gösteriminin biçimi, belirtilen biçimle tam olarak eşleşmelidir veya bir özel durum oluşturulur.
ParseExact(ReadOnlySpan<Char>, String[], IFormatProvider, DateTimeStyles)	Belirtilen biçim dizisini, kültüre özgü biçim bilgilerini ve stili kullanarak bir tarih ve saatin belirtilen span gösterimini eşdeğerine DateTime dönüştürür. Dize gösteriminin biçimi, belirtilen biçimlerden en az biriyle tam olarak eşleşmelidir veya bir özel durum oluşturulur.
ParseExact(String, String, IFormatProvider, DateTimeStyles)	Belirtilen biçimi, kültüre özgü biçim bilgilerini ve stili kullanarak bir tarih ve saatin belirtilen dize gösterimini eşdeğerine DateTime dönüştürür. Dize gösteriminin biçimi, belirtilen biçimle tam olarak eşleşmelidir veya bir özel durum oluşturulur.
ParseExact(String, String[], IFormatProvider, DateTimeStyles)	Belirtilen biçim dizisini, kültüre özgü biçim bilgilerini ve stili kullanarak bir tarih ve saatin belirtilen dize gösterimini DateTime eşdeğerine dönüştürür. Dize gösteriminin biçimi, belirtilen biçimlerden en az biriyle tam olarak eşleşmelidir veya bir özel durum oluşturulur.

Açıklamalar

Önemli

Japon takvimlerindeki dönemler imparatorun saltanatına dayanır ve bu nedenle değişmesi beklenir. Örneğin, 1 Mayıs 2019 ve JapaneseLunisolarCalendariçinde Reiwa döneminin başlangıcını işaretlediJapaneseCalendar. Bu tür bir çağ değişikliği, bu takvimleri kullanan tüm uygulamaları etkiler. Daha fazla bilgi edinmek ve uygulamalarınızın etkilenip etkilenmediğini belirlemek için bkz. .NET'te Japon takviminde yeni bir dönemi işleme. Uygulamalarınızı Windows sistemlerinde test ederek çağ değişikliğine hazır olmalarını sağlama hakkında bilgi için bkz. Uygulamanızı Japon dönemi değişikliğine hazırlama. .NET'te birden çok dönemi destekleyen takvimleri destekleyen özellikler ve birden çok dönemi destekleyen takvimlerle çalışırken en iyi yöntemler için bkz. Dönemlerle çalışma.

ParseExact(String, String, IFormatProvider)

Kaynak:: DateTime.cs

Kaynak:: DateTime.cs

Kaynak:: DateTime.cs

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

public:
 static DateTime ParseExact(System::String ^ s, System::String ^ format, IFormatProvider ^ provider);

public static DateTime ParseExact (string s, string format, IFormatProvider provider);

public static DateTime ParseExact (string s, string format, IFormatProvider? provider);

static member ParseExact : string * string * IFormatProvider -> DateTime

Public Shared Function ParseExact (s As String, format As String, provider As IFormatProvider) As DateTime

Parametreler

s: String

Dönüştürülecek bir tarih ve saat içeren bir dize.

format: String

gerekli biçimini tanımlayan bir biçim tanımlayıcısı s. Daha fazla bilgi için Açıklamalar bölümüne bakın.

provider: IFormatProvider

hakkında skültüre özgü biçim bilgileri sağlayan bir nesne.

Döndürülenler

DateTime

ve providertarafından format belirtildiği gibi içinde sbulunan tarih ve saate eşdeğer bir nesne.

Özel durumlar

ArgumentNullException

s veya format şeklindedir null.

FormatException

s veya format boş bir dizedir.

-veya-

s içinde belirtilen formatdesene karşılık gelen bir tarih ve saat içermez.

-veya-

içindeki saat bileşeni ve AM/PM göstergesi s aynı fikirde değildir.

Örnekler

Aşağıdaki örnekte yöntemi gösterilmektedir ParseExact .

using System;
using System.Globalization;

public class Example
{
   public static void Main()
   {
      string dateString, format;
      DateTime result;
      CultureInfo provider = CultureInfo.InvariantCulture;

      // Parse date-only value with invariant culture.
      dateString = "06/15/2008";
      format = "d";
      try {
         result = DateTime.ParseExact(dateString, format, provider);
         Console.WriteLine("{0} converts to {1}.", dateString, result.ToString());
      }
      catch (FormatException) {
         Console.WriteLine("{0} is not in the correct format.", dateString);
      }

      // Parse date-only value without leading zero in month using "d" format.
      // Should throw a FormatException because standard short date pattern of
      // invariant culture requires two-digit month.
      dateString = "6/15/2008";
      try {
         result = DateTime.ParseExact(dateString, format, provider);
         Console.WriteLine("{0} converts to {1}.", dateString, result.ToString());
      }
      catch (FormatException) {
         Console.WriteLine("{0} is not in the correct format.", dateString);
      }

      // Parse date and time with custom specifier.
      dateString = "Sun 15 Jun 2008 8:30 AM -06:00";
      format = "ddd dd MMM yyyy h:mm tt zzz";
      try {
         result = DateTime.ParseExact(dateString, format, provider);
         Console.WriteLine("{0} converts to {1}.", dateString, result.ToString());
      }
      catch (FormatException) {
         Console.WriteLine("{0} is not in the correct format.", dateString);
      }

      // Parse date and time with offset but without offset's minutes.
      // Should throw a FormatException because "zzz" specifier requires leading
      // zero in hours.
      dateString = "Sun 15 Jun 2008 8:30 AM -06";
      try {
         result = DateTime.ParseExact(dateString, format, provider);
         Console.WriteLine("{0} converts to {1}.", dateString, result.ToString());
      }
      catch (FormatException) {
         Console.WriteLine("{0} is not in the correct format.", dateString);
      }

      dateString = "15/06/2008 08:30";
      format = "g";
      provider = new CultureInfo("fr-FR");
      try {
         result = DateTime.ParseExact(dateString, format, provider);
         Console.WriteLine("{0} converts to {1}.", dateString, result.ToString());
      }
      catch (FormatException) {
         Console.WriteLine("{0} is not in the correct format.", dateString);
      }

      // Parse a date that includes seconds and milliseconds
      // by using the French (France) and invariant cultures.
      dateString = "18/08/2015 06:30:15.006542";
      format = "dd/MM/yyyy HH:mm:ss.ffffff";
      try {
         result = DateTime.ParseExact(dateString, format, provider);
         Console.WriteLine("{0} converts to {1}.", dateString, result.ToString());
      }
      catch (FormatException) {
         Console.WriteLine("{0} is not in the correct format.", dateString);
      }
   }
}
// The example displays the following output:
//       06/15/2008 converts to 6/15/2008 12:00:00 AM.
//       6/15/2008 is not in the correct format.
//       Sun 15 Jun 2008 8:30 AM -06:00 converts to 6/15/2008 7:30:00 AM.
//       Sun 15 Jun 2008 8:30 AM -06 is not in the correct format.
//       15/06/2008 08:30 converts to 6/15/2008 8:30:00 AM.
//       18/08/2015 06:30:15.006542 converts to 8/18/2015 6:30:15 AM.

open System
open System.Globalization

[<EntryPoint>]
let main _ =
    let provider = CultureInfo.InvariantCulture

    // Parse date-only value with invariant culture.
    let dateString = "06/15/2008"
    let format = "d"
    try
        let result = DateTime.ParseExact(dateString, format, provider)
        printfn $"{dateString} converts to {result}."
    with :? FormatException ->
        printfn $"{dateString} is not in the correct format."

    // Parse date-only value without leading zero in month using "d" format.
    // Should throw a FormatException because standard short date pattern of
    // invariant culture requires two-digit month.
    let dateString = "6/15/2008"
    try
        let result = DateTime.ParseExact(dateString, format, provider)
        printfn $"{dateString} converts to {result}."
    with :? FormatException ->
        printfn $"{dateString} is not in the correct format."

    // Parse date and time with custom specifier.
    let dateString = "Sun 15 Jun 2008 8:30 AM -06:00"
    let format = "ddd dd MMM yyyy h:mm tt zzz"
    try
        let result = DateTime.ParseExact(dateString, format, provider)
        printfn $"{dateString} converts to {result}."
    with :? FormatException ->
        printfn $"{dateString} is not in the correct format."

    // Parse date and time with offset but without offset's minutes.
    // Should throw a FormatException because "zzz" specifier requires leading
    // zero in hours.
    let dateString = "Sun 15 Jun 2008 8:30 AM -06"
    try
        let result = DateTime.ParseExact(dateString, format, provider)
        printfn $"{dateString} converts to {result}."
    with :? FormatException ->
        printfn $"{dateString} is not in the correct format."

    let dateString = "15/06/2008 08:30"
    let format = "g"
    let provider = CultureInfo "fr-FR"
    try
        let result = DateTime.ParseExact(dateString, format, provider)
        printfn $"{dateString} converts to {result}."
    with :? FormatException ->
        printfn $"{dateString} is not in the correct format."

    // Parse a date that includes seconds and milliseconds
    // by using the French (France) and invariant cultures.
    let dateString = "18/08/2015 06:30:15.006542"
    let format = "dd/MM/yyyy HH:mm:ss.ffffff"
    try
        let result = DateTime.ParseExact(dateString, format, provider)
        printfn $"{dateString} converts to {result}."
    with :? FormatException ->
        printfn $"{dateString} is not in the correct format."

    0

// The example displays the following output:
//       06/15/2008 converts to 6/15/2008 12:00:00 AM.
//       6/15/2008 is not in the correct format.
//       Sun 15 Jun 2008 8:30 AM -06:00 converts to 6/15/2008 7:30:00 AM.
//       Sun 15 Jun 2008 8:30 AM -06 is not in the correct format.
//       15/06/2008 08:30 converts to 6/15/2008 8:30:00 AM.
//       18/08/2015 06:30:15.006542 converts to 8/18/2015 6:30:15 AM.

Imports System.Globalization

Module Example
   Public Sub Main()
      Dim dateString, format As String  
      Dim result As Date
      Dim provider As CultureInfo = CultureInfo.InvariantCulture

      ' Parse date-only value with invariant culture.
      dateString = "06/15/2008"
      format = "d"
      Try
         result = Date.ParseExact(dateString, format, provider)
         Console.WriteLine("{0} converts to {1}.", dateString, result.ToString())
      Catch e As FormatException
         Console.WriteLine("{0} is not in the correct format.", dateString)
      End Try 

      ' Parse date-only value without leading zero in month using "d" format.
      ' Should throw a FormatException because standard short date pattern of 
      ' invariant culture requires two-digit month.
      dateString = "6/15/2008"
      Try
         result = Date.ParseExact(dateString, format, provider)
         Console.WriteLine("{0} converts to {1}.", dateString, result.ToString())
      Catch e As FormatException
         Console.WriteLine("{0} is not in the correct format.", dateString)
      End Try 
      
      ' Parse date and time with custom specifier.
      dateString = "Sun 15 Jun 2008 8:30 AM -06:00"
      format = "ddd dd MMM yyyy h:mm tt zzz"        
      Try
         result = Date.ParseExact(dateString, format, provider)
         Console.WriteLine("{0} converts to {1}.", dateString, result.ToString())
      Catch e As FormatException
         Console.WriteLine("{0} is not in the correct format.", dateString)
      End Try 
      
      ' Parse date and time with offset but without offset's minutes.
      ' Should throw a FormatException because "zzz" specifier requires leading  
      ' zero in hours.
      dateString = "Sun 15 Jun 2008 8:30 AM -06"
      Try
         result = Date.ParseExact(dateString, format, provider)
         Console.WriteLine("{0} converts to {1}.", dateString, result.ToString())
      Catch e As FormatException
         Console.WriteLine("{0} is not in the correct format.", dateString)
      End Try 
      
      ' Parse a date string using the French (France) culture.
      dateString = "15/06/2008 08:30"
      format = "g"
      provider = New CultureInfo("fr-FR")
      Try
         result = Date.ParseExact(dateString, format, provider)
         Console.WriteLine("{0} converts to {1}.", dateString, result.ToString())
      Catch e As FormatException
         Console.WriteLine("{0} is not in the correct format.", dateString)
      End Try

      ' Parse a date that includes seconds and milliseconds
      ' by using the French (France) and invariant cultures.
      dateString = "18/08/2015 06:30:15.006542"
      format = "dd/MM/yyyy HH:mm:ss.ffffff"
      Try
         result = Date.ParseExact(dateString, format, provider)
         Console.WriteLine("{0} converts to {1}.", dateString, result.ToString())
      Catch e As FormatException
         Console.WriteLine("{0} is not in the correct format.", dateString)
      End Try
   End Sub
End Module
' The example displays the following output:
'       06/15/2008 converts to 6/15/2008 12:00:00 AM.
'       6/15/2008 is not in the correct format.
'       Sun 15 Jun 2008 8:30 AM -06:00 converts to 6/15/2008 7:30:00 AM.
'       Sun 15 Jun 2008 8:30 AM -06 is not in the correct format.
'       15/06/2008 08:30 converts to 6/15/2008 8:30:00 AM.
'       18/08/2015 06:30:15.006542 converts to 8/18/2015 6:30:15 AM.

Açıklamalar

DateTime.ParseExact(String, String, IFormatProvider) yöntemi, parametre tarafından tanımlanan biçimde olması gereken bir tarihin dize gösterimini format ayrıştırır. Ayrıca, bir tarih ve saatin dize gösteriminin Tarih ve Saat öğelerinin tarafından formatbelirtilen sırada gösterilmesini ve s tarafından izin verilenden formatbaşka boşluk olmamasını gerektirir<.><> Saat öğesi olmayan bir tarih tanımlarsa format ve ayrıştırma işlemi başarılı olursa, sonuçta elde DateTime edilen değerin gece yarısı (00:00:00) saati vardır. Tarih öğesi olmayan bir saat tanımlarsa format ve ayrıştırma işlemi başarılı olursa, sonuçta elde edilen DateTime değerin DateTime.Now.Datetarihi olur.

Belirli bir saat dilimindeki bir saati temsil etmiyorsa s ve ayrıştırma işlemi başarılı olursa, Kind döndürülen DateTime değerin özelliği olur DateTimeKind.Unspecified. s Belirli bir saat dilimindeki saati temsil ederse ve format saat dilimi bilgilerinin mevcut olmasına izin veriyorsa (örneğin, "o", "r" veya "u" standart biçim tanımlayıcılarına eşitse format ya da "z", "zz" veya "zzz" özel biçim tanımlayıcılarını içeriyorsa), Kind döndürülen DateTime değerin özelliği olurDateTimeKind.Local.

format parametresi, tek bir standart biçim belirticisi veya gerekli biçimini tanımlayan bir veya daha fazla özel biçim belirticisi içeren bir dizedirs. Geçerli biçimlendirme kodları hakkında ayrıntılı bilgi için bkz. Standart Tarih ve Saat Biçim Dizeleri veya Özel Tarih ve Saat Biçim Dizeleri.

Not

Tarih veya saat ayırıcıları içermeyen özel bir biçim deseniyse format ("yyyyMMddHHmm" gibi), parametre için provider sabit kültürü ve her özel biçim tanımlayıcısının en geniş biçimini kullanın. Örneğin, saat sayısını biçim düzeninde belirtmek istiyorsanız, daha dar bir form olan "H" yerine daha geniş olan "SS" biçimini belirtin.

içinde kullanılan s belirli tarih ve saat simgeleri ve dizeleri (belirli bir dilde haftanın günlerinin adları gibi), standart biçim belirtici dizesi ise format tam biçimi s olduğu gibi parametresi tarafından provider tanımlanır. provider parametresi aşağıdakilerden biri olabilir:

CultureInfo yorumlamak siçin kullanılan kültürü temsil eden bir nesne. DateTimeFormatInfo özelliği tarafından DateTimeFormat döndürülen nesne, içindeki ssembolleri ve biçimlendirmeyi tanımlar.
DateTimeFormatInfo Tarih ve saat verilerinin biçimini tanımlayan bir nesne.
Yöntemi, biçimlendirme bilgilerini sağlayan nesneyi veya DateTimeFormatInfo nesneyi döndüren CultureInfo özel IFormatProvider bir uygulamaGetFormat.

ise providernull, CultureInfo geçerli kültüre karşılık gelen nesne kullanılır.

Arayanlara Notlar

.NET Framework 4'te yöntemi, ParseExact ayrıştırılacak dizenin bir saat bileşeni ve uyuşmayan bir AM/PM belirteci içeriyorsa bir oluştururFormatException. .NET Framework 3.5 ve önceki sürümlerde AM/PM göstergesi yoksayılır.

Ayrıca bkz.

Şunlara uygulanır

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

Kaynak:: DateTime.cs

Kaynak:: DateTime.cs

Kaynak:: DateTime.cs

Belirtilen biçimi, kültüre özgü biçim bilgilerini ve stili kullanarak bir tarih ve saatin belirtilen span gösterimini eşdeğerine DateTime dönüştürür. Dize gösteriminin biçimi, belirtilen biçimle tam olarak eşleşmelidir veya bir özel durum oluşturulur.

public static DateTime ParseExact (ReadOnlySpan<char> s, ReadOnlySpan<char> format, IFormatProvider? provider, System.Globalization.DateTimeStyles style = System.Globalization.DateTimeStyles.None);

public static DateTime ParseExact (ReadOnlySpan<char> s, ReadOnlySpan<char> format, IFormatProvider provider, System.Globalization.DateTimeStyles style = System.Globalization.DateTimeStyles.None);

static member ParseExact : ReadOnlySpan<char> * ReadOnlySpan<char> * IFormatProvider * System.Globalization.DateTimeStyles -> DateTime

Public Shared Function ParseExact (s As ReadOnlySpan(Of Char), format As ReadOnlySpan(Of Char), provider As IFormatProvider, Optional style As DateTimeStyles = System.Globalization.DateTimeStyles.None) As DateTime

Parametreler

s: ReadOnlySpan<Char>

Dönüştürülecek tarih ve saati temsil eden karakterleri içeren bir yayılma alanı.

format: ReadOnlySpan<Char>

gerekli biçimini tanımlayan bir biçim tanımlayıcısını temsil eden karakterleri içeren bir yayılma alanı s.

provider: IFormatProvider

hakkında skültüre özgü biçimlendirme bilgileri sağlayan bir nesne.

style: DateTimeStyles

içinde bulunabilecek sstil öğeleri hakkında veya öğesinden s bir değere dönüştürme hakkında shakkında ek bilgi sağlayan numaralandırma değerlerinin bit düzeyinde birleşimiDateTime. Belirtilmesi gereken tipik bir değerdir None.

Döndürülenler

DateTime

, ve styletarafından formatproviderbelirtildiği gibi içinde sbulunan tarih ve saate eşdeğer bir nesne.

Şunlara uygulanır

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

Kaynak:: DateTime.cs

Kaynak:: DateTime.cs

Kaynak:: DateTime.cs

Belirtilen biçim dizisini, kültüre özgü biçim bilgilerini ve stili kullanarak bir tarih ve saatin belirtilen span gösterimini eşdeğerine DateTime dönüştürür. Dize gösteriminin biçimi, belirtilen biçimlerden en az biriyle tam olarak eşleşmelidir veya bir özel durum oluşturulur.

public static DateTime ParseExact (ReadOnlySpan<char> s, string[] formats, IFormatProvider? provider, System.Globalization.DateTimeStyles style = System.Globalization.DateTimeStyles.None);

public static DateTime ParseExact (ReadOnlySpan<char> s, string[] formats, IFormatProvider provider, System.Globalization.DateTimeStyles style = System.Globalization.DateTimeStyles.None);

static member ParseExact : ReadOnlySpan<char> * string[] * IFormatProvider * System.Globalization.DateTimeStyles -> DateTime

Public Shared Function ParseExact (s As ReadOnlySpan(Of Char), formats As String(), provider As IFormatProvider, Optional style As DateTimeStyles = System.Globalization.DateTimeStyles.None) As DateTime

Parametreler

s: ReadOnlySpan<Char>

Dönüştürülecek tarih ve saati temsil eden karakterleri içeren bir yayılma alanı.

formats: String[]

İzin verilebilen biçim dizisi s.

provider: IFormatProvider

hakkında skültüre özgü biçim bilgileri sağlayan bir nesne.

style: DateTimeStyles

İzin verilen biçimini gösteren sabit listesi değerlerinin bit düzeyinde birleşimi s. Belirtilmesi gereken tipik bir değerdir None.

Döndürülenler

DateTime

, ve styletarafından formatsproviderbelirtildiği gibi içinde sbulunan tarih ve saate eşdeğer bir nesne.

Şunlara uygulanır

ParseExact(String, String, IFormatProvider, DateTimeStyles)

Kaynak:: DateTime.cs

Kaynak:: DateTime.cs

Kaynak:: DateTime.cs

Belirtilen biçimi, kültüre özgü biçim bilgilerini ve stili kullanarak bir tarih ve saatin belirtilen dize gösterimini eşdeğerine DateTime dönüştürür. Dize gösteriminin biçimi, belirtilen biçimle tam olarak eşleşmelidir veya bir özel durum oluşturulur.

public:
 static DateTime ParseExact(System::String ^ s, System::String ^ format, IFormatProvider ^ provider, System::Globalization::DateTimeStyles style);

public static DateTime ParseExact (string s, string format, IFormatProvider provider, System.Globalization.DateTimeStyles style);

public static DateTime ParseExact (string s, string format, IFormatProvider? provider, System.Globalization.DateTimeStyles style);

static member ParseExact : string * string * IFormatProvider * System.Globalization.DateTimeStyles -> DateTime

Public Shared Function ParseExact (s As String, format As String, provider As IFormatProvider, style As DateTimeStyles) As DateTime

Parametreler

s: String

Dönüştürülecek tarih ve saati içeren bir dize.

format: String

gerekli biçimini tanımlayan bir biçim tanımlayıcısı s. Daha fazla bilgi için Açıklamalar bölümüne bakın.

provider: IFormatProvider

hakkında skültüre özgü biçimlendirme bilgileri sağlayan bir nesne.

style: DateTimeStyles

Döndürülenler

DateTime

, providerve styletarafından formatbelirtildiği gibi içinde sbulunan tarih ve saate eşdeğer bir nesne.

Özel durumlar

ArgumentNullException

s veya format şeklindedir null.

FormatException

s veya format boş bir dizedir.

-veya-

s içinde belirtilen formatdesene karşılık gelen bir tarih ve saat içermez.

-veya-

içindeki saat bileşeni ve AM/PM göstergesi s aynı fikirde değildir.

ArgumentException

style geçersiz bir değer bileşimi DateTimeStyles içeriyor. Örneğin, hem AssumeUniversalhem de AssumeLocal .

Örnekler

Aşağıdaki örnekte yöntemi gösterilmektedir ParseExact(String, String, IFormatProvider) . Öndeki boşluklara izin verilmediğinden formatparametre eşit DateTimeStyles.None olduğunda " 01.05.2009 08:30" dizesinin styles başarıyla ayrıştırılamayacağını unutmayın. Buna ek olarak, "01.05.2009 09:00" dizesi "AA/gg/yyyyhh:mm" ile format başarıyla ayrıştırılamaz çünkü tarih dizesi ay sayısından önce başta sıfır yoktur, format çünkü gerektiğinde.

using System;
using System.Globalization;

public class Example
{
   public static void Main()
   {
      CultureInfo enUS = new CultureInfo("en-US");
      string dateString;
      DateTime dateValue;

      // Parse date with no style flags.
      dateString = " 5/01/2009 8:30 AM";
      try {
         dateValue = DateTime.ParseExact(dateString, "g", enUS, DateTimeStyles.None);
         Console.WriteLine("Converted '{0}' to {1} ({2}).", dateString, dateValue,
                           dateValue.Kind);
      }
      catch (FormatException) {
         Console.WriteLine("'{0}' is not in an acceptable format.", dateString);
      }
      // Allow a leading space in the date string.
      try {
         dateValue = DateTime.ParseExact(dateString, "g", enUS, DateTimeStyles.AllowLeadingWhite);
         Console.WriteLine("Converted '{0}' to {1} ({2}).", dateString, dateValue,
                           dateValue.Kind);
      }
      catch (FormatException) {
         Console.WriteLine("'{0}' is not in an acceptable format.", dateString);
      }

      // Use custom formats with M and MM.
      dateString = "5/01/2009 09:00";
      try {
         dateValue = DateTime.ParseExact(dateString, "M/dd/yyyy hh:mm", enUS, DateTimeStyles.None);
         Console.WriteLine("Converted '{0}' to {1} ({2}).", dateString, dateValue,
                           dateValue.Kind);
      }
      catch (FormatException) {
         Console.WriteLine("'{0}' is not in an acceptable format.", dateString);
      }
      // Allow a leading space in the date string.
      try {
         dateValue = DateTime.ParseExact(dateString, "MM/dd/yyyy hh:mm", enUS, DateTimeStyles.None);
         Console.WriteLine("Converted '{0}' to {1} ({2}).", dateString, dateValue,
                           dateValue.Kind);
      }
      catch (FormatException) {
         Console.WriteLine("'{0}' is not in an acceptable format.", dateString);
      }

      // Parse a string with time zone information.
      dateString = "05/01/2009 01:30:42 PM -05:00";
      try {
         dateValue = DateTime.ParseExact(dateString, "MM/dd/yyyy hh:mm:ss tt zzz", enUS, DateTimeStyles.None);
         Console.WriteLine("Converted '{0}' to {1} ({2}).", dateString, dateValue,
                           dateValue.Kind);
      }
      catch (FormatException) {
         Console.WriteLine("'{0}' is not in an acceptable format.", dateString);
      }
      // Allow a leading space in the date string.
      try {
         dateValue = DateTime.ParseExact(dateString, "MM/dd/yyyy hh:mm:ss tt zzz", enUS,
                                     DateTimeStyles.AdjustToUniversal);
         Console.WriteLine("Converted '{0}' to {1} ({2}).", dateString, dateValue,
                           dateValue.Kind);
      }
      catch (FormatException) {
         Console.WriteLine("'{0}' is not in an acceptable format.", dateString);
      }

      // Parse a string representing UTC.
      dateString = "2008-06-11T16:11:20.0904778Z";
      try {
         dateValue = DateTime.ParseExact(dateString, "o", CultureInfo.InvariantCulture,
                                     DateTimeStyles.None);
         Console.WriteLine("Converted '{0}' to {1} ({2}).", dateString, dateValue,
                           dateValue.Kind);
      }
      catch (FormatException) {
         Console.WriteLine("'{0}' is not in an acceptable format.", dateString);
      }
      try {
         dateValue = DateTime.ParseExact(dateString, "o", CultureInfo.InvariantCulture,
                                     DateTimeStyles.RoundtripKind);
         Console.WriteLine("Converted '{0}' to {1} ({2}).", dateString, dateValue,
                           dateValue.Kind);
      }
      catch (FormatException) {
         Console.WriteLine("'{0}' is not in an acceptable format.", dateString);
      }
   }
}
// The example displays the following output:
//    ' 5/01/2009 8:30 AM' is not in an acceptable format.
//    Converted ' 5/01/2009 8:30 AM' to 5/1/2009 8:30:00 AM (Unspecified).
//    Converted '5/01/2009 09:00' to 5/1/2009 9:00:00 AM (Unspecified).
//    '5/01/2009 09:00' is not in an acceptable format.
//    Converted '05/01/2009 01:30:42 PM -05:00' to 5/1/2009 11:30:42 AM (Local).
//    Converted '05/01/2009 01:30:42 PM -05:00' to 5/1/2009 6:30:42 PM (Utc).
//    Converted '2008-06-11T16:11:20.0904778Z' to 6/11/2008 9:11:20 AM (Local).
//    Converted '2008-06-11T16:11:20.0904778Z' to 6/11/2008 4:11:20 PM (Utc).

open System
open System.Globalization

[<EntryPoint>]
let main _ =
    let enUS = CultureInfo "en-US"

    // Parse date with no style flags.
    let dateString = " 5/01/2009 8:30 AM"
    try
        let dateValue = DateTime.ParseExact(dateString, "g", enUS, DateTimeStyles.None)
        printfn $"Converted '{dateString}' to {dateValue} ({dateValue.Kind})."
    with :? FormatException ->
        printfn $"'{dateString}' is not in an acceptable format."
    
    // Allow a leading space in the date string.
    try
        let dateValue = DateTime.ParseExact(dateString, "g", enUS, DateTimeStyles.AllowLeadingWhite)
        printfn $"Converted '{dateString}' to {dateValue} ({dateValue.Kind})."
    with :? FormatException ->
        printfn $"'{dateString}' is not in an acceptable format."

    // Use custom formats with M and MM.
    let dateString = "5/01/2009 09:00"
    try
        let dateValue = DateTime.ParseExact(dateString, "M/dd/yyyy hh:mm", enUS, DateTimeStyles.None)
        printfn $"Converted '{dateString}' to {dateValue} ({dateValue.Kind})."
    with :? FormatException ->
        printfn $"'{dateString}' is not in an acceptable format."

    // Allow a leading space in the date string.
    try
        let dateValue = DateTime.ParseExact(dateString, "MM/dd/yyyy hh:mm", enUS, DateTimeStyles.None)
        printfn $"Converted '{dateString}' to {dateValue} ({dateValue.Kind})."
    with :? FormatException ->
        printfn $"'{dateString}' is not in an acceptable format."

    // Parse a string with time zone information.
    let dateString = "05/01/2009 01:30:42 PM -05:00"
    try
        let dateValue = DateTime.ParseExact(dateString, "MM/dd/yyyy hh:mm:ss tt zzz", enUS, DateTimeStyles.None)
        printfn $"Converted '{dateString}' to {dateValue} ({dateValue.Kind})."
    with :? FormatException ->
        printfn $"'{dateString}' is not in an acceptable format."

    // Allow a leading space in the date string.
    try
        let dateValue = DateTime.ParseExact(dateString, "MM/dd/yyyy hh:mm:ss tt zzz", enUS, DateTimeStyles.AdjustToUniversal)
        printfn $"Converted '{dateString}' to {dateValue} ({dateValue.Kind})."
    with :? FormatException ->
        printfn $"'{dateString}' is not in an acceptable format."

    // Parse a string representing UTC.
    let dateString = "2008-06-11T16:11:20.0904778Z"
    try
        let dateValue = DateTime.ParseExact(dateString, "o", CultureInfo.InvariantCulture, DateTimeStyles.None)
        printfn $"Converted '{dateString}' to {dateValue} ({dateValue.Kind})."
    with :? FormatException ->
        printfn $"'{dateString}' is not in an acceptable format."

    try
        let dateValue = DateTime.ParseExact(dateString, "o", CultureInfo.InvariantCulture, DateTimeStyles.RoundtripKind)
        printfn $"Converted '{dateString}' to {dateValue} ({dateValue.Kind})."
    with :? FormatException ->
        printfn $"'{dateString}' is not in an acceptable format."


// The example displays the following output:
//    ' 5/01/2009 8:30 AM' is not in an acceptable format.
//    Converted ' 5/01/2009 8:30 AM' to 5/1/2009 8:30:00 AM (Unspecified).
//    Converted '5/01/2009 09:00' to 5/1/2009 9:00:00 AM (Unspecified).
//    '5/01/2009 09:00' is not in an acceptable format.
//    Converted '05/01/2009 01:30:42 PM -05:00' to 5/1/2009 11:30:42 AM (Local).
//    Converted '05/01/2009 01:30:42 PM -05:00' to 5/1/2009 6:30:42 PM (Utc).
//    Converted '2008-06-11T16:11:20.0904778Z' to 6/11/2008 9:11:20 AM (Local).
//    Converted '2008-06-11T16:11:20.0904778Z' to 6/11/2008 4:11:20 PM (Utc).

Imports System.Globalization

Module Example
   Public Sub Main()
      Dim enUS As New CultureInfo("en-US") 
      Dim dateString As String
      Dim dateValue As Date
      
      ' Parse date with no style flags.
      dateString = " 5/01/2009 8:30 AM"
      Try
         dateValue = Date.ParseExact(dateString, "g", enUS, DateTimeStyles.None)
         Console.WriteLine("Converted '{0}' to {1} ({2}).", dateString, dateValue, _
                           dateValue.Kind)
      Catch e As FormatException
         Console.WriteLine("'{0}' is not in an acceptable format.", dateString)
      End Try
      ' Allow a leading space in the date string.
      Try
         dateValue = Date.ParseExact(dateString, "g", enUS, DateTimeStyles.AllowLeadingWhite)
         Console.WriteLine("Converted '{0}' to {1} ({2}).", dateString, dateValue, _
                           dateValue.Kind)
      Catch e As FormatException
         Console.WriteLine("'{0}' is not in an acceptable format.", dateString)
      End Try
      
      ' Use custom formats with M and MM.
      dateString = "5/01/2009 09:00"
      Try
         dateValue = Date.ParseExact(dateString, "M/dd/yyyy hh:mm", enUS, DateTimeStyles.None)
         Console.WriteLine("Converted '{0}' to {1} ({2}).", dateString, dateValue, _
                           dateValue.Kind)
      Catch e As FormatException
         Console.WriteLine("'{0}' is not in an acceptable format.", dateString)
      End Try
      ' Allow a leading space in the date string.
      Try
         dateValue = Date.ParseExact(dateString, "MM/dd/yyyy hh:mm", enUS, DateTimeStyles.None)
         Console.WriteLine("Converted '{0}' to {1} ({2}).", dateString, dateValue, _
                           dateValue.Kind)
      Catch e As FormatException
         Console.WriteLine("'{0}' is not in an acceptable format.", dateString)
      End Try

      ' Parse a string with time zone information.
      dateString = "05/01/2009 01:30:42 PM -05:00" 
      Try
         dateValue = Date.ParseExact(dateString, "MM/dd/yyyy hh:mm:ss tt zzz", enUS, DateTimeStyles.None)
         Console.WriteLine("Converted '{0}' to {1} ({2}).", dateString, dateValue, _
                           dateValue.Kind)
      Catch e As FormatException
         Console.WriteLine("'{0}' is not in an acceptable format.", dateString)
      End Try
      ' Allow a leading space in the date string.
      Try
         dateValue = Date.ParseExact(dateString, "MM/dd/yyyy hh:mm:ss tt zzz", enUS, _
                                     DateTimeStyles.AdjustToUniversal)
         Console.WriteLine("Converted '{0}' to {1} ({2}).", dateString, dateValue, _
                           dateValue.Kind)
      Catch e As FormatException
         Console.WriteLine("'{0}' is not in an acceptable format.", dateString)
      End Try
           
      ' Parse a string representing UTC.
      dateString = "2008-06-11T16:11:20.0904778Z"
      Try
         dateValue = Date.ParseExact(dateString, "o", CultureInfo.InvariantCulture, _
                                     DateTimeStyles.None)
         Console.WriteLine("Converted '{0}' to {1} ({2}).", dateString, dateValue, _
                           dateValue.Kind)
      Catch e As FormatException
         Console.WriteLine("'{0}' is not in an acceptable format.", dateString)
      End Try
      Try
         dateValue = Date.ParseExact(dateString, "o", CultureInfo.InvariantCulture, _
                                     DateTimeStyles.RoundtripKind)
         Console.WriteLine("Converted '{0}' to {1} ({2}).", dateString, dateValue, _
                           dateValue.Kind)
      Catch e As FormatException
         Console.WriteLine("'{0}' is not in an acceptable format.", dateString)
      End Try
   End Sub
End Module
' The example displays the following output:
'    ' 5/01/2009 8:30 AM' is not in an acceptable format.
'    Converted ' 5/01/2009 8:30 AM' to 5/1/2009 8:30:00 AM (Unspecified).
'    Converted '5/01/2009 09:00' to 5/1/2009 9:00:00 AM (Unspecified).
'    '5/01/2009 09:00' is not in an acceptable format.
'    Converted '05/01/2009 01:30:42 PM -05:00' to 5/1/2009 11:30:42 AM (Local).
'    Converted '05/01/2009 01:30:42 PM -05:00' to 5/1/2009 6:30:42 PM (Utc).
'    Converted '2008-06-11T16:11:20.0904778Z' to 6/11/2008 9:11:20 AM (Local).
'    Converted '2008-06-11T16:11:20.0904778Z' to 6/11/2008 4:11:20 PM (Utc).

Açıklamalar

DateTime.ParseExact(String, String, IFormatProvider, DateTimeStyles) yöntemi, parametre tarafından tanımlanan bir biçimde olması gereken bir tarihin dize gösterimini format ayrıştırır. Ayrıca içindeki tarih ve saat öğelerinin s tarafından formatbelirtilen sırada gösterilmesini gerektirir. s parametresinin deseniyle format eşleşmiyorsa, parametresi tarafından style tanımlanan varyasyonlarla, yöntemi bir FormatExceptionoluşturur. Buna karşılık yöntemi, DateTime.Parse(String, IFormatProvider, DateTimeStyles) biçim sağlayıcısının DateTimeFormatInfo nesnesi tarafından tanınan biçimlerden herhangi birinde bir tarihin dize gösterimini ayrıştırır. yöntemi, DateTime.Parse(String, IFormatProvider, DateTimeStyles) içindeki s tarih ve saat öğelerinin herhangi bir sırada görünmesini de sağlar.

s Parametre yalnızca saat içeriyorsa ve tarih içermiyorsa, parametre bayrağını içermediği DateTimeStyles.NoCurrentDateDefault sürece style geçerli tarih kullanılır ve bu durumda varsayılan tarih (DateTime.Date.MinValue) kullanılır. s Parametre yalnızca tarih içeriyorsa ve saat içermiyorsa, gece yarısı (00:00:00) kullanılır. style parametresi ayrıca parametrenin s baştaki, iç veya sondaki boşluk karakterlerini içerip içeremeyeceğini de belirler.

Saat dilimi bilgisi içermiyorsa s , Kind döndürülen DateTime nesnenin özelliği olur DateTimeKind.Unspecified. Bu davranış, özelliği olan bir değeri döndüren bayrağı kullanılarak veya özelliği DateTimeKind.Utc DateTimeKind.Localolan bir DateTime Kind DateTime değer döndüren ve DateTimeStyles.AdjustToUniversal bayrakları kullanılarak DateTimeStyles.AssumeUniversal değiştirilebilir.DateTimeStyles.AssumeLocal Kind s Saat dilimi bilgilerini içeriyorsa, saat gerekirse yerel saate dönüştürülür ve Kind döndürülen DateTime nesnenin özelliği olarak DateTimeKind.Localayarlanır. Bu davranış, Eşgüdümlü Evrensel Saat 'i (UTC) yerel saate dönüştürmemek ve özelliğini DateTimeKind.Utcolarak ayarlamak Kind için bayrağı kullanılarak DateTimeStyles.RoundtripKind değiştirilebilir.

format parametresi, parametresinin gerekli desenini s tanımlar. Özel Tarih ve Saat Biçim Dizeleri tablosundaki bir veya daha fazla özel biçim tanımlayıcısından ya da Standart Tarih ve Saat Biçim Dizeleri tablosundan önceden tanımlanmış bir deseni tanımlayan tek bir standart biçim tanımlayıcısından oluşabilir.

Özel biçim deseninde tarih veya saat ayırıcıları kullanmıyorsanız, parametre için provider sabit kültürü ve her özel biçim tanımlayıcısının en geniş biçimini kullanın. Örneğin, düzende saatleri belirtmek istiyorsanız, dar kapsamlı "H" biçimi yerine daha geniş "HH" biçimini belirtin.

Not

Ayrıştırma işleminin başarılı olması için tek bir biçime uygun olmasını s gerektirmek yerine yöntemini çağırabilir DateTime.ParseExact(String, String[], IFormatProvider, DateTimeStyles) ve izin verilen birden çok biçim belirtebilirsiniz. Bu, ayrıştırma işleminin başarılı olma olasılığını daha yüksek hale getirir.

parametresi, styles tarafından tanımlanmayan format boşluğun DateTimeStyles içinde s görünüp görünmeyeceğini ve ayrıştırma işleminin kesin davranışını denetleyen bir veya daha fazla numaralandırma üyesini içerir. Aşağıdaki tabloda, numaralandırmanın her üyesinin DateTimeStyles yöntemin işlemini ParseExact(String, String, IFormatProvider, DateTimeStyles) nasıl etkilediği açıklanmaktadır.

DateTimeStyles üyesi	Açıklama
AdjustToUniversal	Ayrıştırıp `s` gerekirse UTC'ye dönüştürür. `s` Saat dilimi uzaklığı içeriyorsa veya saat dilimi bilgisi içermiyorsa `s` ancak `styles` bayrağı içeriyorsaDateTimeStyles.AssumeLocal, yöntemi dizeyi ayrıştırıyor, döndürülen DateTime değeri UTC'ye dönüştürmek için öğesini çağırıyor ToUniversalTime ve özelliğini olarak DateTimeKind.UtcayarlırKind. UTC'yi temsil ettiğini gösteriyorsa `s` veya saat dilimi bilgisi içermiyorsa `s` ancak `styles` bayrağını DateTimeStyles.AssumeUniversal içeriyorsa, yöntemi dizeyi ayrıştırıyor, döndürülen DateTime değerde saat dilimi dönüştürmesi gerçekleştirmez ve özelliğini olarak DateTimeKind.UtcayarlarKind. Diğer durumlarda, bayrağın hiçbir etkisi olmaz.
AllowInnerWhite	tarafından `format` tanımlanmayan boşluğun herhangi bir tek tarih veya saat öğesi arasında görünebileceğini belirtir.
AllowLeadingWhite	tarafından `format` tanımlanmayan boşluğun başında `s`görünebileceğini belirtir.
AllowTrailingWhite	tarafından `format` tanımlanmayan boşluğun sonunda `s`görünebileceğini belirtir.
AllowWhiteSpaces	tarafından `format`tanımlanmayan `s` baştaki, iç ve sondaki boşlukları içerebileceğini belirtir.
AssumeLocal	Herhangi bir saat dilimi bilgisi yoksa `s` , yerel saati temsil ettiğini varsayar. DateTimeStyles.AdjustToUniversal Bayrağı yoksa, Kind döndürülen DateTime değerin özelliği olarak DateTimeKind.Localayarlanır.
AssumeUniversal	Herhangi bir saat dilimi bilgisi yoksa `s` UTC'yi temsil ettiğini belirtir. DateTimeStyles.AdjustToUniversal Bayrağı yoksa yöntemi döndürülen değeri UTC'den yerel saate dönüştürür DateTime ve özelliğini olarak DateTimeKind.LocalayarlarKind.
NoCurrentDateDefault	`s` Tarih bilgisi olmayan bir saat içeriyorsa, dönüş değerinin tarihi olarak `DateTime.MinValue.Date`ayarlanır.
None	`s` parametresi varsayılan değerler kullanılarak ayrıştırılır. içinde `format` bulunandan başka boşluk yoktur. Tarih bileşeni yoksa `s` , döndürülen DateTime değerin tarihi 1/1/0001 olarak ayarlanır. Saat dilimi bilgisi içermiyorsa `s` , Kind döndürülen DateTime nesnenin özelliği olarak DateTimeKind.Unspecifiedayarlanır. içinde `s`saat dilimi bilgileri varsa, saat yerel saate dönüştürülür ve Kind döndürülen DateTime nesnenin özelliği olarak DateTimeKind.Localayarlanır.
RoundtripKind	Saat dilimi bilgilerini içeren dizeler için, özelliği olarak ayarlanmış bir DateTime değer tarih ve saatine Kind dönüştürmeyi engellemeye DateTimeKind.Localçalışır. Bu bayrak öncelikle UTC saatlerinin yerel saatlere dönüştürülmesini önler.

CultureInfo yorumlamak siçin kullanılan kültürü temsil eden bir nesne. DateTimeFormatInfo özelliği tarafından DateTimeFormat döndürülen nesne, içindeki ssembolleri ve biçimlendirmeyi tanımlar.
DateTimeFormatInfo Tarih ve saat verilerinin biçimini tanımlayan nesne.
Yöntemi biçimlendirme bilgileri sağlayan nesneyi veya DateTimeFormatInfo nesneyi döndüren CultureInfo özel IFormatProvider bir uygulamaGetFormat.

ise providernull, CultureInfo geçerli kültüre karşılık gelen nesne kullanılır.

Arayanlara Notlar

Ayrıca bkz.

Şunlara uygulanır

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

Kaynak:: DateTime.cs

Kaynak:: DateTime.cs

Kaynak:: DateTime.cs

Belirtilen biçim dizisini, kültüre özgü biçim bilgilerini ve stili kullanarak bir tarih ve saatin belirtilen dize gösterimini DateTime eşdeğerine dönüştürür. Dize gösteriminin biçimi, belirtilen biçimlerden en az biriyle tam olarak eşleşmelidir veya bir özel durum oluşturulur.

public:
 static DateTime ParseExact(System::String ^ s, cli::array <System::String ^> ^ formats, IFormatProvider ^ provider, System::Globalization::DateTimeStyles style);

public static DateTime ParseExact (string s, string[] formats, IFormatProvider provider, System.Globalization.DateTimeStyles style);

public static DateTime ParseExact (string s, string[] formats, IFormatProvider? provider, System.Globalization.DateTimeStyles style);

static member ParseExact : string * string[] * IFormatProvider * System.Globalization.DateTimeStyles -> DateTime

Public Shared Function ParseExact (s As String, formats As String(), provider As IFormatProvider, style As DateTimeStyles) As DateTime

Parametreler

s: String

Dönüştürülecek bir tarih ve saat içeren bir dize.

formats: String[]

İzin verilebilen biçimlerden oluşan bir sdizi. Daha fazla bilgi için Açıklamalar bölümüne bakın.

provider: IFormatProvider

hakkında skültüre özgü biçim bilgileri sağlayan bir nesne.

style: DateTimeStyles

İzin verilen biçimini gösteren sabit listesi değerlerinin bit düzeyinde birleşimi s. Belirtilmesi gereken tipik bir değerdir None.

Döndürülenler

DateTime

, ve styletarafından formatsproviderbelirtildiği gibi içinde sbulunan tarih ve saate eşdeğer bir nesne.

Özel durumlar

ArgumentNullException

s veya formats şeklindedir null.

FormatException

s boş bir dizedir.

-veya-

öğesi formats boş bir dizedir.

-veya-

s öğesinin herhangi bir öğesine formatskarşılık gelen bir tarih ve saat içermez.

-veya-

içindeki saat bileşeni ve AM/PM göstergesi s aynı fikirde değildir.

ArgumentException

style geçersiz değer bileşimi DateTimeStyles içeriyor. Örneğin, hem AssumeUniversalhem de AssumeLocal .

Örnekler

Aşağıdaki örnek, bir dizi olası biçimdeki bir dizenin başarıyla ayrıştırılabilmesini sağlamak için yöntemini kullanır DateTime.ParseExact(String, String[], IFormatProvider, DateTimeStyles) .

using System;
using System.Globalization;

public class Example
{
   public static void Main()
   {
      string[] formats= {"M/d/yyyy h:mm:ss tt", "M/d/yyyy h:mm tt",
                         "MM/dd/yyyy hh:mm:ss", "M/d/yyyy h:mm:ss",
                         "M/d/yyyy hh:mm tt", "M/d/yyyy hh tt",
                         "M/d/yyyy h:mm", "M/d/yyyy h:mm",
                         "MM/dd/yyyy hh:mm", "M/dd/yyyy hh:mm",
                         "MM/d/yyyy HH:mm:ss.ffffff" };
      string[] dateStrings = {"5/1/2009 6:32 PM", "05/01/2009 6:32:05 PM",
                              "5/1/2009 6:32:00", "05/01/2009 06:32",
                              "05/01/2009 06:32:00 PM", "05/01/2009 06:32:00",
                              "08/28/2015 16:17:39.125", "08/28/2015 16:17:39.125000" };
      DateTime dateValue;

      foreach (string dateString in dateStrings)
      {
         try {
            dateValue = DateTime.ParseExact(dateString, formats,
                                            new CultureInfo("en-US"),
                                            DateTimeStyles.None);
            Console.WriteLine("Converted '{0}' to {1}.", dateString, dateValue);
         }
         catch (FormatException) {
            Console.WriteLine("Unable to convert '{0}' to a date.", dateString);
         }
      }
   }
}
// The example displays the following output:
//       Converted '5/1/2009 6:32 PM' to 5/1/2009 6:32:00 PM.
//       Converted '05/01/2009 6:32:05 PM' to 5/1/2009 6:32:05 PM.
//       Converted '5/1/2009 6:32:00' to 5/1/2009 6:32:00 AM.
//       Converted '05/01/2009 06:32' to 5/1/2009 6:32:00 AM.
//       Converted '05/01/2009 06:32:00 PM' to 5/1/2009 6:32:00 PM.
//       Converted '05/01/2009 06:32:00' to 5/1/2009 6:32:00 AM.
//       Unable to convert '08/28/2015 16:17:39.125' to a date.
//       Converted '08/28/2015 16:17:39.125000' to 8/28/2015 4:17:39 PM.

open System
open System.Globalization

let formats = 
    [| "M/d/yyyy h:mm:ss tt"; "M/d/yyyy h:mm tt"
       "MM/dd/yyyy hh:mm:ss"; "M/d/yyyy h:mm:ss"
       "M/d/yyyy hh:mm tt"; "M/d/yyyy hh tt"
       "M/d/yyyy h:mm"; "M/d/yyyy h:mm"
       "MM/dd/yyyy hh:mm"; "M/dd/yyyy hh:mm"
       "MM/d/yyyy HH:mm:ss.ffffff" |]

let dateStrings = 
    [ "5/1/2009 6:32 PM"; "05/01/2009 6:32:05 PM"
      "5/1/2009 6:32:00"; "05/01/2009 06:32"
      "05/01/2009 06:32:00 PM"; "05/01/2009 06:32:00"
      "08/28/2015 16:17:39.125"; "08/28/2015 16:17:39.125000" ]

for dateString in dateStrings do
    try
        let dateValue = DateTime.ParseExact(dateString, formats, CultureInfo "en-US", DateTimeStyles.None)
        printfn $"Converted '{dateString}' to {dateValue}."
    with :? FormatException ->
        printfn $"Unable to convert '{dateString}' to a date."

// The example displays the following output:
//       Converted '5/1/2009 6:32 PM' to 5/1/2009 6:32:00 PM.
//       Converted '05/01/2009 6:32:05 PM' to 5/1/2009 6:32:05 PM.
//       Converted '5/1/2009 6:32:00' to 5/1/2009 6:32:00 AM.
//       Converted '05/01/2009 06:32' to 5/1/2009 6:32:00 AM.
//       Converted '05/01/2009 06:32:00 PM' to 5/1/2009 6:32:00 PM.
//       Converted '05/01/2009 06:32:00' to 5/1/2009 6:32:00 AM.
//       Unable to convert '08/28/2015 16:17:39.125' to a date.
//       Converted '08/28/2015 16:17:39.125000' to 8/28/2015 4:17:39 PM.

Imports System.Globalization

Module Example
   Public Sub Main()
      Dim formats() As String = {"M/d/yyyy h:mm:ss tt", "M/d/yyyy h:mm tt", _
                                 "MM/dd/yyyy hh:mm:ss", "M/d/yyyy h:mm:ss", _
                                 "M/d/yyyy hh:mm tt", "M/d/yyyy hh tt", _
                                 "M/d/yyyy h:mm", "M/d/yyyy h:mm", _
                                 "MM/dd/yyyy hh:mm", "M/dd/yyyy hh:mm",
                                 "MM/d/yyyy HH:mm:ss.ffffff" }
      Dim dateStrings() As String = {"5/1/2009 6:32 PM", "05/01/2009 6:32:05 PM", _
                                     "5/1/2009 6:32:00", "05/01/2009 06:32", _
                                     "05/01/2009 06:32:00 PM", "05/01/2009 06:32:00",
                                     "08/28/2015 16:17:39.125", "08/28/2015 16:17:39.125000" }

      Dim dateValue As DateTime
      
      For Each dateString As String In dateStrings
         Try
            dateValue = DateTime.ParseExact(dateString, formats, _
                                            New CultureInfo("en-US"), _
                                            DateTimeStyles.None)
            Console.WriteLine("Converted '{0}' to {1}.", dateString, dateValue)
         Catch e As FormatException
            Console.WriteLine("Unable to convert '{0}' to a date.", dateString)
         End Try                                               
      Next
   End Sub
End Module
' The example displays the following output:
'       Converted '5/1/2009 6:32 PM' to 5/1/2009 6:32:00 PM.
'       Converted '05/01/2009 6:32:05 PM' to 5/1/2009 6:32:05 PM.
'       Converted '5/1/2009 6:32:00' to 5/1/2009 6:32:00 AM.
'       Converted '05/01/2009 06:32' to 5/1/2009 6:32:00 AM.
'       Converted '05/01/2009 06:32:00 PM' to 5/1/2009 6:32:00 PM.
'       Converted '05/01/2009 06:32:00' to 5/1/2009 6:32:00 AM.
'       Unable to convert '08/28/2015 16:17:39.125' to a date.
'       Converted '08/28/2015 16:17:39.125000' to 8/28/2015 4:17:39 PM.

Açıklamalar

yöntemi, DateTime.ParseExact(String, String[], IFormatProvider, DateTimeStyles) parametreye atanan desenlerden herhangi biriyle eşleşen bir tarihin dize gösterimini formats ayrıştırır. Dize s bu desenlerden herhangi biriyle parametresi tarafından styles tanımlanan varyasyonlardan herhangi biriyle eşleşmiyorsa, yöntemi bir FormatExceptionoluşturur. Bu aşırı yükleme, tek bir biçimlendirme deseni yerine birden çok biçimlendirme deseni ile karşılaştırmanın s yanı sıra yöntemiyle DateTime.ParseExact(String, String, IFormatProvider, DateTimeStyles) aynı şekilde davranır.

s parametresi ayrıştırmak için tarih ve saati içerir. s Parametre yalnızca saat içeriyorsa ve tarih içermiyorsa, parametre bayrağını içermediği DateTimeStyles.NoCurrentDateDefault sürece style geçerli tarih kullanılır ve bu durumda varsayılan tarih (DateTime.Date.MinValue) kullanılır. s Parametre yalnızca tarih içeriyorsa ve saat içermiyorsa, gece yarısı (00:00:00) kullanılır. style parametresi ayrıca parametresinin s içindeki biçim dizelerinden biri tarafından izin verilenler dışında baştaki, iç veya sondaki boşluk karakterlerini formatsiçerip içeremeyeceğini de belirler.

formats parametresi, ayrıştırma işleminin başarılı olması durumunda tam s olarak eşleşmesi gereken bir desen dizisi içerir. Parametredeki formats desenler , Özel Tarih ve Saat Biçim Dizeleri tablosundaki bir veya daha fazla özel biçim tanımlayıcısından veya Standart Tarih ve Saat Biçim Dizeleri tablosundan önceden tanımlanmış bir deseni tanımlayan tek bir standart biçim tanımlayıcısından oluşur.

DateTimeStyles üyesi	Açıklama
AdjustToUniversal	Ayrıştırıp `s` gerekirse UTC'ye dönüştürür. `s` Saat dilimi uzaklığı içeriyorsa veya saat dilimi bilgisi içermiyorsa `s` ancak `styles` bayrağı içeriyorsaDateTimeStyles.AssumeLocal, yöntemi dizeyi ayrıştırıyor, döndürülen DateTime değeri UTC'ye dönüştürmek için öğesini çağırıyor ToUniversalTime ve özelliğini olarak DateTimeKind.UtcayarlırKind. UTC'yi temsil ettiğini gösteriyorsa `s` veya saat dilimi bilgisi içermiyorsa `s` ancak `styles` bayrağını DateTimeStyles.AssumeUniversal içeriyorsa, yöntemi dizeyi ayrıştırıyor, döndürülen DateTime değerde saat dilimi dönüştürmesi gerçekleştirmez ve özelliğini olarak DateTimeKind.UtcayarlarKind. Diğer durumlarda, bayrağın hiçbir etkisi olmaz.
AllowInnerWhite	tarafından `format` tanımlanmayan boşluğun herhangi bir tek tarih veya saat öğesi arasında görünebileceğini belirtir.
AllowLeadingWhite	tarafından `format` tanımlanmayan boşluğun başında `s`görünebileceğini belirtir.
AllowTrailingWhite	tarafından `format` tanımlanmayan boşluğun sonunda `s`görünebileceğini belirtir.
AllowWhiteSpaces	tarafından `format`tanımlanmayan `s` baştaki, iç ve sondaki boşlukları içerebileceğini belirtir.
AssumeLocal	Herhangi bir saat dilimi bilgisi yoksa `s` , yerel saati temsil ettiğini varsayar. DateTimeStyles.AdjustToUniversal Bayrağı yoksa, Kind döndürülen DateTime değerin özelliği olarak DateTimeKind.Localayarlanır.
AssumeUniversal	Herhangi bir saat dilimi bilgisi yoksa `s` UTC'yi temsil ettiğini belirtir. DateTimeStyles.AdjustToUniversal Bayrağı yoksa yöntemi döndürülen değeri UTC'den yerel saate dönüştürür DateTime ve özelliğini olarak DateTimeKind.LocalayarlarKind.
NoCurrentDateDefault	`s` Tarih bilgisi olmayan bir saat içeriyorsa, dönüş değerinin tarihi olarak `DateTime.MinValue.Date`ayarlanır.
None	`s` parametresi varsayılan değerler kullanılarak ayrıştırılır. içinde `format` bulunandan başka boşluk yoktur. Tarih bileşeni yoksa `s` , döndürülen DateTime değerin tarihi 1/1/0001 olarak ayarlanır. Saat dilimi bilgisi içermiyorsa `s` , Kind döndürülen DateTime nesnenin özelliği olarak DateTimeKind.Unspecifiedayarlanır. içinde `s`saat dilimi bilgileri varsa, saat yerel saate dönüştürülür ve Kind döndürülen DateTime nesnenin özelliği olarak DateTimeKind.Localayarlanır.
RoundtripKind	Saat dilimi bilgilerini içeren dizeler için, özelliği olarak ayarlanmış bir tarih ve saate Kind dönüştürmeyi engellemeye DateTimeKind.Localçalışır. Bu bayrak öncelikle UTC saatlerinin yerel saatlere dönüştürülmesini önler.

içinde kullanılan s belirli tarih ve saat simgeleri ve dizeleri (belirli bir dildeki haftanın günlerinin adları gibi), standart biçim tanımlayıcı dizesiyse format tam biçimi s olduğu gibi parametresi tarafından provider tanımlanır. provider parametresi aşağıdakilerden biri olabilir:

CultureInfo yorumlamak siçin kullanılan kültürü temsil eden bir nesne. DateTimeFormatInfo özelliği tarafından DateTimeFormat döndürülen nesne, içindeki ssembolleri ve biçimlendirmeyi tanımlar.
DateTimeFormatInfo Tarih ve saat verilerinin biçimini tanımlayan bir nesne.
Yöntemi, biçimlendirme bilgilerini sağlayan nesneyi veya DateTimeFormatInfo nesneyi döndüren CultureInfo özel IFormatProvider bir uygulamaGetFormat.

ise providernull, CultureInfo geçerli kültüre karşılık gelen nesne kullanılır.

Arayanlara Notlar

.NET Framework 4'te yöntemi, ParseExact ayrıştırılacak dizenin bir saat bileşeni ve anlaşmada olmayan bir AM/PM belirteci içermesi durumunda bir oluştururFormatException. .NET Framework 3.5 ve önceki sürümlerde AM/PM göstergesi yoksayılır.

Ayrıca bkz.

Şunlara uygulanır

Aracılığıyla paylaş

DateTime.ParseExact Yöntem

Tanım

Aşırı Yüklemeler

Açıklamalar

ParseExact(String, String, IFormatProvider)

Parametreler

Döndürülenler

Özel durumlar

Örnekler

Açıklamalar

Arayanlara Notlar

Ayrıca bkz.

Şunlara uygulanır

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

Parametreler

Döndürülenler

Şunlara uygulanır

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

Parametreler

Döndürülenler

Şunlara uygulanır

ParseExact(String, String, IFormatProvider, DateTimeStyles)

Parametreler

Döndürülenler

Özel durumlar

Örnekler

Açıklamalar

Arayanlara Notlar

Ayrıca bkz.

Şunlara uygulanır

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

Parametreler

Döndürülenler

Özel durumlar

Örnekler

Açıklamalar

Arayanlara Notlar

Ayrıca bkz.

Şunlara uygulanır

Ek kaynaklar