DateTime.Parse Yöntem

Tanım

Ad Alanı:

System

Bütünleştirilmiş Kod:

System.Runtime.dll

Bir tarih ve saatin dize gösterimini DateTime eşdeğerine dönüştürür.

Aşırı Yüklemeler

Parse(String)	Geçerli kültürün kurallarını kullanarak bir tarih ve saatin dize gösterimini DateTime eşdeğerine dönüştürür.
Parse(ReadOnlySpan<Char>, IFormatProvider)	Bir karakter aralığını bir değere ayrıştırıyor.
Parse(String, IFormatProvider)	Kültüre özgü biçim bilgilerini kullanarak tarih ve saatin dize gösterimini DateTime eşdeğerine dönüştürür.
Parse(ReadOnlySpan<Char>, IFormatProvider, DateTimeStyles)	Kültüre özgü biçim bilgilerini ve biçimlendirme stilini kullanarak tarih ve saatin dize gösterimini içeren bellek aralığını DateTime eşdeğerine dönüştürür.
Parse(String, IFormatProvider, DateTimeStyles)	Kültüre özgü biçim bilgilerini ve biçimlendirme stilini kullanarak tarih ve saatin dize gösterimini DateTime eşdeğerine dönüştürür.

Örnekler

DateTime.Parse yöntemini çağıran çok sayıda örnek, bu makalenin Açıklamalar bölümünde ve tek tek DateTime.Parse aşırı yüklemeleri için belgelerde yer almaktadır.

Not

Bu makaledeki bazı C# örnekleri Try.NET satır içi kod çalıştırıcısında ve oyun alanında çalıştırılır. Etkileşimli bir pencerede örnek çalıştırmak için Çalıştır'ı seçin. Kodu yürüttkten sonra, yeniden çalıştır'ı seçerek kodu değiştirebilir ve değiştirilen kodu çalıştırabilirsiniz. Değiştirilen kod etkileşimli pencerede çalışır veya derleme başarısız olursa, etkileşimli pencerede tüm C# derleyicisi hata iletileri görüntülenir.

Try.NET satır içi kod çalıştırıcısının ve oyun alanının yerel saat dilimi Eşgüdümlü Evrensel Saat veya UTC'dir. Bu, DateTime, DateTimeOffsetve TimeZoneInfo türlerini ve üyelerini gösteren örneklerin davranışını ve çıkışını etkileyebilir.

C#için bir .NET Core projesine dahil edilen eksiksiz bir örnekleri kümesini de indirebilirsiniz.

Açıklamalar

Bu bölümde:

• Hangi yöntemi çağırmalıyım?
• ayrıştırmak için dize
• Ayrıştırma ve kültürel kongreler
• Ayrıştırma ve stil öğelerini
• Dönüş değeri ve DateTime.Kind

Hangi yöntemi çağırmalıyım?

Hedef	Çağırmak
Geçerli kültürün kurallarını kullanarak bir tarih ve saat dizesini ayrıştırın.	Parse(String) aşırı yüklemesi
Belirli bir kültürün kurallarını kullanarak bir tarih ve saat dizesini ayrıştırın.	Parse(String, IFormatProvider) aşırı yükleme (bkz. Ayrıştırma ve Kültürel Kurallar)
Tarih ve saat dizesini özel stil öğeleriyle ayrıştırma (boşluk veya boşluk olmaması gibi).	Parse(String, IFormatProvider, DateTimeStyles) aşırı yüklemesi
Belirli bir biçimde olması gereken tarih ve saat dizesini ayrıştırma.	DateTime.ParseExact veya DateTime.TryParseExact
Tarih ve saat dizesini ayrıştırın ve UTC veya yerel saate dönüştürme gerçekleştirin.	Parse(String, IFormatProvider, DateTimeStyles) aşırı yüklemesi
Özel durumları işlemeden bir tarih ve saat dizesini ayrıştırma.	DateTime.TryParse yöntemi
Biçimlendirme işlemi tarafından oluşturulan tarih ve saat değerini geri yükleme (gidiş dönüş).	"o" veya "r" standart biçim dizesini ToString(String) yöntemine geçirin ve DateTimeStyles.RoundtripKind ile Parse(String, IFormatProvider, DateTimeStyles) aşırı yüklemesini çağırın
Tarih ve saat dizesini makine (ve muhtemelen kültürel) sınırları arasında sabit bir biçimde ayrıştırma.	DateTime.ParseExact veya DateTime.TryParseExact yöntemi

Ayrıştırmak için dize

Parse yöntemi, bir tarih ve saat değerinin dize gösterimini DateTime eşdeğerine dönüştürmeye çalışır. Bir FormatException özel durumu oluşturmadan giriş dizesini tamamen ayrıştırmaya çalışır.

Önemli

Ayrıştırma işlemi tanınmayan bir dize biçimi nedeniyle başarısız olursa, Parse yöntemi bir FormatExceptionoluştururken, TryParse yöntemi falsedöndürür. Özel durum işleme pahalı olabileceğinden, giriş kaynağına güvenildiğinden ayrıştırma işleminin başarılı olması beklendiğinde Parse kullanmanız gerekir. TryParse, özellikle de bir giriş kaynağına güvenilmediğinden veya başarıyla ayrıştırılmayan dizelerin yerine geçecek makul varsayılan değerlere sahip olduğunuzda hata ayrıştırma olasılığı yüksek olduğunda tercih edilir.

Ayrıştırılacak dize aşağıdaki formlardan herhangi birini alabilir:

• Tarih ve saat bileşenine sahip bir dize.

• Tarih içeren ancak saat bileşeni olmayan bir dize. Saat bileşeni yoksa, yöntem gece yarısı 12:00 olduğunu varsayar. Tarih bileşeni iki basamaklı bir yıla sahipse, geçerli kültürün geçerli takviminin veya belirtilen kültürün geçerli takviminin Calendar.TwoDigitYearMax (null olmayan bir provider bağımsız değişkeniyle aşırı yükleme kullanıyorsanız) temel alınarak bir yıla dönüştürülür.

• Yalnızca ay ve yıl içeren ancak gün bileşeni içermeyen tarih bileşenine sahip bir dize. yöntemi, ayın ilk günü olduğunu varsayar.

• Yalnızca ay ve günü içeren ancak yıl bileşeni içermeyen tarih bileşenine sahip bir dize. yöntemi geçerli yılı varsayar.

• Saat içeren ancak tarih bileşeni olmayan bir dize. yöntemi, Parse(String, IFormatProvider, DateTimeStyles) aşırı yüklemesini çağırmadığınız ve styles bağımsız değişkenine DateTimeStyles.NoCurrentDateDefault dahil etmediğiniz sürece geçerli tarihi varsayar; bu durumda yöntem 1 Ocak 0001 tarihini kabul eder.

• Tarih bileşeni olmayan, yalnızca saati ve/PM belirleyicisini içeren saat bileşenine sahip bir dize. yöntemi geçerli tarihi ve dakikasız ve saniyesiz bir saati varsayar. Parse(String, IFormatProvider, DateTimeStyles) aşırı yüklemesini çağırarak ve styles bağımsız değişkenine DateTimeStyles.NoCurrentDateDefault ekleyerek bu davranışı değiştirebilirsiniz; bu durumda yöntem 1 Ocak 0001 tarihini varsayar.

• Saat dilimi bilgilerini içeren ve ISO 8601'e uyan bir dize. Aşağıdaki örneklerde, ilk dize Eşgüdümlü Evrensel Saat (UTC) belirtir ve ikincisi utc'den yedi saat önceki bir saat diliminde saati belirtir:

  "2008-11-01T19:35:00.0000000Z" "2008-11-01T19:35:00.0000000-07:00"

• GMT belirleyicisini içeren ve RFC 1123 saat biçimine uyan bir dize; mesela:

  "Sat, 01 Nov 2008 19:35:00 GMT"

• Saat dilimi uzaklığı bilgileriyle birlikte tarih ve saati içeren bir dize; mesela:

  "03/01/2009 05:42:00 -5:00"

Aşağıdaki örnek, geçerli kültürün biçimlendirme kurallarını kullanarak bu biçimlerin her birindeki dizeleri ayrıştırmaktadır ve bu örnekte en-US kültürü verilmiştir:

using System;

public class Example
{
   public static void Main()
   {
      (string dateAsString, string description)[]  dateInfo = { ("08/18/2018 07:22:16", "String with a date and time component"),
                                                                ("08/18/2018", "String with a date component only"),
                                                                ("8/2018", "String with a month and year component only"),
                                                                ("8/18", "String with a month and day component only"),
                                                                ("07:22:16", "String with a time component only"),
                                                                ("7 PM", "String with an hour and AM/PM designator only"),
                                                                ("2018-08-18T07:22:16.0000000Z", "UTC string that conforms to ISO 8601"),
                                                                ("2018-08-18T07:22:16.0000000-07:00", "Non-UTC string that conforms to ISO 8601"),
                                                                ("Sat, 18 Aug 2018 07:22:16 GMT", "String that conforms to RFC 1123"),
                                                                ("08/18/2018 07:22:16 -5:00", "String with date, time, and time zone information" ) };

      Console.WriteLine($"Today is {DateTime.Now:d}\n");

      foreach (var item in dateInfo) {
         Console.WriteLine($"{item.description + ":",-52} '{item.dateAsString}' --> {DateTime.Parse(item.dateAsString)}");
      }
   }
}
// The example displays output like the following:
//   Today is 2/22/2018
//
//   String with a date and time component:               '08/18/2018 07:22:16' --> 8/18/2018 7:22:16 AM
//   String with a date component only:                   '08/18/2018' --> 8/18/2018 12:00:00 AM
//   String with a month and year component only:         '8/2018' --> 8/1/2018 12:00:00 AM
//   String with a month and day component only:          '8/18' --> 8/18/2018 12:00:00 AM
//   String with a time component only:                   '07:22:16' --> 2/22/2018 7:22:16 AM
//   String with an hour and AM/PM designator only:       '7 PM' --> 2/22/2018 7:00:00 PM
//   UTC string that conforms to ISO 8601:                '2018-08-18T07:22:16.0000000Z' --> 8/18/2018 12:22:16 AM
//   Non-UTC string that conforms to ISO 8601:            '2018-08-18T07:22:16.0000000-07:00' --> 8/18/2018 7:22:16 AM
//   String that conforms to RFC 1123:                    'Sat, 18 Aug 2018 07:22:16 GMT' --> 8/18/2018 12:22:16 AM
//   String with date, time, and time zone information:   '08/18/2018 07:22:16 -5:00' --> 8/18/2018 5:22:16 AM

module Parse6

open System

let  dateInfo = 
    [ "08/18/2018 07:22:16", "String with a date and time component"
      "08/18/2018", "String with a date component only"
      "8/2018", "String with a month and year component only"
      "8/18", "String with a month and day component only"
      "07:22:16", "String with a time component only"
      "7 PM", "String with an hour and AM/PM designator only"
      "2018-08-18T07:22:16.0000000Z", "UTC string that conforms to ISO 8601"
      "2018-08-18T07:22:16.0000000-07:00", "Non-UTC string that conforms to ISO 8601"
      "Sat, 18 Aug 2018 07:22:16 GMT", "String that conforms to RFC 1123"
      "08/18/2018 07:22:16 -5:00", "String with date, time, and time zone information" ]

printfn $"Today is {DateTime.Now:d}\n"

for dateAsString, description in dateInfo do
    printfn $"""{description + ":",-52} '{dateAsString}' --> {DateTime.Parse(dateAsString)}"""


// The example displays output like the following:
//   Today is 2/22/2018
//
//   String with a date and time component:               '08/18/2018 07:22:16' --> 8/18/2018 7:22:16 AM
//   String with a date component only:                   '08/18/2018' --> 8/18/2018 12:00:00 AM
//   String with a month and year component only:         '8/2018' --> 8/1/2018 12:00:00 AM
//   String with a month and day component only:          '8/18' --> 8/18/2018 12:00:00 AM
//   String with a time component only:                   '07:22:16' --> 2/22/2018 7:22:16 AM
//   String with an hour and AM/PM designator only:       '7 PM' --> 2/22/2018 7:00:00 PM
//   UTC string that conforms to ISO 8601:                '2018-08-18T07:22:16.0000000Z' --> 8/18/2018 12:22:16 AM
//   Non-UTC string that conforms to ISO 8601:            '2018-08-18T07:22:16.0000000-07:00' --> 8/18/2018 7:22:16 AM
//   String that conforms to RFC 1123:                    'Sat, 18 Aug 2018 07:22:16 GMT' --> 8/18/2018 12:22:16 AM
//   String with date, time, and time zone information:   '08/18/2018 07:22:16 -5:00' --> 8/18/2018 5:22:16 AM

Public Module Strings
   Public Sub Main()
      Dim dateInfo() As (dateAsString As String, description As String) = 
                     { ("08/18/2018 07:22:16", "String with a date and time component"),
                       ("08/18/2018", "String with a date component only"),
                       ("8/2018", "String with a month and year component only"),
                       ("8/18", "String with a month and day component only"),
                       ("07:22:16", "String with a time component only"),
                       ("7 PM", "String with an hour and AM/PM designator only"),
                       ("2018-08-18T07:22:16.0000000Z", "UTC string that conforms to ISO 8601"),   
                       ("2018-08-18T07:22:16.0000000-07:00", "Non-UTC string that conforms to ISO 8601"),
                       ("Sat, 18 Aug 2018 07:22:16 GMT", "String that conforms to RFC 1123"),
                       ("08/18/2018 07:22:16 -5:00", "String with date, time, and time zone information" ) }
   
      Console.WriteLine($"Today is {Date.Now:d}{vbCrLf}")
      
      For Each item in dateInfo
         Console.WriteLine($"{item.description + ":",-52} '{item.dateAsString}' --> {DateTime.Parse(item.dateAsString)}")        
      Next
   End Sub
End Module
' The example displays output like the following:
'   Today is 2/22/2018
'   
'   String with a date and time component:               '08/18/2018 07:22:16' --> 8/18/2018 7:22:16 AM
'   String with a date component only:                   '08/18/2018' --> 8/18/2018 12:00:00 AM
'   String with a month and year component only:         '8/2018' --> 8/1/2018 12:00:00 AM
'   String with a month and day component only:          '8/18' --> 8/18/2018 12:00:00 AM
'   String with a time component only:                   '07:22:16' --> 2/22/2018 7:22:16 AM
'   String with an hour and AM/PM designator only:       '7 PM' --> 2/22/2018 7:00:00 PM
'   UTC string that conforms to ISO 8601:                '2018-08-18T07:22:16.0000000Z' --> 8/18/2018 12:22:16 AM
'   Non-UTC string that conforms to ISO 8601:            '2018-08-18T07:22:16.0000000-07:00' --> 8/18/2018 7:22:16 AM
'   String that conforms to RFC 1123:                    'Sat, 18 Aug 2018 07:22:16 GMT' --> 8/18/2018 12:22:16 AM
'   String with date, time, and time zone information:   '08/18/2018 07:22:16 -5:00' --> 8/18/2018 5:22:16 AM

Giriş dizesi ayrıştırma yöntemi tarafından kullanılan takvimde artık yılda artık bir günü temsil ederse (bkz. Ayrıştırma ve kültürel kurallar), Parse yöntemi dizeyi başarıyla ayrıştırıyor. Giriş dizesi artık olmayan bir yılda artık bir günü temsil ederse, yöntemi bir FormatExceptionoluşturur.

Parse yöntemi geçerli veya belirtilen kültürün biçimlendirme kurallarını kullanarak bir tarih ve saatin dize gösterimini ayrıştırmaya çalıştığından, bir dizeyi farklı kültürler arasında ayrıştırmaya çalışmak başarısız olabilir. Belirli bir tarih ve saat biçimini farklı yerel ayarlar arasında ayrıştırmak için, DateTime.ParseExact yönteminin aşırı yüklemelerinden birini kullanın ve bir biçim tanımlayıcısı sağlayın.

Ayrıştırma ve kültürel kurallar

Ayrıştırılacak dize (aşağıdaki tabloda s ile temsil edilir) ISO 8601 desenine uymadığı sürece Parse yönteminin tüm aşırı yüklemeleri kültüre duyarlıdır. Ayrıştırma işlemi, aşağıdaki gibi türetilen bir DateTimeFormatInfo nesnesindeki biçimlendirme bilgilerini kullanır:

Önemli

Japon takvimlerindeki dönemler imparatorun saltanatına dayanır ve bu nedenle değişmesi beklenir. Örneğin, 1 Mayıs 2019, JapaneseCalendar ve JapaneseLunisolarCalendarReiwa döneminin başlangıcını işaretledi. Bu tür bir dönem 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. .NETJapon takviminde yeni bir çağı işleme. Zaman değişikliğine hazır olduğundan emin olmak için uygulamalarınızı Windows sistemlerinde test etme hakkında bilgi için bkz. Uygulamanızı Japon çağı değişikliğine hazırlama. .NET'te birden çok çağa sahip takvimleri destekleyen özellikler ve birden çok çağı destekleyen takvimlerle çalışırken en iyi yöntemler için bkz. Dönemlerle çalışma.

Eğer ararsanız	Ve provider	Biçimlendirme bilgileri şu kaynaktan türetilir:
Parse(String)	-	Geçerli kültür (DateTimeFormatInfo.CurrentInfo özelliği)
Parse(String, IFormatProvider) veya Parse(String, IFormatProvider, DateTimeStyles)	DateTimeFormatInfo nesnesi	Belirtilen DateTimeFormatInfo nesnesi
Parse(String, IFormatProvider) veya Parse(String, IFormatProvider, DateTimeStyles)	null	Geçerli kültür (DateTimeFormatInfo.CurrentInfo özelliği)
Parse(String, IFormatProvider) veya Parse(String, IFormatProvider, DateTimeStyles)	CultureInfo nesnesi	CultureInfo.DateTimeFormat özelliği
Parse(String, IFormatProvider) veya Parse(String, IFormatProvider, DateTimeStyles)	Özel IFormatProvider uygulaması	IFormatProvider.GetFormat yöntemi

Biçimlendirme bilgileri bir DateTimeFormatInfo nesnesinden türetildiğinde, DateTimeFormatInfo.Calendar özelliği ayrıştırma işleminde kullanılan takvimi tanımlar.

Tarih ve saat dizesini standart kültürün ayarlarından farklı özelleştirilmiş ayarlara sahip bir DateTimeFormatInfo nesnesi kullanarak ayrıştırırsanız, başarılı bir dönüştürme olasılığını artırmak için Parse yöntemi yerine ParseExact yöntemini kullanın. Standart olmayan bir tarih ve saat dizesi karmaşık ve ayrıştırılması zor olabilir. Parse yöntemi, bir dizeyi çeşitli örtük ayrıştırma desenleriyle ayrıştırmaya çalışır ve bunların tümü başarısız olabilir. Buna karşılık, ParseExact yöntemi başarılı olma olasılığı olan bir veya daha fazla ayrıştırma desenini açıkça belirlemenizi gerektirir. Daha fazla bilgi için DateTimeFormatInfo konusunun "DateTimeFormatInfo ve Dinamik Veriler" bölümüne bakın.

Önemli

Belirli bir kültür için biçimlendirme kurallarının dinamik olduğunu ve değiştirilebilir olabileceğini unutmayın. Bu, varsayılan (geçerli) kültürün biçimlendirme kurallarına bağlı olan veya sabit kültür dışında bir kültürü temsil eden bir IFormatProvider nesnesi belirten ayrıştırma işlemlerinin aşağıdakilerden biri gerçekleşirse beklenmedik bir şekilde başarısız olabileceği anlamına gelir:

• Kültüre özgü veriler, .NET Framework'ün ana veya ikincil sürümleri arasında ya da .NET Framework'ün var olan sürümüne yapılan bir güncelleştirmenin sonucu olarak değişmiştir.
• Kültüre özgü veriler, makineden makineye veya oturumdan oturuma farklılık gösterebilen kullanıcı tercihlerini yansıtır.
• Kültüre özgü veriler, standart kültürün veya özel kültürün ayarlarını geçersiz kılan bir değiştirme kültürünü temsil eder.

Kültürel verilerdeki değişikliklerle ilişkili veri ve saat dizelerini ayrıştırmada karşılaşılan zorlukları önlemek için, sabit kültürü kullanarak tarih ve saat dizelerini ayrıştırabilir veya ParseExact veya TryParseExact yöntemini çağırabilir ve ayrıştırılacak dizenin tam biçimini belirtebilirsiniz. Tarih ve saat verilerini seri hale getirir ve seri durumdan çıkarırsanız, sabit kültürün biçimlendirme kurallarını kullanabilir veya DateTime değerini ikili biçimde seri hale getirip seri durumdan çıkarabilirsiniz.

Daha fazla bilgi için CultureInfo konusunun "Dinamik kültür verileri" bölümüne ve DateTime konu başlığındaki "DateTime değerlerini kalıcı hale getirir" bölümüne bakın.

Ayrıştırma ve stil öğeleri

Tüm Parse aşırı yüklemeleri giriş dizesindeki baştaki, içteki veya sondaki boşluk karakterlerini yoksayar (aşağıdaki tabloda s gösterilir). Tarih ve saat, bir çift baştaki ve sondaki SAYI İşaretİ karakterleriyle ("#", U+0023) köşeli ayraç eklenebilir ve sonunda bir veya daha fazla NULL karakter (U+0000) bulunabilir.

Ek olarak, Parse(String, IFormatProvider, DateTimeStyles) aşırı yüklemesi, DateTimeStyles numaralandırmasının bir veya daha fazla üyesinden oluşan bir styles parametresine sahiptir. Bu parametre, s nasıl yorumlanması gerektiğini ve ayrıştırma işleminin s tarih ve saate nasıl dönüştürdüğünü tanımlar. Aşağıdaki tabloda her DateTimeStyles üyesinin ayrıştırma işlemi üzerindeki etkisi açıklanmaktadır.

DateTimeStyles üyesi	Dönüştürme üzerindeki etkisi
AdjustToUniversal	s ayrıştırarak gerekirse utc'ye dönüştürür: - s saat dilimi uzaklığı içeriyorsa veya s saat dilimi bilgisi içermiyorsa ancak stylesAssumeLocal bayrağı içeriyorsa, yöntem dizeyi ayrıştırıyor, döndürülen DateTime değerini UTC'ye dönüştürmek için ToUniversalTime çağırır ve Kind özelliğini DateTimeKind.Utcolarak ayarlar. - s UTC'yi temsil ettiğini gösteriyorsa veya s saat dilimi bilgilerini içermiyorsa ancak stylesAssumeUniversal bayrağını içeriyorsa, yöntem dizeyi ayrıştırıyor, döndürülen DateTime değerinde saat dilimi dönüştürmesi gerçekleştirmez ve Kind özelliğini DateTimeKind.Utcolarak ayarlar. - Diğer tüm durumlarda bayrağın hiçbir etkisi yoktur.
AllowInnerWhite	Bu değer yoksayılır. starih ve saat öğelerinde her zaman iç boşluklara izin verilir.
AllowLeadingWhite	Bu değer yoksayılır. starih ve saat öğelerinde her zaman baştaki boşluklara izin verilir.
AllowTrailingWhite	Bu değer yoksayılır. starih ve saat öğelerinde sondaki boşluklara her zaman izin verilir.
AllowWhiteSpaces	s baştaki, iç ve sondaki beyaz boşlukları içerebileceğini belirtir. Bu, varsayılan davranıştır. Nonegibi daha kısıtlayıcı bir DateTimeStyles numaralandırma değeri sağlayarak geçersiz kılınamaz.
AssumeLocal	s herhangi bir saat dilimi bilgisi yoksa yerel saatin varsayıldığını belirtir. AdjustToUniversal bayrağı yoksa, döndürülen DateTime değerinin Kind özelliği DateTimeKind.Localolarak ayarlanır.
AssumeUniversal	s herhangi bir saat dilimi bilgisi yoksa UTC varsayıldığını belirtir. AdjustToUniversal bayrağı yoksa yöntemi döndürülen DateTime değerini UTC'den yerel saate dönüştürür ve Kind özelliğini DateTimeKind.Localolarak ayarlar.
None	Geçerli olsa da, bu değer yoksayılır.
RoundtripKind	Saat dilimi bilgilerini içeren dizeler için, bir tarih ve saat dizesinin Kind özelliği DateTimeKind.Localolarak ayarlanmış yerel saati temsil eden bir DateTime değerine dönüştürülmesini engellemeye çalışır. Genellikle, böyle bir dize DateTime.ToString(String) yöntemi çağrılarak ve "o", "r" veya "u" standart biçim tanımlayıcısı kullanılarak oluşturulur.

Dönüş değeri ve DateTime.Kind

DateTime.Parse aşırı yüklemeleri, Kind özelliği saat dilimi bilgilerini içeren bir DateTime değeri döndürür. Saatin şu şekilde olduğunu gösterebilir:

• Eşgüdümlü Evrensel Saat (System.DateTimeKind.Utc).
• Yerel saat dilimindeki saat (System.DateTimeKind.Local).
• Bilinmeyen bir saat dilimindeki saat (System.DateTimeKind.Unspecified).

Genellikle, Parse yöntemi Kind özelliği DateTimeKind.Unspecifiedolan bir DateTime nesnesi döndürür. Ancak Parse yöntemi ayrıca saat dilimi dönüştürmesi gerçekleştirebilir ve s ve styles parametrelerinin değerlerine bağlı olarak Kind özelliğinin değerini farklı şekilde ayarlayabilir:

Eğer	Saat dilimi dönüştürme	Kind özelliği
s saat dilimi bilgilerini içerir.	Tarih ve saat, yerel saat dilimindeki saate dönüştürülür.	DateTimeKind.Local
s saat dilimi bilgilerini ve stylesAdjustToUniversal bayrağını içerir.	Tarih ve saat Eşgüdümlü Evrensel Saat'e (UTC) dönüştürülür.	DateTimeKind.Utc
s Z veya GMT saat dilimi belirleyicisini ve stylesRoundtripKind bayrağını içerir.	Tarih ve saat UTC olarak yorumlanır.	DateTimeKind.Utc

Aşağıdaki örnek, saat dilimi bilgilerini içeren tarih dizelerini yerel saat dilimindeki saate dönüştürür:

using System;

public class Example
{
   public static void Main()
   {
      string[] dateStrings = {"2008-05-01T07:34:42-5:00",
                              "2008-05-01 7:34:42Z",
                              "Thu, 01 May 2008 07:34:42 GMT"};
      foreach (string dateString in dateStrings)
      {
         DateTime convertedDate = DateTime.Parse(dateString);
         Console.WriteLine($"Converted {dateString} to {convertedDate.Kind} time {convertedDate}");
      }
   }
}
// These calls to the DateTime.Parse method display the following output:
//  Converted 2008-05-01T07:34:42-5:00 to Local time 5/1/2008 5:34:42 AM
//  Converted 2008-05-01 7:34:42Z to Local time 5/1/2008 12:34:42 AM
//  Converted Thu, 01 May 2008 07:34:42 GMT to Local time 5/1/2008 12:34:42 AM

open System

let dateStrings = 
    [ "2008-05-01T07:34:42-5:00"
      "2008-05-01 7:34:42Z"
      "Thu, 01 May 2008 07:34:42 GMT" ]

for dateString in dateStrings do
    let convertedDate = DateTime.Parse dateString
    printfn $"Converted {dateString} to {convertedDate.Kind} time {convertedDate}"

// These calls to the DateTime.Parse method display the following output:
//  Converted 2008-05-01T07:34:42-5:00 to Local time 5/1/2008 5:34:42 AM
//  Converted 2008-05-01 7:34:42Z to Local time 5/1/2008 12:34:42 AM
//  Converted Thu, 01 May 2008 07:34:42 GMT to Local time 5/1/2008 12:34:42 AM

Module Example
   Public Sub Main()
      Dim dateStrings() As String = {"2008-05-01T07:34:42-5:00", 
                                     "2008-05-01 7:34:42Z", 
                                     "Thu, 01 May 2008 07:34:42 GMT"}
      
      For Each dateStr In dateStrings
         Dim convertedDate As Date = Date.Parse(dateStr)
         Console.WriteLine($"Converted {dateStr} to {convertedDate.Kind} time {convertedDate}")
      Next 
   End Sub
End Module
' These calls to the DateTime.Parse method display the following output:
'   Converted 2008-05-01T07:34:42-5:00 to Local time 5/1/2008 5:34:42 AM
'   Converted 2008-05-01 7:34:42Z to Local time 5/1/2008 12:34:42 AM
'   Converted Thu, 01 May 2008 07:34:42 GMT to Local time 5/1/2008 12:34:42 AM

DateTimeStyles.RoundtripKind bayrağını kullanarak biçimlendirme ve ayrıştırma işlemi sırasında tarih ve saatin Kind özelliğinin değerini de koruyabilirsiniz. Aşağıdaki örnekte, RoundtripKind bayrağının "o", "r" veya "u" biçim tanımlayıcısı kullanılarak dizelere dönüştürülen DateTime değerlerde ayrıştırma işlemini nasıl etkilediği gösterilmektedir.

   string[] formattedDates = { "2008-09-15T09:30:41.7752486-07:00",
                               "2008-09-15T09:30:41.7752486Z",
                               "2008-09-15T09:30:41.7752486",
                               "2008-09-15T09:30:41.7752486-04:00",
                               "Mon, 15 Sep 2008 09:30:41 GMT" };
   foreach (string formattedDate in formattedDates)
   {
      Console.WriteLine(formattedDate);
      DateTime roundtripDate = DateTime.Parse(formattedDate, null,
                                              DateTimeStyles.RoundtripKind);
      Console.WriteLine($"   With RoundtripKind flag: {roundtripDate} {roundtripDate.Kind} time.");

      DateTime noRoundtripDate = DateTime.Parse(formattedDate, null,
                                                DateTimeStyles.None);
      Console.WriteLine($"   Without RoundtripKind flag: {noRoundtripDate} {noRoundtripDate.Kind} time.");
   }
// The example displays the following output:
//       2008-09-15T09:30:41.7752486-07:00
//          With RoundtripKind flag: 9/15/2008 9:30:41 AM Local time.
//          Without RoundtripKind flag: 9/15/2008 9:30:41 AM Local time.
//       2008-09-15T09:30:41.7752486Z
//          With RoundtripKind flag: 9/15/2008 9:30:41 AM Utc time.
//          Without RoundtripKind flag: 9/15/2008 2:30:41 AM Local time.
//       2008-09-15T09:30:41.7752486
//          With RoundtripKind flag: 9/15/2008 9:30:41 AM Unspecified time.
//          Without RoundtripKind flag: 9/15/2008 9:30:41 AM Unspecified time.
//       2008-09-15T09:30:41.7752486-04:00
//          With RoundtripKind flag: 9/15/2008 6:30:41 AM Local time.
//          Without RoundtripKind flag: 9/15/2008 6:30:41 AM Local time.
//       Mon, 15 Sep 2008 09:30:41 GMT
//          With RoundtripKind flag: 9/15/2008 9:30:41 AM Utc time.
//          Without RoundtripKind flag: 9/15/2008 2:30:41 AM Local time.

let formattedDates = 
    [ "2008-09-15T09:30:41.7752486-07:00"
      "2008-09-15T09:30:41.7752486Z"
      "2008-09-15T09:30:41.7752486"
      "2008-09-15T09:30:41.7752486-04:00"
      "Mon, 15 Sep 2008 09:30:41 GMT" ]

for formattedDate in formattedDates do
    printfn $"{formattedDate}"
    let roundtripDate = DateTime.Parse(formattedDate, null, DateTimeStyles.RoundtripKind)
    printfn $"   With RoundtripKind flag: {roundtripDate} {roundtripDate.Kind} time."

    let noRoundtripDate = DateTime.Parse(formattedDate, null, DateTimeStyles.None)
    printfn $"   Without RoundtripKind flag: {noRoundtripDate} {noRoundtripDate.Kind} time."

// The example displays the following output:
//       2008-09-15T09:30:41.7752486-07:00
//          With RoundtripKind flag: 9/15/2008 9:30:41 AM Local time.
//          Without RoundtripKind flag: 9/15/2008 9:30:41 AM Local time.
//       2008-09-15T09:30:41.7752486Z
//          With RoundtripKind flag: 9/15/2008 9:30:41 AM Utc time.
//          Without RoundtripKind flag: 9/15/2008 2:30:41 AM Local time.
//       2008-09-15T09:30:41.7752486
//          With RoundtripKind flag: 9/15/2008 9:30:41 AM Unspecified time.
//          Without RoundtripKind flag: 9/15/2008 9:30:41 AM Unspecified time.
//       2008-09-15T09:30:41.7752486-04:00
//          With RoundtripKind flag: 9/15/2008 6:30:41 AM Local time.
//          Without RoundtripKind flag: 9/15/2008 6:30:41 AM Local time.
//       Mon, 15 Sep 2008 09:30:41 GMT
//          With RoundtripKind flag: 9/15/2008 9:30:41 AM Utc time.
//          Without RoundtripKind flag: 9/15/2008 2:30:41 AM Local time.

Dim formattedDates() = { "2008-09-15T09:30:41.7752486-07:00", 
                           "2008-09-15T09:30:41.7752486Z",  
                           "2008-09-15T09:30:41.7752486",  
                           "2008-09-15T09:30:41.7752486-04:00", 
                           "Mon, 15 Sep 2008 09:30:41 GMT" }
For Each formattedDate In formattedDates
   Console.WriteLine(formattedDate)
   Dim roundtripDate = DateTime.Parse(formattedDate, Nothing,  
                                      DateTimeStyles.RoundtripKind)                        
   Console.WriteLine($"   With RoundtripKind flag: {roundtripDate} {roundtripDate.Kind} time.")                                          
   Dim noRoundtripDate = DateTime.Parse(formattedDate, Nothing,                                                                                                  DateTimeStyles.None)
   Console.WriteLine($"   Without RoundtripKind flag: {noRoundtripDate} {noRoundtripDate.Kind} time.")
Next         
' The example displays the following output:
'       2008-09-15T09:30:41.7752486-07:00
'          With RoundtripKind flag: 9/15/2008 9:30:41 AM Local time.
'          Without RoundtripKind flag: 9/15/2008 9:30:41 AM Local time.
'       2008-09-15T09:30:41.7752486Z
'          With RoundtripKind flag: 9/15/2008 9:30:41 AM Utc time.
'          Without RoundtripKind flag: 9/15/2008 2:30:41 AM Local time.
'       2008-09-15T09:30:41.7752486
'          With RoundtripKind flag: 9/15/2008 9:30:41 AM Unspecified time.
'          Without RoundtripKind flag: 9/15/2008 9:30:41 AM Unspecified time.
'       2008-09-15T09:30:41.7752486-04:00
'          With RoundtripKind flag: 9/15/2008 6:30:41 AM Local time.
'          Without RoundtripKind flag: 9/15/2008 6:30:41 AM Local time.
'       Mon, 15 Sep 2008 09:30:41 GMT
'          With RoundtripKind flag: 9/15/2008 9:30:41 AM Utc time.
'          Without RoundtripKind flag: 9/15/2008 2:30:41 AM Local time.

Parse(String)

Kaynak:

DateTime.cs

Geçerli kültürün kurallarını kullanarak bir tarih ve saatin dize gösterimini DateTime eşdeğerine dönüştürür.

public:
 static DateTime Parse(System::String ^ s);

public static DateTime Parse (string s);

static member Parse : string -> DateTime

Public Shared Function Parse (s As String) As DateTime

Parametreler

s

String

Dönüştürülecek tarih ve saati içeren dize. Daha fazla bilgi için bkz. ayrıştırmak için dize.

Döndürülenler

DateTime

siçinde yer alan tarih ve saate eşdeğer bir nesne.

Özel durumlar

ArgumentNullException

s null.

FormatException

s tarih ve saatin geçerli dize gösterimini içermez.

Örnekler

Aşağıdaki örnek, birkaç tarih ve saat değerinin dize gösterimini şu şekilde ayrıştırır:

• Örnek çıkışı oluşturmak için kullanılan bilgisayarın geçerli kültürünün biçimlendirme kurallarını sağlayan varsayılan biçim sağlayıcısını kullanma. Bu örnekteki çıktı, en-US kültürünün biçimlendirme kurallarını yansıtır.

• AllowWhiteSpacesvarsayılan stil değerini kullanma.

Yöntem başka bir kültürün biçimlendirme kurallarını kullanarak bir tarih ve saatin dize gösterimini ayrıştırmaya çalıştığında oluşan FormatException özel durumunu işler. Ayrıca geçerli kültürün biçimlendirme kurallarını kullanmayan bir tarih ve saat değerinin nasıl başarıyla ayrıştırıldığını da gösterir.

using System;
using System.Globalization;

public class DateTimeParser
{
   public static void Main()
   {
      // Assume the current culture is en-US.
      // The date is February 16, 2008, 12 hours, 15 minutes and 12 seconds.

      // Use standard en-US date and time value
      DateTime dateValue;
      string dateString = "2/16/2008 12:15:12 PM";
      try {
         dateValue = DateTime.Parse(dateString);
         Console.WriteLine("'{0}' converted to {1}.", dateString, dateValue);
      }
      catch (FormatException) {
         Console.WriteLine("Unable to convert '{0}'.", dateString);
      }

      // Reverse month and day to conform to the fr-FR culture.
      // The date is February 16, 2008, 12 hours, 15 minutes and 12 seconds.
      dateString = "16/02/2008 12:15:12";
      try {
         dateValue = DateTime.Parse(dateString);
         Console.WriteLine("'{0}' converted to {1}.", dateString, dateValue);
      }
      catch (FormatException) {
         Console.WriteLine("Unable to convert '{0}'.", dateString);
      }

      // Call another overload of Parse to successfully convert string
      // formatted according to conventions of fr-FR culture.
      try {
         dateValue = DateTime.Parse(dateString, new CultureInfo("fr-FR", false));
         Console.WriteLine("'{0}' converted to {1}.", dateString, dateValue);
      }
      catch (FormatException) {
         Console.WriteLine("Unable to convert '{0}'.", dateString);
      }

      // Parse string with date but no time component.
      dateString = "2/16/2008";
      try {
         dateValue = DateTime.Parse(dateString);
         Console.WriteLine("'{0}' converted to {1}.", dateString, dateValue);
      }
      catch (FormatException) {
         Console.WriteLine("Unable to convert '{0}'.", dateString);
      }
   }
}
// The example displays the following output to the console:
//       '2/16/2008 12:15:12 PM' converted to 2/16/2008 12:15:12 PM.
//       Unable to convert '16/02/2008 12:15:12'.
//       '16/02/2008 12:15:12' converted to 2/16/2008 12:15:12 PM.
//       '2/16/2008' converted to 2/16/2008 12:00:00 AM.

open System
open System.Globalization

[<EntryPoint>]
let main _ =
    // Assume the current culture is en-US.
    // The date is February 16, 2008, 12 hours, 15 minutes and 12 seconds.

    // Use standard en-US date and time value
    let dateString = "2/16/2008 12:15:12 PM"
    try
        let dateValue = DateTime.Parse dateString
        printfn $"'{dateString}' converted to {dateValue}."
    with :? FormatException ->
        printfn $"Unable to convert '{dateString}'."

    // Reverse month and day to conform to the fr-FR culture.
    // The date is February 16, 2008, 12 hours, 15 minutes and 12 seconds.
    let dateString = "16/02/2008 12:15:12"
    try
        let dateValue = DateTime.Parse dateString
        printfn $"'{dateString}' converted to {dateValue}."
    with :? FormatException ->
        Console.WriteLine("Unable to convert '{0}'.", dateString)

    // Call another overload of Parse to successfully convert string
    // formatted according to conventions of fr-FR culture.
    try
        let dateValue = DateTime.Parse(dateString, CultureInfo("fr-FR", false))
        printfn $"'{dateString}' converted to {dateValue}."
    with :? FormatException ->
        printfn $"Unable to convert '{dateString}'."

    // Parse string with date but no time component.
    let dateString = "2/16/2008"
    try
        let dateValue = DateTime.Parse dateString
        printfn $"'{dateString}' converted to {dateValue}."
    with :? FormatException ->
        printfn $"Unable to convert '{dateString}'."

    0

// The example displays the following output to the console:
//       '2/16/2008 12:15:12 PM' converted to 2/16/2008 12:15:12 PM.
//       Unable to convert '16/02/2008 12:15:12'.
//       '16/02/2008 12:15:12' converted to 2/16/2008 12:15:12 PM.
//       '2/16/2008' converted to 2/16/2008 12:00:00 AM.

Imports System.Globalization

Class DateTimeParser
   Public Shared Sub Main()
      ' Assume the current culture is en-US. 
      ' The date is February 16, 2008, 12 hours, 15 minutes and 12 seconds.

      ' Use standard en-US date and time value
      Dim dateValue As Date
      Dim dateString As String = "2/16/2008 12:15:12 PM"
      Try
         dateValue = Date.Parse(dateString)
         Console.WriteLine("'{0}' converted to {1}.", dateString, dateValue)
      Catch e As FormatException
         Console.WriteLine("Unable to convert '{0}'.", dateString)
      End Try
            
      ' Reverse month and day to conform to the fr-FR culture.
      ' The date is February 16, 2008, 12 hours, 15 minutes and 12 seconds.
      dateString = "16/02/2008 12:15:12"
      Try
         dateValue = Date.Parse(dateString)
         Console.WriteLine("'{0}' converted to {1}.", dateString, dateValue)
      Catch e As FormatException
         Console.WriteLine("Unable to convert '{0}'.", dateString)
      End Try

      ' Call another overload of Parse to successfully convert string
      ' formatted according to conventions of fr-FR culture.      
      Try
         dateValue = Date.Parse(dateString, New CultureInfo("fr-FR", False))
         Console.WriteLine("'{0}' converted to {1}.", dateString, dateValue)
      Catch e As FormatException
         Console.WriteLine("Unable to convert '{0}'.", dateString)
      End Try
      
      ' Parse string with date but no time component.
      dateString = "2/16/2008"
      Try
         dateValue = Date.Parse(dateString)
         Console.WriteLine("'{0}' converted to {1}.", dateString, dateValue)
      Catch e As FormatException
         Console.WriteLine("Unable to convert '{0}'.", dateString)
      End Try
   End Sub 
End Class 
' The example displays the following output to the console:
'       '2/16/2008 12:15:12 PM' converted to 2/16/2008 12:15:12 PM.
'       Unable to convert '16/02/2008 12:15:12'.
'       '16/02/2008 12:15:12' converted to 2/16/2008 12:15:12 PM.
'       '2/16/2008' converted to 2/16/2008 12:00:00 AM.

Açıklamalar

s saat dilimi bilgileri içeriyorsa, bu yöntem Kind özelliği DateTimeKind.Local olan ve s tarih ve saati yerel saate dönüştüren bir DateTime değeri döndürür. Aksi takdirde, saat dilimi dönüştürmesi gerçekleştirmez ve Kind özelliği DateTimeKind.Unspecifiedolan bir DateTime değeri döndürür.

Bu aşırı yükleme, geçerli kültürün biçimlendirme kurallarını kullanarak s ayrıştırmaya çalışır. Geçerli kültür CurrentCulture özelliğiyle gösterilir. Belirli bir kültürün biçimlendirme kurallarını kullanarak bir dizeyi ayrıştırmak için Parse(String, IFormatProvider) veya Parse(String, IFormatProvider, DateTimeStyles) aşırı yüklemelerini çağırın.

Bu aşırı yükleme, DateTimeStyles.AllowWhiteSpaces stili kullanarak s ayrıştırmaya çalışır.

Ayrıca bkz.

• TryParse
• CultureInfo
• DateTimeFormatInfo
• .NET Framework Tarih ve Saat Dizelerini Ayrıştırma
• Standart Tarih ve Saat Biçim Dizelerini
• Özel Tarih ve Saat Biçim Dizeleri

Parse(ReadOnlySpan<Char>, IFormatProvider)

Kaynak:

DateTime.cs

Bir karakter aralığını bir değere ayrıştırıyor.

public:
 static DateTime Parse(ReadOnlySpan<char> s, IFormatProvider ^ provider) = ISpanParsable<DateTime>::Parse;

public static DateTime Parse (ReadOnlySpan<char> s, IFormatProvider? provider);

static member Parse : ReadOnlySpan<char> * IFormatProvider -> DateTime

Public Shared Function Parse (s As ReadOnlySpan(Of Char), provider As IFormatProvider) As DateTime

Parametreler

s

ReadOnlySpan<Char>

Ayrıştırılacak karakterlerin yayılma alanı.

provider

IFormatProvider

shakkında kültüre özgü biçimlendirme bilgileri sağlayan nesne.

Döndürülenler

DateTime

sayrıştırma sonucu.

Uygulamalar

Parse(ReadOnlySpan<Char>, IFormatProvider)

Parse(String, IFormatProvider)

Kaynak:

DateTime.cs

Kültüre özgü biçim bilgilerini kullanarak tarih ve saatin dize gösterimini DateTime eşdeğerine dönüştürür.

public:
 static DateTime Parse(System::String ^ s, IFormatProvider ^ provider) = IParsable<DateTime>::Parse;

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

static member Parse : string * IFormatProvider -> DateTime

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

Parametreler

s

String

Dönüştürülecek tarih ve saati içeren dize. Daha fazla bilgi için bkz. ayrıştırmak için dize.

provider

IFormatProvider

shakkında kültüre özgü biçim bilgileri sağlayan bir nesne. Bkz. Ayrıştırma ve kültürel kongreler

Döndürülenler

DateTime

providertarafından belirtilen s içinde yer alan tarih ve saate eşdeğer bir nesne.

Uygulamalar

Parse(String, IFormatProvider)

Özel durumlar

ArgumentNullException

s null.

FormatException

s tarih ve saatin geçerli dize gösterimini içermez.

Örnekler

Aşağıdaki örnek, en-US, fr-FRve de-DE kültürlerinin kurallarını kullanarak bir tarih dizeleri dizisini ayrıştırır. Tek bir tarihin dize gösterimlerinin farklı kültürler arasında farklı yorumlanabilir olduğunu gösterir.

using System;
using System.Globalization;

public class ParseDate
{
   public static void Main()
   {
      // Define cultures to be used to parse dates.
      CultureInfo[] cultures = {CultureInfo.CreateSpecificCulture("en-US"),
                                CultureInfo.CreateSpecificCulture("fr-FR"),
                                CultureInfo.CreateSpecificCulture("de-DE")};
      // Define string representations of a date to be parsed.
      string[] dateStrings = {"01/10/2009 7:34 PM",
                              "10.01.2009 19:34",
                              "10-1-2009 19:34" };
      // Parse dates using each culture.
      foreach (CultureInfo culture in cultures)
      {
         DateTime dateValue;
         Console.WriteLine("Attempted conversions using {0} culture.",
                           culture.Name);
         foreach (string dateString in dateStrings)
         {
            try {
               dateValue = DateTime.Parse(dateString, culture);
               Console.WriteLine("   Converted '{0}' to {1}.",
                                 dateString, dateValue.ToString("f", culture));
            }
            catch (FormatException) {
               Console.WriteLine("   Unable to convert '{0}' for culture {1}.",
                                 dateString, culture.Name);
            }
         }
         Console.WriteLine();
      }
   }
}
// The example displays the following output to the console:
//       Attempted conversions using en-US culture.
//          Converted '01/10/2009 7:34 PM' to Saturday, January 10, 2009 7:34 PM.
//          Converted '10.01.2009 19:34' to Thursday, October 01, 2009 7:34 PM.
//          Converted '10-1-2009 19:34' to Thursday, October 01, 2009 7:34 PM.
//
//       Attempted conversions using fr-FR culture.
//          Converted '01/10/2009 7:34 PM' to jeudi 1 octobre 2009 19:34.
//          Converted '10.01.2009 19:34' to samedi 10 janvier 2009 19:34.
//          Converted '10-1-2009 19:34' to samedi 10 janvier 2009 19:34.
//
//       Attempted conversions using de-DE culture.
//          Converted '01/10/2009 7:34 PM' to Donnerstag, 1. Oktober 2009 19:34.
//          Converted '10.01.2009 19:34' to Samstag, 10. Januar 2009 19:34.
//          Converted '10-1-2009 19:34' to Samstag, 10. Januar 2009 19:34.

open System
open System.Globalization

// Define cultures to be used to parse dates.
let cultures = 
    [ CultureInfo.CreateSpecificCulture "en-US"
      CultureInfo.CreateSpecificCulture "fr-FR"
      CultureInfo.CreateSpecificCulture "de-DE" ]

// Define string representations of a date to be parsed.
let dateStrings = 
    [ "01/10/2009 7:34 PM"
      "10.01.2009 19:34"
      "10-1-2009 19:34" ]

// Parse dates using each culture.
for culture in cultures do
    printfn $"Attempted conversions using {culture.Name} culture."
    for dateString in dateStrings do
        try
            let dateValue = DateTime.Parse(dateString, culture)
            printfn $"""   Converted '{dateString}' to {dateValue.ToString("f", culture)}."""
        with :? FormatException ->
            printfn $"   Unable to convert '{dateString}' for culture {culture.Name}." 
    printfn ""


// The example displays the following output to the console:
//       Attempted conversions using en-US culture.
//          Converted '01/10/2009 7:34 PM' to Saturday, January 10, 2009 7:34 PM.
//          Converted '10.01.2009 19:34' to Thursday, October 01, 2009 7:34 PM.
//          Converted '10-1-2009 19:34' to Thursday, October 01, 2009 7:34 PM.
//
//       Attempted conversions using fr-FR culture.
//          Converted '01/10/2009 7:34 PM' to jeudi 1 octobre 2009 19:34.
//          Converted '10.01.2009 19:34' to samedi 10 janvier 2009 19:34.
//          Converted '10-1-2009 19:34' to samedi 10 janvier 2009 19:34.
//
//       Attempted conversions using de-DE culture.
//          Converted '01/10/2009 7:34 PM' to Donnerstag, 1. Oktober 2009 19:34.
//          Converted '10.01.2009 19:34' to Samstag, 10. Januar 2009 19:34.
//          Converted '10-1-2009 19:34' to Samstag, 10. Januar 2009 19:34.

Imports System.Globalization

Module ParseDate
   Public Sub Main()
      ' Define cultures to be used to parse dates.
      Dim cultures() As CultureInfo = {CultureInfo.CreateSpecificCulture("en-US"), _
                                       CultureInfo.CreateSpecificCulture("fr-FR"), _
                                       CultureInfo.CreateSpecificCulture("de-DE")}
      ' Define string representations of a date to be parsed.
      Dim dateStrings() As String = {"01/10/2009 7:34 PM", _
                                     "10.01.2009 19:34", _
                                     "10-1-2009 19:34" }
      ' Parse dates using each culture.
      For Each culture In cultures
         Dim dateValue As Date
         Console.WriteLine("Attempted conversions using {0} culture.", culture.Name)
         For Each dateString As String In dateStrings
            Try
               dateValue = Date.Parse(dateString, culture)
               Console.WriteLine("   Converted '{0}' to {1}.", _
                                 dateString, dateValue.ToString("f", culture))
            Catch e As FormatException
               Console.WriteLine("   Unable to convert '{0}' for culture {1}.", _
                                 dateString, culture.Name)
            End Try                                                
         Next
         Console.WriteLine()
      Next                                                                                     
   End Sub
End Module
' The example displays the following output to the console:
'       Attempted conversions using en-US culture.
'          Converted '01/10/2009 7:34 PM' to Saturday, January 10, 2009 7:34 PM.
'          Converted '10.01.2009 19:34' to Thursday, October 01, 2009 7:34 PM.
'          Converted '10-1-2009 19:34' to Thursday, October 01, 2009 7:34 PM.
'       
'       Attempted conversions using fr-FR culture.
'          Converted '01/10/2009 7:34 PM' to jeudi 1 octobre 2009 19:34.
'          Converted '10.01.2009 19:34' to samedi 10 janvier 2009 19:34.
'          Converted '10-1-2009 19:34' to samedi 10 janvier 2009 19:34.
'       
'       Attempted conversions using de-DE culture.
'          Converted '01/10/2009 7:34 PM' to Donnerstag, 1. Oktober 2009 19:34.
'          Converted '10.01.2009 19:34' to Samstag, 10. Januar 2009 19:34.
'          Converted '10-1-2009 19:34' to Samstag, 10. Januar 2009 19:34.

Açıklamalar

s saat dilimi bilgileri içeriyorsa, bu yöntem Kind özelliği DateTimeKind.Local olan ve s tarih ve saati yerel saate dönüştüren bir DateTime değeri döndürür. Aksi takdirde, saat dilimi dönüştürmesi gerçekleştirmez ve Kind özelliği DateTimeKind.Unspecifiedolan bir DateTime değeri döndürür.

Bu aşırı yükleme, DateTimeStyles.AllowWhiteSpaces stilini kullanarak s ayrıştırmaya çalışır.

Ayrıca bkz.

• TryParse
• CultureInfo
• DateTimeFormatInfo
• .NET Framework Tarih ve Saat Dizelerini Ayrıştırma
• Standart Tarih ve Saat Biçim Dizelerini
• Özel Tarih ve Saat Biçim Dizeleri

Parse(ReadOnlySpan<Char>, IFormatProvider, DateTimeStyles)

Kaynak:

DateTime.cs

Kültüre özgü biçim bilgilerini ve biçimlendirme stilini kullanarak tarih ve saatin dize gösterimini içeren bellek aralığını DateTime eşdeğerine dönüştürür.

public static DateTime Parse (ReadOnlySpan<char> s, IFormatProvider? provider = default, System.Globalization.DateTimeStyles styles = System.Globalization.DateTimeStyles.None);

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

Public Shared Function Parse (s As ReadOnlySpan(Of Char), Optional provider As IFormatProvider = Nothing, Optional styles As DateTimeStyles = System.Globalization.DateTimeStyles.None) As DateTime

Parametreler

s

ReadOnlySpan<Char>

Ayrıştırılacak dizeyi içeren bellek aralığı. Daha fazla bilgi için bkz. ayrıştırmak için dize.

provider

IFormatProvider

shakkında kültüre özgü biçim bilgileri sağlayan bir nesne. Bkz. Ayrıştırma ve kültürel kongreler

styles

DateTimeStyles

Ayrıştırma işleminin başarılı olması için s içinde bulunabilecek stil öğelerini gösteren ve ayrıştırılan tarihin geçerli saat dilimiyle veya geçerli tarihle ilişkili olarak nasıl yorumlanabileceğini tanımlayan sabit listesi değerlerinin bit düzeyinde birleşimi. Belirtilmesi gereken tipik bir değer None.

Döndürülenler

DateTime

provider ve stylestarafından belirtildiği gibi siçinde bulunan tarih ve saate eşdeğer bir nesne.

Özel durumlar

FormatException

s tarih ve saatin geçerli dize gösterimini içermez.

ArgumentException

styles geçersiz bir DateTimeStyles değeri bileşimi içeriyor. Örneğin, hem AssumeLocal hem de AssumeUniversal.

Parse(String, IFormatProvider, DateTimeStyles)

Kaynak:

DateTime.cs

Kültüre özgü biçim bilgilerini ve biçimlendirme stilini kullanarak tarih ve saatin dize gösterimini DateTime eşdeğerine dönüştürür.

public:
 static DateTime Parse(System::String ^ s, IFormatProvider ^ provider, System::Globalization::DateTimeStyles styles);

public static DateTime Parse (string s, IFormatProvider? provider, System.Globalization.DateTimeStyles styles);

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

Public Shared Function Parse (s As String, provider As IFormatProvider, styles As DateTimeStyles) As DateTime

Parametreler

s

String

Dönüştürülecek tarih ve saati içeren dize. Daha fazla bilgi için bkz. ayrıştırmak için dize.

provider

IFormatProvider

shakkında kültüre özgü biçimlendirme bilgileri sağlayan bir nesne. Bkz. Ayrıştırma ve kültürel kongreler

styles

DateTimeStyles

Ayrıştırma işleminin başarılı olması için s içinde bulunabilecek stil öğelerini gösteren ve ayrıştırılan tarihin geçerli saat dilimiyle veya geçerli tarihle ilişkili olarak nasıl yorumlanabileceğini tanımlayan sabit listesi değerlerinin bit düzeyinde birleşimi. Belirtilmesi gereken tipik bir değer None.

Döndürülenler

DateTime

provider ve stylestarafından belirtildiği gibi siçinde bulunan tarih ve saate eşdeğer bir nesne.

Özel durumlar

ArgumentNullException

s null.

FormatException

s tarih ve saatin geçerli dize gösterimini içermez.

ArgumentException

styles geçersiz bir DateTimeStyles değeri bileşimi içeriyor. Örneğin, hem AssumeLocal hem de AssumeUniversal.

Örnekler

Aşağıdaki örnek, Parse(String, IFormatProvider, DateTimeStyles) yöntemini gösterir ve sonuçta elde edilen DateTime değerlerinin Kind özelliğinin değerini görüntüler.

using System;
using System.Globalization;

public class ParseDateExample
{
   public static void Main()
   {
      string dateString;
      CultureInfo culture ;
      DateTimeStyles styles;
      DateTime result;

      // Parse a date and time with no styles.
      dateString = "03/01/2009 10:00 AM";
      culture = CultureInfo.CreateSpecificCulture("en-US");
      styles = DateTimeStyles.None;
      try {
         result = DateTime.Parse(dateString, culture, styles);
         Console.WriteLine("{0} converted to {1} {2}.",
                           dateString, result, result.Kind.ToString());
      }
      catch (FormatException) {
         Console.WriteLine("Unable to convert {0} to a date and time.",
                           dateString);
      }

      // Parse the same date and time with the AssumeLocal style.
      styles = DateTimeStyles.AssumeLocal;
      try {
         result = DateTime.Parse(dateString, culture, styles);
         Console.WriteLine("{0} converted to {1} {2}.",
                           dateString, result, result.Kind.ToString());
      }
      catch (FormatException) {
         Console.WriteLine("Unable to convert {0} to a date and time.", dateString);
      }

      // Parse a date and time that is assumed to be local.
      // This time is five hours behind UTC. The local system's time zone is
      // eight hours behind UTC.
      dateString = "2009/03/01T10:00:00-5:00";
      styles = DateTimeStyles.AssumeLocal;
      try {
         result = DateTime.Parse(dateString, culture, styles);
         Console.WriteLine("{0} converted to {1} {2}.",
                           dateString, result, result.Kind.ToString());
      }
      catch (FormatException) {
         Console.WriteLine("Unable to convert {0} to a date and time.", dateString);
      }

      // Attempt to convert a string in improper ISO 8601 format.
      dateString = "03/01/2009T10:00:00-5:00";
      try {
         result = DateTime.Parse(dateString, culture, styles);
         Console.WriteLine("{0} converted to {1} {2}.",
                           dateString, result, result.Kind.ToString());
      }
      catch (FormatException) {
         Console.WriteLine("Unable to convert {0} to a date and time.", dateString);
      }

      // Assume a date and time string formatted for the fr-FR culture is the local
      // time and convert it to UTC.
      dateString = "2008-03-01 10:00";
      culture = CultureInfo.CreateSpecificCulture("fr-FR");
      styles = DateTimeStyles.AdjustToUniversal | DateTimeStyles.AssumeLocal;
      try {
         result = DateTime.Parse(dateString, culture, styles);
         Console.WriteLine("{0} converted to {1} {2}.",
                           dateString, result, result.Kind.ToString());
      }
      catch (FormatException) {
         Console.WriteLine("Unable to convert {0} to a date and time.", dateString);
      }
   }
}
// The example displays the following output to the console:
//       03/01/2009 10:00 AM converted to 3/1/2009 10:00:00 AM Unspecified.
//       03/01/2009 10:00 AM converted to 3/1/2009 10:00:00 AM Local.
//       2009/03/01T10:00:00-5:00 converted to 3/1/2009 7:00:00 AM Local.
//       Unable to convert 03/01/2009T10:00:00-5:00 to a date and time.
//       2008-03-01 10:00 converted to 3/1/2008 6:00:00 PM Utc.

open System
open System.Globalization

[<EntryPoint>]
let main _ =
    // Parse a date and time with no styles.
    let dateString = "03/01/2009 10:00 AM"
    let culture = CultureInfo.CreateSpecificCulture "en-US"
    let styles = DateTimeStyles.None
    try
        let result = DateTime.Parse(dateString, culture, styles)
        printfn $"{dateString} converted to {result} {result.Kind}."
    with :? FormatException ->
        printfn $"Unable to convert {dateString} to a date and time."

    // Parse the same date and time with the AssumeLocal style.
    let styles = DateTimeStyles.AssumeLocal
    try
        let result = DateTime.Parse(dateString, culture, styles)
        printfn $"{dateString} converted to {result} {result.Kind}."
    with :? FormatException ->
        printfn $"Unable to convert {dateString} to a date and time."

    // Parse a date and time that is assumed to be local.
    // This time is five hours behind UTC. The local system's time zone is
    // eight hours behind UTC.
    let dateString = "2009/03/01T10:00:00-5:00"
    let styles = DateTimeStyles.AssumeLocal
    try
        let result = DateTime.Parse(dateString, culture, styles)
        printfn $"{dateString} converted to {result} {result.Kind}."
    with :? FormatException ->
        printfn $"Unable to convert {dateString} to a date and time."

    // Attempt to convert a string in improper ISO 8601 format.
    let dateString = "03/01/2009T10:00:00-5:00"
    try
        let result = DateTime.Parse(dateString, culture, styles)
        printfn $"{dateString} converted to {result} {result.Kind}."
    with :? FormatException ->
        printfn $"Unable to convert {dateString} to a date and time."

    // Assume a date and time string formatted for the fr-FR culture is the local
    // time and convert it to UTC.
    let dateString = "2008-03-01 10:00"
    let culture = CultureInfo.CreateSpecificCulture "fr-FR"
    let styles = DateTimeStyles.AdjustToUniversal ||| DateTimeStyles.AssumeLocal
    try
        let result = DateTime.Parse(dateString, culture, styles)
        printfn $"{dateString} converted to {result} {result.Kind}."
    with :? FormatException ->
        printfn $"Unable to convert {dateString} to a date and time."

    0

// The example displays the following output to the console:
//       03/01/2009 10:00 AM converted to 3/1/2009 10:00:00 AM Unspecified.
//       03/01/2009 10:00 AM converted to 3/1/2009 10:00:00 AM Local.
//       2009/03/01T10:00:00-5:00 converted to 3/1/2009 7:00:00 AM Local.
//       Unable to convert 03/01/2009T10:00:00-5:00 to a date and time.
//       2008-03-01 10:00 converted to 3/1/2008 6:00:00 PM Utc.

Imports System.Globalization

Module ParseDateExample
   Public Sub Main()
      Dim dateString As String  
      Dim culture As CultureInfo
      Dim styles As DateTimeStyles 
      Dim result As DateTime
      
      ' Parse a date and time with no styles.
      dateString = "03/01/2009 10:00 AM"
      culture = CultureInfo.CreateSpecificCulture("en-US")
      styles = DateTimeStyles.None
      Try
         result = DateTime.Parse(dateString, culture, styles)
         Console.WriteLine("{0} converted to {1} {2}.", _
                           dateString, result, result.Kind.ToString())
      Catch e As FormatException
         Console.WriteLine("Unable to convert {0} to a date and time.", dateString)
      End Try      
      
      ' Parse the same date and time with the AssumeLocal style.
      styles = DateTimeStyles.AssumeLocal
      Try
         result = DateTime.Parse(dateString, culture, styles)
         Console.WriteLine("{0} converted to {1} {2}.", _
                           dateString, result, result.Kind.ToString())
      Catch e As FormatException
         Console.WriteLine("Unable to convert {0} to a date and time.", dateString)
      End Try      
      
      ' Parse a date and time that is assumed to be local.
      ' This time is five hours behind UTC. The local system's time zone is 
      ' eight hours behind UTC.
      dateString = "2009/03/01T10:00:00-5:00"
      styles = DateTimeStyles.AssumeLocal
      Try
         result = DateTime.Parse(dateString, culture, styles)
         Console.WriteLine("{0} converted to {1} {2}.", _
                           dateString, result, result.Kind.ToString())
      Catch e As FormatException
         Console.WriteLine("Unable to convert {0} to a date and time.", dateString)
      End Try      
      
      ' Attempt to convert a string in improper ISO 8601 format.
      dateString = "03/01/2009T10:00:00-5:00"
      Try
         result = DateTime.Parse(dateString, culture, styles)
         Console.WriteLine("{0} converted to {1} {2}.", _
                           dateString, result, result.Kind.ToString())
      Catch e As FormatException
         Console.WriteLine("Unable to convert {0} to a date and time.", dateString)
      End Try      

      ' Assume a date and time string formatted for the fr-FR culture is the local 
      ' time and convert it to UTC.
      dateString = "2008-03-01 10:00"
      culture = CultureInfo.CreateSpecificCulture("fr-FR")
      styles = DateTimeStyles.AdjustToUniversal Or DateTimeStyles.AssumeLocal
      Try
         result = DateTime.Parse(dateString, culture, styles)
         Console.WriteLine("{0} converted to {1} {2}.", _
                           dateString, result, result.Kind.ToString())
      Catch e As FormatException
         Console.WriteLine("Unable to convert {0} to a date and time.", dateString)
      End Try      
   End Sub
End Module
'
' The example displays the following output to the console:
'       03/01/2009 10:00 AM converted to 3/1/2009 10:00:00 AM Unspecified.
'       03/01/2009 10:00 AM converted to 3/1/2009 10:00:00 AM Local.
'       2009/03/01T10:00:00-5:00 converted to 3/1/2009 7:00:00 AM Local.
'       Unable to convert 03/01/2009T10:00:00-5:00 to a date and time.
'       2008-03-01 10:00 converted to 3/1/2008 6:00:00 PM Utc.

Açıklamalar

Bu yöntem aşırı yüklemesi, s içindeki tarih ve saati dönüştürür ve döndürülen DateTime değerinin Kind özelliğini aşağıdaki gibi ayarlar:

Eğer	Saat dilimi dönüştürme	Kind özelliği
s saat dilimi bilgisi içermez.	Hiç kimse.	DateTimeKind.Unspecified
s saat dilimi bilgilerini içerir.	Yerel saat dilimindeki saate	DateTimeKind.Local
s saat dilimi bilgilerini ve stylesDateTimeStyles.AdjustToUniversal bayrağını içerir.	Eşgüdümlü Evrensel Saate (UTC)	DateTimeKind.Utc
s Z veya GMT saat dilimi belirleyicisini ve stylesDateTimeStyles.RoundtripKindiçerir.	Hiç kimse.	DateTimeKind.Utc

Ayrıca bkz.

• TryParse
• CultureInfo
• DateTimeFormatInfo
• .NET Framework Tarih ve Saat Dizelerini Ayrıştırma
• Standart Tarih ve Saat Biçim Dizelerini
• Özel Tarih ve Saat Biçim Dizeleri
• Nasıl Yapılır: Gidiş Dönüş Tarih ve Saat Değerleri