DateTime.Parse Yöntem
Tanım
Ö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 dize gösterimini eşdeğerine DateTime 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 eşdeğerine DateTime 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 eşdeğerine DateTime 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ı eşdeğerine DateTime 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 eşdeğerine DateTime dönüştürür. |
Örnekler
Yöntemini çağıran DateTime.Parse
çok sayıda örnek, bu makalenin Açıklamalar bölümü boyunca ve tek tek DateTime.Parse
aşırı yüklemelere yönelik belgelerde ara sıralanmıştı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 pencerede bir örnek çalıştırmak için Çalıştır düğmesini seçin. Kodu yürüttkten sonra yeniden Çalıştır'ı seçerek kodu değiştirebilir ve değiştirilmiş kodu çalıştırabilirsiniz. Değiştirilen kod etkileşimli pencerede çalışır veya derleme başarısız olursa etkileşimli pencere tüm C# derleyicisi hata iletilerini görüntüler.
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, , DateTimeOffsetve türlerini ve üyelerini gösteren örneklerin DateTimedavranışını ve TimeZoneInfo çıkışını etkileyebilir.
Ayrıca, C# için bir .NET Core projesine dahil edilen eksiksiz bir örnek kümesini DateTime.Parse
de indirebilirsiniz.
Açıklamalar
Bu bölümdeki konular:
- Hangi yöntemi çağırmalıyım?
- Ayrıştırılacak dize
- Ayrıştırma ve kültürel kurallar
- Ayrıştırma ve stil öğeleri
- Dönüş değeri ve DateTime.Kind
Hangi yöntemi çağırmalıyım?
Amaç | Call |
---|---|
Geçerli kültürün kurallarını kullanarak bir tarih ve saat dizesini ayrıştırın. | Parse(String) Aşırı |
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ı |
Belirli bir biçimde olması gereken bir 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ı |
Ö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üş). | Yöntemine "o" veya "r" standart biçim dizesini ToString(String) geçirin ve ile aşırı yüklemeyi çağırın Parse(String, IFormatProvider, DateTimeStyles)DateTimeStyles.RoundtripKind |
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ırılacak dize
yöntemi, Parse bir tarih ve saat değerinin dize gösterimini eşdeğerine DateTime dönüştürmeye çalışır. Bir özel durum oluşturmadan giriş dizesini tamamen ayrıştırmaya FormatException ç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 döndürür false
. Özel durum işleme pahalı olabileceğinden, giriş kaynağına güvenildiğinden ayrıştırma işleminin başarılı olması beklendiğinde kullanmanız Parse gerekir. TryParse özellikle 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.
Tarihe sahip ancak saat bileşeni olmayan bir dize. Saat bileşeni yoksa, yöntemi gece yarısı 12:00 olarak kabul edilir. Tarih bileşeni iki basamaklı bir yıla sahipse, geçerli kültürün geçerli takvimine veya belirtilen kültürün geçerli takvimine göre Calendar.TwoDigitYearMax bir yıla dönüştürülür (null
provider
olmayan bir bağımsız değişkenle aşırı yükleme kullanırsanız).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şenini 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, aşırı yüklemeyi çağırıp Parse(String, IFormatProvider, DateTimeStyles) bağımsız değişkenine
styles
eklemediğiniz DateTimeStyles.NoCurrentDateDefault sürece geçerli tarihi varsayar; bu durumda yöntem 1 Ocak 0001 tarihini kabul eder.Tarih bileşeni olmadan yalnızca saati ve AM/PM belirleyicisini içeren saat bileşenine sahip bir dize. yöntemi, geçerli tarihi ve dakikası olmayan ve saniyesi olmayan bir saati varsayar. Aşırı yüklemeyi çağırarak Parse(String, IFormatProvider, DateTimeStyles) ve bağımsız değişkenine
styles
dahil DateTimeStyles.NoCurrentDateDefault ederek 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) ve ikinci dize 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; örneğin:
"Sat, 01 Kas 2008 19:35:00 GMT"
Saat dilimi uzaklığı bilgilerinin yanı sıra tarih ve saati içeren bir dize; örneğin:
"03/01/2009 05:42:00 -5:00"
Aşağıdaki örnek, geçerli kültürün biçimlendirme kurallarını (bu örnekte en-US kültürü) kullanarak bu biçimlerin her birinde dizeleri ayrıştırmaktadır:
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 bir artık günü temsil ederse (bkz. Ayrıştırma ve kültürel kurallar), Parse yöntem 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, farklı kültürler arasında bir dizeyi 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 yönteminin aşırı yüklemelerinden DateTime.ParseExact birini kullanın ve bir biçim belirtici sağlayın.
Ayrıştırma ve kültürel kurallar
Ayrıştırılacak dize (aşağıdaki tabloda gösterilirs
) ISO 8601 desenine uymadığı sürece yöntemin tüm aşırı yüklemeleri Parse kültüre duyarlıdır. Ayrıştırma işlemi, aşağıdaki gibi türetilen bir DateTimeFormatInfo nesnedeki 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 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 çağı 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.
Şunu ararsanız: | Ve provider |
Biçimlendirme bilgileri şu kaynaktan türetilir: |
---|---|---|
Parse(String) | - | Geçerli kültür (DateTimeFormatInfo.CurrentInfo özellik) |
Parse(String, IFormatProvider) veya Parse(String, IFormatProvider, DateTimeStyles) | nesne DateTimeFormatInfo | Belirtilen DateTimeFormatInfo nesne |
Parse(String, IFormatProvider) veya Parse(String, IFormatProvider, DateTimeStyles) | null |
Geçerli kültür (DateTimeFormatInfo.CurrentInfo özellik) |
Parse(String, IFormatProvider) veya Parse(String, IFormatProvider, DateTimeStyles) | nesne CultureInfo | CultureInfo.DateTimeFormat özelliği |
Parse(String, IFormatProvider) veya Parse(String, IFormatProvider, DateTimeStyles) | Özel IFormatProvider uygulama | IFormatProvider.GetFormat yöntemi |
Biçimlendirme bilgileri bir DateTimeFormatInfo nesneden 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 nesne kullanarak ayrıştırırsanız, başarılı bir dönüştürme olasılığını artırmak için yöntemi yerine Parse yöntemini kullanınParseExact. Standart olmayan bir tarih ve saat dizesini ayrıştırmak karmaşık ve 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ığı yüksek bir veya daha fazla ayrıştırma desenini açıkça belirlemenizi gerektirir. Daha fazla bilgi için konunun "DateTimeFormatInfo ve Dinamik Veri" bölümüne DateTimeFormatInfo bakın.
Önemli
Belirli bir kültür için biçimlendirme kurallarının dinamik olduğunu ve değiştirilebilir olduğunu 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 nesne 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 ana veya ikincil sürümleri arasında ya da .NET Framework mevcut 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 zaman dizelerini ayrıştırmada zorluk yaşanmasını önlemek için, sabit kültürü kullanarak tarih ve saat dizelerini ayrıştırabilir veya veya TryParseExact yöntemini çağırabilir ParseExact 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 değeri ikili biçimde seri hale getirip seri durumdan DateTime çıkarabilirsiniz.
Daha fazla bilgi için konunun "Dinamik kültür verileri" bölümüne CultureInfo ve konunun "Kalıcı DateTime değerleri" bölümüne DateTime bakın.
Ayrıştırma ve stil öğeleri
Tüm Parse aşırı yüklemeler giriş dizesindeki (aşağıdaki tabloda ile gösterilir s
) baştaki, içteki veya sondaki boşluk karakterlerini yoksayar. Tarih ve saat, bir çift baştaki ve sondaki SAYI İşaretİ karakteriyle ("#", U+0023) köşeli ayraçla işaretlenebilir ve sonunda bir veya daha fazla NULL karakter (U+0000) bulunabilir.
Buna ek olarak, Parse(String, IFormatProvider, DateTimeStyles) aşırı yüklemenin numaralandırmanın bir veya daha fazla üyesinden DateTimeStyles oluşan bir styles
parametresi vardır. Bu parametre, nasıl s
yorumlanması gerektiğini ve ayrıştırma işleminin tarih ve saate nasıl dönüştürülmesi s
gerektiğini tanımlar. Aşağıdaki tabloda her DateTimeStyles üyenin ayrıştırma işlemi üzerindeki etkisi açıklanmaktadır.
DateTimeStyles üyesi | Dönüştürme üzerindeki etkisi |
---|---|
AdjustToUniversal | ayrıştırıp s gerekirse utc'ye dönüştürür:- Saat s dilimi uzaklığı içeriyorsa veya saat dilimi bilgisi içermiyorsa s ancak styles bayrağı içeriyorsaAssumeLocal, yöntemi dizeyi ayrıştırıyor, döndürülen DateTime değeri UTC'ye dönüştürmek için çağrılar ToUniversalTime ve özelliğini olarak DateTimeKind.UtcayarlarKind.- UTC'yi temsil ettiğini gösterirse s veya saat dilimi bilgilerini içermiyorsa s ancak styles bayrağı içeriyorsaAssumeUniversal, yöntem 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 tüm durumlarda bayrağın hiçbir etkisi yoktur. |
AllowInnerWhite | Bu değer yoksayılır. 'nin tarih ve saat öğelerinde s her zaman iç boşluklara izin verilir. |
AllowLeadingWhite | Bu değer yoksayılır. 'nin tarih ve saat öğelerinde s her zaman baştaki boşluklara izin verilir. |
AllowTrailingWhite | Bu değer yoksayılır. 'nin tarih ve saat öğelerinde s sondaki boşluklara her zaman izin verilir. |
AllowWhiteSpaces | s Başta, içte ve sonda boşluk içerebileceğini belirtir. Bu varsayılan davranıştır. gibi Nonedaha kısıtlayıcı DateTimeStyles bir numaralandırma değeri sağlayarak geçersiz kılınamaz. |
AssumeLocal | Herhangi bir saat dilimi bilgisi yoksa s yerel saatin varsayıldığını belirtir. 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 varsayıldığını belirtir. 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. |
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 yerel saati temsil eden ve özelliği olarak ayarlanmış bir DateTimeKind değere dönüştürülmesini engellemeye DateTimeKind.Localçalışır. Genellikle, böyle bir dize yöntemi çağrılarak DateTime.ToString(String) ve "o", "r" veya "u" standart biçim tanımlayıcısı kullanılarak oluşturulur. |
Dönüş değeri ve DateTime.Kind
Aşırı DateTime.Parse
yüklemeler, özelliği saat dilimi bilgilerini içeren bir DateTime değer Kind 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).
Yöntemi genellikle Parse özelliği DateTimeKind.Unspecifiedolan Kind bir DateTime nesnesi döndürür. Ancak yöntemi ayrıca Parse saat dilimi dönüştürmesi gerçekleştirebilir ve ve styles
parametrelerinin Kind değerlerine bağlı olarak özelliğin s
değerini farklı 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 içerir ve styles bayrağını AdjustToUniversal 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 göstergesini içerir ve styles bayrağını RoundtripKind 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
Ayrıca, biçimlendirme ve ayrıştırma işlemi sırasında bayrağını kullanarak bir tarih ve saatin Kind özelliğinin DateTimeStyles.RoundtripKind değerini de koruyabilirsiniz. Aşağıdaki örnekte bayrağın RoundtripKind "o", "r" veya "u" biçim belirticisi kullanılarak dizelere dönüştürülen değerlerde ayrıştırma işlemini DateTime 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)
Geçerli kültürün kurallarını kullanarak bir tarih ve saatin dize gösterimini eşdeğerine DateTime 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 bir tarih ve saat içeren bir dize. Daha fazla bilgi için bkz. Ayrıştırmak için dize .
Döndürülenler
içinde yer alan s
tarih ve saate eşdeğer bir nesne.
Özel durumlar
s
, null
değeridir.
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.
Varsayılan stil değerini (olan AllowWhiteSpaces) kullanma.
Yöntemi 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 özel durumu işler FormatException . 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ı 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 özelliği olan KindDateTimeKind.Local bir DateTime değer döndürür ve içindeki tarih ve saati s
yerel saate dönüştürür. Aksi takdirde, saat dilimi dönüştürmesi gerçekleştirmez ve özelliği olan KindDateTimeKind.Unspecifiedbir DateTime değer döndürür.
Bu aşırı yükleme, geçerli kültürün biçimlendirme kurallarını kullanarak ayrıştırmaya s
çalışır. Geçerli kültür özelliğiyle CurrentCulture gösterilir. Belirli bir kültürün biçimlendirme kurallarını kullanarak bir dizeyi ayrıştırmak için veya aşırı yüklemelerini çağırın Parse(String, IFormatProvider)Parse(String, IFormatProvider, DateTimeStyles) .
Bu aşırı yükleme, stil kullanarak DateTimeStyles.AllowWhiteSpaces ayrıştırmaya s
çalışır.
Ayrıca bkz.
- TryParse
- CultureInfo
- DateTimeFormatInfo
- .NET Framework'te Tarih ve Saat Dizelerini Ayrıştırma
- Standart Tarih ve Saat Biçim Dizeleri
- Özel Tarih ve Saat Biçim Dizeleri
Şunlara uygulanır
Parse(ReadOnlySpan<Char>, IFormatProvider)
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ılması.
- provider
- IFormatProvider
hakkında s
kültüre özgü biçimlendirme bilgileri sağlayan bir nesne.
Döndürülenler
ayrıştırma s
işleminin sonucu.
Uygulamalar
Şunlara uygulanır
Parse(String, IFormatProvider)
Kültüre özgü biçim bilgilerini kullanarak tarih ve saatin dize gösterimini eşdeğerine DateTime dönüştürür.
public:
static DateTime Parse(System::String ^ s, IFormatProvider ^ provider);
public:
static DateTime Parse(System::String ^ s, IFormatProvider ^ provider) = IParsable<DateTime>::Parse;
public static DateTime Parse (string s, IFormatProvider provider);
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 bir tarih ve saat içeren bir dize. Daha fazla bilgi için bkz. Ayrıştırmak için dize .
- provider
- IFormatProvider
hakkında s
kültüre özgü biçim bilgileri sağlayan bir nesne. Bkz . Ayrıştırma ve kültürel kurallar
Döndürülenler
tarafından provider
belirtildiği gibi içinde s
yer alan tarih ve saate eşdeğer bir nesne.
Uygulamalar
Özel durumlar
s
, null
değeridir.
s
tarih ve saatin geçerli dize gösterimini içermez.
Örnekler
Aşağıdaki örnek, en-US, fr-FR ve 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 özelliği olan KindDateTimeKind.Local bir DateTime değer döndürür ve içindeki tarih ve saati s
yerel saate dönüştürür. Aksi takdirde, saat dilimi dönüştürmesi gerçekleştirmez ve özelliği olan KindDateTimeKind.Unspecifiedbir DateTime değer döndürür.
Bu aşırı yükleme, stili kullanarak DateTimeStyles.AllowWhiteSpaces ayrıştırmaya s
çalışır.
Ayrıca bkz.
- TryParse
- CultureInfo
- DateTimeFormatInfo
- .NET Framework'te Tarih ve Saat Dizelerini Ayrıştırma
- Standart Tarih ve Saat Biçim Dizeleri
- Özel Tarih ve Saat Biçim Dizeleri
Şunlara uygulanı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ı eşdeğerine DateTime dönüştürür.
public static DateTime Parse (ReadOnlySpan<char> s, IFormatProvider? provider = default, System.Globalization.DateTimeStyles styles = System.Globalization.DateTimeStyles.None);
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
hakkında s
kültüre özgü biçim bilgileri sağlayan bir nesne. Bkz . Ayrıştırma ve kültürel kurallar
- styles
- DateTimeStyles
Ayrıştırma işleminin başarılı olması için içinde s
bulunabilecek stil öğelerini gösteren ve ayrıştırılmış tarihin geçerli saat dilimine veya geçerli tarihe göre nasıl yorumlanabileceğini tanımlayan sabit listesi değerlerinin bit düzeyinde birleşimi. Belirtilmesi gereken tipik bir değerdir None.
Döndürülenler
ve styles
tarafından provider
belirtildiği gibi içinde s
bulunan tarih ve saate eşdeğer bir nesne.
Özel durumlar
s
tarih ve saatin geçerli dize gösterimini içermez.
styles
geçersiz bir değer bileşimi DateTimeStyles içeriyor. Örneğin, hem AssumeUniversalhem de AssumeLocal .
Şunlara uygulanır
Parse(String, IFormatProvider, DateTimeStyles)
Kültüre özgü biçim bilgileri ve biçimlendirme stili kullanarak tarih ve saatin dize gösterimini eşdeğerine DateTime 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);
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 bir tarih ve saat içeren bir dize. Daha fazla bilgi için bkz. Ayrıştırmak için dize .
- provider
- IFormatProvider
hakkında s
kültüre özgü biçimlendirme bilgileri sağlayan bir nesne. Bkz . Ayrıştırma ve kültürel kurallar
- styles
- DateTimeStyles
Ayrıştırma işleminin başarılı olması için içinde s
bulunabilecek stil öğelerini gösteren ve ayrıştırılmış tarihin geçerli saat dilimine veya geçerli tarihe göre nasıl yorumlanabileceğini tanımlayan sabit listesi değerlerinin bit düzeyinde birleşimi. Belirtilmesi gereken tipik bir değerdir None.
Döndürülenler
ve styles
tarafından provider
belirtildiği gibi içinde s
bulunan tarih ve saate eşdeğer bir nesne.
Özel durumlar
s
, null
değeridir.
s
tarih ve saatin geçerli dize gösterimini içermez.
styles
geçersiz bir değer bileşimi DateTimeStyles içeriyor. Örneğin, hem AssumeUniversalhem de AssumeLocal .
Örnekler
Aşağıdaki örnek yöntemini gösterir Parse(String, IFormatProvider, DateTimeStyles) ve sonuçta elde DateTime edilen değerlerin özelliğinin değerini Kind 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 içindeki tarih ve saati s
dönüştürür ve döndürülen DateTime değerin özelliğini aşağıdaki gibi ayarlarKind:
Eğer | Saat dilimi dönüştürme | Kind özelliği |
---|---|---|
s saat dilimi bilgisi içermez. |
Yok. | DateTimeKind.Unspecified |
s saat dilimi bilgilerini içerir. |
Yerel saat dilimindeki saate | DateTimeKind.Local |
s saat dilimi bilgilerini içerir ve styles bayrağını DateTimeStyles.AdjustToUniversal içerir. |
Eşgüdümlü Evrensel Saate (UTC) | DateTimeKind.Utc |
s Z veya GMT saat dilimi belirleyicisini içerir ve styles öğesini DateTimeStyles.RoundtripKindiçerir. |
Yok. | DateTimeKind.Utc |
Ayrıca bkz.
- TryParse
- CultureInfo
- DateTimeFormatInfo
- .NET Framework'te Tarih ve Saat Dizelerini Ayrıştırma
- Standart Tarih ve Saat Biçim Dizeleri
- Özel Tarih ve Saat Biçim Dizeleri
- Nasıl yapılır: Gidiş Dönüş Tarih ve Saat Değerleri
Şunlara uygulanır
Geri Bildirim
https://aka.ms/ContentUserFeedback.
Çok yakında: 2024 boyunca, içerik için geri bildirim mekanizması olarak GitHub Sorunları’nı kullanımdan kaldıracak ve yeni bir geri bildirim sistemiyle değiştireceğiz. Daha fazla bilgi için bkz.Gönderin ve geri bildirimi görüntüleyin