System.DateTime yapısı
Bu makale, bu API'nin başvuru belgelerine ek açıklamalar sağlar.
Ö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çindeki Reiwa döneminin başlangıcını JapaneseCalendar 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 . .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 ç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.
Genel bakış
DateTime Değer türü, Gregoryen takviminde 00:00:00 (gece yarısı), 1 Ocak 0001 Anno Domini (Common Era) ile 11:59:59 ARASıNDA, 31 Aralık 9999 M.Ö. (C.E.) arasında değerler içeren tarih ve saatleri temsil eder.
Zaman değerleri, keneler olarak adlandırılan 100 nanosaniye cinsinden ölçülür. Belirli bir tarih, takvimde 12:00 gece yarısı, 1 Ocak 0001 M.Ö. (C.E.) tarihinden bu yana olan GregorianCalendar kene sayısıdır. Sayı, artık saniyeler tarafından eklenecek değer işaretlerini dışlar. Örneğin, 31241376000000000L değer, 01 Ocak 0100 Cuma 12:00:00 gece yarısı tarihini temsil eder. Bir DateTime değer her zaman açık veya varsayılan takvim bağlamında ifade edilir.
Not
Dakika veya saniye gibi başka bir zaman aralığına dönüştürmek istediğiniz bir değerle çalışıyorsanız, dönüştürmeyi gerçekleştirmek için , TimeSpan.TicksPerHour, TimeSpan.TicksPerMinute, TimeSpan.TicksPerSecondveya TimeSpan.TicksPerMillisecond sabitini kullanmanız TimeSpan.TicksPerDaygerekir. Örneğin, bir değerin bileşenine DateTime belirtilen sayıda değerle temsil edilen saniye sayısını eklemek için Second ifadesini dateValue.Second + nTicks/Timespan.TicksPerSecondkullanabilirsiniz.
Bu makaledeki örnek kümesinin tamamının kaynağını Visual Basic, F# veya C# dilinde görüntüleyebilirsiniz.
Not
Belirli saat dilimlerinde tarih ve saat değerleriyle çalışma yapısının DateTimeOffset bir alternatifi DateTime de yapıdır. Yapı, DateTimeOffset tarih ve saat bilgilerini özel bir alanda ve bu DateTime tarih ve saatin utc'den farklı olduğu dakika sayısını özel Int16 bir alanda depolar. Bu, bir değerin belirli bir DateTimeOffset saat dilimindeki saati yansıtmasını mümkün kılarken, bir DateTime değer yalnızca UTC ve yerel saat diliminin saatini net bir şekilde yansıtabilir. Tarih ve saat değerleriyle çalışırken yapının veya DateTimeOffset yapının ne zaman kullanılacağı DateTime hakkında bir tartışma için bkz. DateTime, DateTimeOffset, TimeSpan ve TimeZoneInfo Arasında Seçim Yapmak.
Örnek koda hızlı bağlantılar
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 düğmesini 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, , DateTimeOffsetve türlerini ve üyelerini gösteren örneklerin DateTimedavranışını ve TimeZoneInfo çıkışını etkileyebilir.
Bu makale, türünü kullanan DateTime birkaç örnek içerir:
Başlatma örnekleri
- Oluşturucu çağırma
- Örtük parametresiz oluşturucuyu çağırma
- Dönüş değerinden atama
- Tarih ve saati temsil eden bir dizeyi ayrıştırma
- Tarih ve saat başlatmak için Visual Basic söz dizimi
Nesneleri dize olarak biçimlendirme DateTime örnekleri
- Varsayılan tarih saat biçimini kullanma
- Belirli bir kültürü kullanarak tarih ve saati biçimlendirme
- Standart veya özel biçim dizesi kullanarak tarih saatini biçimlendirme
- Hem biçim dizesini hem de belirli bir kültürü belirtme
- Web hizmetleri için ISO 8601 standardını kullanarak tarih saatini biçimlendirme
Dizeleri nesne örnekleri olarak DateTime ayrıştırma
- Dizeyi tarih ve saate dönüştürmek için veya
TryParsekullanınParse - Bilinen biçimdeki bir dizeyi dönüştürmek için veya
TryParseExactkullanınParseExact - ISO 8601 dize gösteriminden tarih ve saate dönüştürme
DateTime çözüm örnekleri
Kültür ve takvim örnekleri
- Kültüre özgü takvimleri kullanarak tarih ve saat değerlerini görüntüleme
- Dizeleri kültüre özgü bir takvime göre ayrıştırma
- Belirli bir kültürün takviminden tarih ve saat başlatma
- Belirli bir kültürün takvimini kullanarak tarih ve saat özelliklerine erişme
- Kültüre özgü takvimleri kullanarak yılın haftasını alma
Kalıcılık örnekleri
- Tarih ve saat değerlerini yerel saat diliminde dize olarak kalıcı hale getirir
- Tarih ve saat değerlerini bir kültür ve saat sabit biçiminde dizeler olarak kalıcı hale getirir
- Tarih ve saat değerlerini tamsayı olarak kalıcı hale getirir
- Kullanarak tarih ve saat değerlerini kalıcı hale
XmlSerializer
DateTime nesnesini başlatma
Başlangıç değerini yeni DateTime bir değere birçok farklı yolla atayabilirsiniz:
- Değerler için bağımsız değişkenleri belirttiğiniz bir oluşturucuyu çağırma veya örtük parametresiz oluşturucuyu kullanma.
- Bir
DateTimeözelliğin veya yöntemin dönüş değerine atama. - Bir
DateTimedeğeri dize gösteriminden ayrıştırma. - Örneğini
DateTimeoluşturmak için Visual Basic'e özgü dil özelliklerini kullanma.
Aşağıdaki kod parçacıklarında her birinin örnekleri gösterilmektedir.
Oluşturucuları çağırma
Tarih ve saat değerinin öğelerini (yıl, ay ve gün veya değer sayısı gibi) belirten oluşturucunun aşırı yüklemelerinden DateTime herhangi birini çağırırsınız. Aşağıdaki kod, oluşturucuyu DateTime kullanarak yıl, ay, gün, saat, dakika ve saniyeyi belirten belirli bir tarih oluşturur.
Dim date1 As New Date(2008, 5, 1, 8, 30, 52)
var date1 = new DateTime(2008, 5, 1, 8, 30, 52);
Console.WriteLine(date1);
let date1 = DateTime(2008, 5, 1, 8, 30, 52)
printfn $"{date1}"
Varsayılan değerinin DateTime başlatılmasını istediğinizde DateTime , yapının örtük parametresiz oluşturucusunu çağırırsınız. (Bir değer türünün örtük parametresiz oluşturucusunun ayrıntıları için bkz. Değer Türleri.) Bazı derleyiciler, açıkça bir değer atamadan değer DateTime bildirmeyi de destekler. Açık bir başlatma olmadan bir değer oluşturmak da varsayılan değerle sonuç verir. Aşağıdaki örnekte C# ve Visual Basic'teki örtük parametresiz oluşturucunun yanı sıra Visual Basic'te atamasız bir DateTime bildirim gösterilmektedirDateTime.
Dim dat1 As DateTime
' The following method call displays 1/1/0001 12:00:00 AM.
Console.WriteLine(dat1.ToString(System.Globalization.CultureInfo.InvariantCulture))
' The following method call displays True.
Console.WriteLine(dat1.Equals(Date.MinValue))
Dim dat2 As New DateTime()
' The following method call displays 1/1/0001 12:00:00 AM.
Console.WriteLine(dat2.ToString(System.Globalization.CultureInfo.InvariantCulture))
' The following method call displays True.
Console.WriteLine(dat2.Equals(Date.MinValue))
var dat1 = new DateTime();
// The following method call displays 1/1/0001 12:00:00 AM.
Console.WriteLine(dat1.ToString(System.Globalization.CultureInfo.InvariantCulture));
// The following method call displays True.
Console.WriteLine(dat1.Equals(DateTime.MinValue));
let dat1 = DateTime()
// The following method call displays 1/1/0001 12:00:00 AM.
printfn $"{dat1.ToString System.Globalization.CultureInfo.InvariantCulture}"
// The following method call displays True.
printfn $"{dat1.Equals DateTime.MinValue}"
Hesaplanan değer atama
Nesneye DateTime bir özellik veya yöntem tarafından döndürülen bir tarih ve saat değeri atayabilirsiniz. Aşağıdaki örnek geçerli tarih ve saati, geçerli Eşgüdümlü Evrensel Saat (UTC) tarih ve saatini ve geçerli tarihi üç yeni DateTime değişkene atar.
Dim date1 As Date = Date.Now
Dim date2 As Date = Date.UtcNow
Dim date3 As Date = Date.Today
DateTime date1 = DateTime.Now;
DateTime date2 = DateTime.UtcNow;
DateTime date3 = DateTime.Today;
let date1 = DateTime.Now
let date2 = DateTime.UtcNow
let date3 = DateTime.Today
DateTime'i temsil eden bir dizeyi ayrıştırma
, ParseExact, TryParseve TryParseExact yöntemlerinin Parsetümü bir dizeyi eşdeğer tarih ve saat değerine dönüştürür. Aşağıdaki örnekler, bir dizeyi Parse ayrıştırmak ve bir değere dönüştürmek için DateTime ve ParseExact yöntemlerini kullanır. İkinci biçim, tarih ve saati dize biçiminde temsil eden iso 8601 standardı tarafından desteklenen bir form kullanır. Bu standart gösterim genellikle web hizmetlerindeki tarih bilgilerini aktarmak için kullanılır.
Dim dateString As String = "5/1/2008 8:30:52 AM"
Dim date1 As Date = Date.Parse(dateString,
System.Globalization.CultureInfo.InvariantCulture)
Dim iso8601String As String = "20080501T08:30:52Z"
Dim dateISO8602 As Date = DateTime.ParseExact(iso8601String, "yyyyMMddTHH:mm:ssZ",
System.Globalization.CultureInfo.InvariantCulture)
Console.WriteLine(dateISO8602)
var dateString = "5/1/2008 8:30:52 AM";
DateTime date1 = DateTime.Parse(dateString,
System.Globalization.CultureInfo.InvariantCulture);
var iso8601String = "20080501T08:30:52Z";
DateTime dateISO8602 = DateTime.ParseExact(iso8601String, "yyyyMMddTHH:mm:ssZ",
System.Globalization.CultureInfo.InvariantCulture);
let dateString = "5/1/2008 8:30:52 AM"
let date1 = DateTime.Parse(dateString, System.Globalization.CultureInfo.InvariantCulture)
let iso8601String = "20080501T08:30:52Z"
let dateISO8602 = DateTime.ParseExact(iso8601String, "yyyyMMddTHH:mm:ssZ", System.Globalization.CultureInfo.InvariantCulture)
TryParse ve TryParseExact yöntemleri, dizenin bir değerin DateTime geçerli bir gösterimi olup olmadığını gösterir ve ise dönüştürmeyi gerçekleştirir.
Visual Basic için dile özgü söz dizimi
Aşağıdaki Visual Basic deyimi yeni DateTime bir değer başlatır.
Dim date1 As Date = #5/1/2008 8:30:52AM#
DateTime değerleri ve bunların dize gösterimleri
Dahili olarak, tüm DateTime değerler 1 Ocak 0001 gece yarısı 12:00:00'dan bu yana geçen değer sayısı (100 nanosaniyelik aralık sayısı) olarak temsil edilir. Gerçek DateTime değer, bu değerin görüntülendiğinde görüntülenme biçiminden bağımsızdır. Bir DateTime değerin görünümü, bir değeri dize gösterimine dönüştüren bir biçimlendirme işleminin sonucudur.
Tarih ve saat değerlerinin görünümü kültüre, uluslararası standartlara, uygulama gereksinimlerine ve kişisel tercihe bağlıdır. Yapısı, DateTime aşırı yüklemeleri ToStringaracılığıyla tarih ve saat değerlerini biçimlendirme esnekliği sunar. Varsayılan DateTime.ToString() yöntem, geçerli kültürün kısa tarih ve uzun saat desenini kullanarak tarih ve saat değerinin dize gösterimini döndürür. Aşağıdaki örnek varsayılan DateTime.ToString() yöntemi kullanır. Geçerli kültür için kısa tarih ve uzun saat desenini kullanarak tarih ve saati görüntüler. En-US kültürü, örneğin çalıştırıldığı bilgisayardaki geçerli kültürdür.
var date1 = new DateTime(2008, 3, 1, 7, 0, 0);
Console.WriteLine(date1.ToString());
// For en-US culture, displays 3/1/2008 7:00:00 AM
let date1 = DateTime(2008, 3, 1, 7, 0, 0)
printfn $"{date1.ToString()}"
// For en-US culture, displays 3/1/2008 7:00:00 AM
Dim date1 As Date = #3/1/2008 7:00AM#
Console.WriteLine(date1.ToString())
' For en-US culture, displays 3/1/2008 7:00:00 AM
Sunucunun istemciden farklı bir kültürde yer aldığı web senaryolarını desteklemek için belirli bir kültürdeki tarihleri biçimlendirmeniz gerekebilir. Belirli bir kültürde kısa tarih ve uzun saat gösterimi oluşturmak için yöntemini kullanarak DateTime.ToString(IFormatProvider) kültürü belirtirsiniz. Aşağıdaki örnek, DateTime.ToString(IFormatProvider) fr-FR kültürü için kısa tarih ve uzun saat desenini kullanarak tarih ve saati görüntülemek için yöntemini kullanır.
var date1 = new DateTime(2008, 3, 1, 7, 0, 0);
Console.WriteLine(date1.ToString(System.Globalization.CultureInfo.CreateSpecificCulture("fr-FR")));
// Displays 01/03/2008 07:00:00
let date1 = DateTime(2008, 3, 1, 7, 0, 0)
printfn $"""{date1.ToString(System.Globalization.CultureInfo.CreateSpecificCulture "fr-FR")}"""
// Displays 01/03/2008 07:00:00
Dim date1 As Date = #3/1/2008 7:00AM#
Console.WriteLine(date1.ToString(System.Globalization.CultureInfo.CreateSpecificCulture("fr-FR")))
' Displays 01/03/2008 07:00:00
Diğer uygulamalar bir tarihin farklı dize gösterimlerini gerektirebilir. yöntemi, DateTime.ToString(String) geçerli kültürün biçimlendirme kurallarını kullanarak standart veya özel biçim tanımlayıcısı tarafından tanımlanan dize gösterimini döndürür. Aşağıdaki örnek, örneğin çalıştırıldığı bilgisayardaki geçerli kültür olan en-US kültürü için tam tarih ve saat desenini görüntülemek için yöntemini kullanır DateTime.ToString(String) .
var date1 = new DateTime(2008, 3, 1, 7, 0, 0);
Console.WriteLine(date1.ToString("F"));
// Displays Saturday, March 01, 2008 7:00:00 AM
let date1 = DateTime(2008, 3, 1, 7, 0, 0)
printfn $"""{date1.ToString "F"}"""
// Displays Saturday, March 01, 2008 7:00:00 AM
Dim date1 As Date = #3/1/2008 7:00AM#
Console.WriteLine(date1.ToString("F"))
' Displays Saturday, March 01, 2008 7:00:00 AM
Son olarak, yöntemini kullanarak DateTime.ToString(String, IFormatProvider) hem kültürü hem de biçimi belirtebilirsiniz. Aşağıdaki örnek, DateTime.ToString(String, IFormatProvider) fr-FR kültürünün tam tarih ve saat desenini görüntülemek için yöntemini kullanır.
var date1 = new DateTime(2008, 3, 1, 7, 0, 0);
Console.WriteLine(date1.ToString("F", new System.Globalization.CultureInfo("fr-FR")));
// Displays samedi 1 mars 2008 07:00:00
let date1 = DateTime(2008, 3, 1, 7, 0, 0)
printfn $"""{date1.ToString("F", new System.Globalization.CultureInfo "fr-FR")}"""
// Displays samedi 1 mars 2008 07:00:00
Dim date1 As Date = #3/1/2008 7:00AM#
Console.WriteLine(date1.ToString("F", New System.Globalization.CultureInfo("fr-FR")))
' Displays samedi 1 mars 2008 07:00:00
Aşırı DateTime.ToString(String) yükleme, diğer biçimleri belirtmek için özel bir biçim dizesiyle de kullanılabilir. Aşağıdaki örnekte, web hizmetleri için sıklıkla kullanılan ISO 8601 standart biçimini kullanarak bir dizenin nasıl biçimlendirilir gösterilmektedir. Iso 8601 biçiminin karşılık gelen bir standart biçim dizesi yoktur.
var date1 = new DateTime(2008, 3, 1, 7, 0, 0, DateTimeKind.Utc);
Console.WriteLine(date1.ToString("yyyy-MM-ddTHH:mm:sszzz", System.Globalization.CultureInfo.InvariantCulture));
// Displays 2008-03-01T07:00:00+00:00
let date1 = DateTime(2008, 3, 1, 7, 0, 0, DateTimeKind.Utc)
printfn $"""{date1.ToString("yyyy-MM-ddTHH:mm:sszzz", System.Globalization.CultureInfo.InvariantCulture)}"""
// Displays 2008-03-01T07:00:00+00:00
Dim date1 As DateTime = New DateTime(2008, 3, 1, 7, 0, 0, DateTimeKind.Utc)
Console.WriteLine(date1.ToString("yyyy-MM-ddTHH:mm:sszzz", System.Globalization.CultureInfo.InvariantCulture))
' Displays 2008-03-01T07:00:00+00:00
Değerleri biçimlendirme DateTime hakkında daha fazla bilgi için bkz . Standart Tarih ve Saat Biçim Dizeleri ve Özel Tarih ve Saat Biçim Dizeleri.
Tarih Saat değerlerini dizelerden ayrıştırma
Ayrıştırma, tarih ve saatin dize gösterimini bir DateTime değere dönüştürür. Genellikle, tarih ve saat dizelerinin uygulamalarda iki farklı kullanımı vardır:
Tarih ve saat, çeşitli biçimler alır ve geçerli kültürün veya belirli bir kültürün kurallarını yansıtır. Örneğin, bir uygulama geçerli kültürü en-US olan bir kullanıcının "15.12.2013" veya "15 Aralık 2013" olarak bir tarih değeri girişine izin verir. Geçerli kültürü en-gb olan bir kullanıcının "12.15.2013" veya "15 Aralık 2013" olarak bir tarih değeri girişine izin verir.
Tarih ve saat önceden tanımlanmış biçimde gösterilir. Örneğin, bir uygulama bir tarihi uygulamanın üzerinde çalıştığı kültürden bağımsız olarak "20130103" olarak seri hale getirir. Bir uygulama, geçerli kültürün kısa tarih biçiminde tarih girişi yapılmasını gerektirebilir.
Bir dizeyi Parse bir kültür tarafından kullanılan ortak tarih ve saat biçimlerinden birinden bir değere dönüştürmek için DateTime veya TryParse yöntemini kullanırsınız. Aşağıdaki örnekte, kültüre özgü farklı biçimlerdeki tarih dizelerini bir DateTime değere dönüştürmek için nasıl kullanabileceğiniz TryParse gösterilmektedir. Geçerli kültürü İngilizce (Birleşik Krallık) olarak değiştirir ve tarih ve saat dizeleri dizisi oluşturmak için yöntemini çağırır GetDateTimeFormats() . Ardından dizideki her öğeyi yöntemine TryParse geçirir. Örnekten elde edilen çıktı, ayrıştırma yönteminin kültüre özgü tarih ve saat dizelerinin her birini başarıyla dönüştürdüğünü gösterir.
System.Threading.Thread.CurrentThread.CurrentCulture =
System.Globalization.CultureInfo.CreateSpecificCulture("en-GB");
var date1 = new DateTime(2013, 6, 1, 12, 32, 30);
var badFormats = new List<String>();
Console.WriteLine($"{"Date String",-37} {"Date",-19}\n");
foreach (var dateString in date1.GetDateTimeFormats())
{
DateTime parsedDate;
if (DateTime.TryParse(dateString, out parsedDate))
Console.WriteLine($"{dateString,-37} {DateTime.Parse(dateString),-19}");
else
badFormats.Add(dateString);
}
// Display strings that could not be parsed.
if (badFormats.Count > 0)
{
Console.WriteLine("\nStrings that could not be parsed: ");
foreach (var badFormat in badFormats)
Console.WriteLine($" {badFormat}");
}
// Press "Run" to see the output.
System.Threading.Thread.CurrentThread.CurrentCulture <-
System.Globalization.CultureInfo.CreateSpecificCulture "en-GB"
let date1 = DateTime(2013, 6, 1, 12, 32, 30)
let badFormats = ResizeArray<String>()
printfn "%-37s %-19s\n" "Date String" "Date"
for dateString in date1.GetDateTimeFormats() do
match DateTime.TryParse dateString with
| true, parsedDate ->
printfn $"%-37s{dateString} %-19O{parsedDate}\n"
| _ ->
badFormats.Add dateString
// Display strings that could not be parsed.
if badFormats.Count > 0 then
printfn "\nStrings that could not be parsed: "
for badFormat in badFormats do
printfn $" {badFormat}"
// Press "Run" to see the output.
Thread.CurrentThread.CurrentCulture = CultureInfo.CreateSpecificCulture("en-GB")
Dim date1 As New DateTime(2013, 6, 1, 12, 32, 30)
Dim badFormats As New List(Of String)
Console.WriteLine($"{"Date String",-37} {"Date",-19}")
Console.WriteLine()
For Each dateString As String In date1.GetDateTimeFormats()
Dim parsedDate As DateTime
If DateTime.TryParse(dateString, parsedDate) Then
Console.WriteLine($"{dateString,-37} {DateTime.Parse(dateString),-19:g}")
Else
badFormats.Add(dateString)
End If
Next
' Display strings that could not be parsed.
If badFormats.Count > 0 Then
Console.WriteLine()
Console.WriteLine("Strings that could not be parsed: ")
For Each badFormat In badFormats
Console.WriteLine($" {badFormat}")
Next
End If
' The example displays the following output:
' Date String Date
'
' 01/06/2013 01/06/2013 00:00:00
' 01/06/13 01/06/2013 00:00:00
' 1/6/13 01/06/2013 00:00:00
' 1.6.13 01/06/2013 00:00:00
' 2013-06-01 01/06/2013 00:00:00
' 01 June 2013 01/06/2013 00:00:00
' 1 June 2013 01/06/2013 00:00:00
' 01 June 2013 12:32 01/06/2013 12:32:00
' 01 June 2013 12:32 01/06/2013 12:32:00
' 01 June 2013 12:32 PM 01/06/2013 12:32:00
' 01 June 2013 12:32 PM 01/06/2013 12:32:00
' 1 June 2013 12:32 01/06/2013 12:32:00
' 1 June 2013 12:32 01/06/2013 12:32:00
' 1 June 2013 12:32 PM 01/06/2013 12:32:00
' 1 June 2013 12:32 PM 01/06/2013 12:32:00
' 01 June 2013 12:32:30 01/06/2013 12:32:30
' 01 June 2013 12:32:30 01/06/2013 12:32:30
' 01 June 2013 12:32:30 PM 01/06/2013 12:32:30
' 01 June 2013 12:32:30 PM 01/06/2013 12:32:30
' 1 June 2013 12:32:30 01/06/2013 12:32:30
' 1 June 2013 12:32:30 01/06/2013 12:32:30
' 1 June 2013 12:32:30 PM 01/06/2013 12:32:30
' 1 June 2013 12:32:30 PM 01/06/2013 12:32:30
' 01/06/2013 12:32 01/06/2013 12:32:00
' 01/06/2013 12:32 01/06/2013 12:32:00
' 01/06/2013 12:32 PM 01/06/2013 12:32:00
' 01/06/2013 12:32 PM 01/06/2013 12:32:00
' 01/06/13 12:32 01/06/2013 12:32:00
' 01/06/13 12:32 01/06/2013 12:32:00
' 01/06/13 12:32 PM 01/06/2013 12:32:00
' 01/06/13 12:32 PM 01/06/2013 12:32:00
' 1/6/13 12:32 01/06/2013 12:32:00
' 1/6/13 12:32 01/06/2013 12:32:00
' 1/6/13 12:32 PM 01/06/2013 12:32:00
' 1/6/13 12:32 PM 01/06/2013 12:32:00
' 1.6.13 12:32 01/06/2013 12:32:00
' 1.6.13 12:32 01/06/2013 12:32:00
' 1.6.13 12:32 PM 01/06/2013 12:32:00
' 1.6.13 12:32 PM 01/06/2013 12:32:00
' 2013-06-01 12:32 01/06/2013 12:32:00
' 2013-06-01 12:32 01/06/2013 12:32:00
' 2013-06-01 12:32 PM 01/06/2013 12:32:00
' 2013-06-01 12:32 PM 01/06/2013 12:32:00
' 01/06/2013 12:32:30 01/06/2013 12:32:30
' 01/06/2013 12:32:30 01/06/2013 12:32:30
' 01/06/2013 12:32:30 PM 01/06/2013 12:32:30
' 01/06/2013 12:32:30 PM 01/06/2013 12:32:30
' 01/06/13 12:32:30 01/06/2013 12:32:30
' 01/06/13 12:32:30 01/06/2013 12:32:30
' 01/06/13 12:32:30 PM 01/06/2013 12:32:30
' 01/06/13 12:32:30 PM 01/06/2013 12:32:30
' 1/6/13 12:32:30 01/06/2013 12:32:30
' 1/6/13 12:32:30 01/06/2013 12:32:30
' 1/6/13 12:32:30 PM 01/06/2013 12:32:30
' 1/6/13 12:32:30 PM 01/06/2013 12:32:30
' 1.6.13 12:32:30 01/06/2013 12:32:30
' 1.6.13 12:32:30 01/06/2013 12:32:30
' 1.6.13 12:32:30 PM 01/06/2013 12:32:30
' 1.6.13 12:32:30 PM 01/06/2013 12:32:30
' 2013-06-01 12:32:30 01/06/2013 12:32:30
' 2013-06-01 12:32:30 01/06/2013 12:32:30
' 2013-06-01 12:32:30 PM 01/06/2013 12:32:30
' 2013-06-01 12:32:30 PM 01/06/2013 12:32:30
' 01 June 01/06/2013 00:00:00
' 01 June 01/06/2013 00:00:00
' 2013-06-01T12:32:30.0000000 01/06/2013 12:32:30
' 2013-06-01T12:32:30.0000000 01/06/2013 12:32:30
' Sat, 01 Jun 2013 12:32:30 GMT 01/06/2013 05:32:30
' Sat, 01 Jun 2013 12:32:30 GMT 01/06/2013 05:32:30
' 2013-06-01T12:32:30 01/06/2013 12:32:30
' 12:32 22/04/2013 12:32:00
' 12:32 22/04/2013 12:32:00
' 12:32 PM 22/04/2013 12:32:00
' 12:32 PM 22/04/2013 12:32:00
' 12:32:30 22/04/2013 12:32:30
' 12:32:30 22/04/2013 12:32:30
' 12:32:30 PM 22/04/2013 12:32:30
' 12:32:30 PM 22/04/2013 12:32:30
' 2013-06-01 12:32:30Z 01/06/2013 05:32:30
' 01 June 2013 19:32:30 01/06/2013 19:32:30
' 01 June 2013 19:32:30 01/06/2013 19:32:30
' 01 June 2013 07:32:30 PM 01/06/2013 19:32:30
' 01 June 2013 7:32:30 PM 01/06/2013 19:32:30
' 1 June 2013 19:32:30 01/06/2013 19:32:30
' 1 June 2013 19:32:30 01/06/2013 19:32:30
' 1 June 2013 07:32:30 PM 01/06/2013 19:32:30
' 1 June 2013 7:32:30 PM 01/06/2013 19:32:30
' June 2013 01/06/2013 00:00:00
' June 2013 01/06/2013 00:00:00
Belirli bir biçim veya biçimle eşleşmesi gereken bir dizeyi bir değere dönüştürmek için DateTime ve TryParseExact yöntemlerini kullanırsınızParseExact. Ayrıştırma yöntemine parametre olarak bir veya daha fazla tarih ve saat biçimi dizesi belirtirsiniz. Aşağıdaki örnek, "yyyyMDd" biçiminde veya "HHmmss" biçiminde olması gereken dizeleri değerlere dönüştürmek için DateTime yöntemini kullanırTryParseExact(String, String[], IFormatProvider, DateTimeStyles, DateTime).
string[] formats = { "yyyyMMdd", "HHmmss" };
string[] dateStrings = { "20130816", "20131608", " 20130816 ",
"115216", "521116", " 115216 " };
DateTime parsedDate;
foreach (var dateString in dateStrings)
{
if (DateTime.TryParseExact(dateString, formats, null,
System.Globalization.DateTimeStyles.AllowWhiteSpaces |
System.Globalization.DateTimeStyles.AdjustToUniversal,
out parsedDate))
Console.WriteLine($"{dateString} --> {parsedDate:g}");
else
Console.WriteLine($"Cannot convert {dateString}");
}
// The example displays the following output:
// 20130816 --> 8/16/2013 12:00 AM
// Cannot convert 20131608
// 20130816 --> 8/16/2013 12:00 AM
// 115216 --> 4/22/2013 11:52 AM
// Cannot convert 521116
// 115216 --> 4/22/2013 11:52 AM
let formats = [| "yyyyMMdd"; "HHmmss" |]
let dateStrings =
[ "20130816"; "20131608"; " 20130816 "
"115216"; "521116"; " 115216 " ]
for dateString in dateStrings do
match DateTime.TryParseExact(dateString, formats, null,
System.Globalization.DateTimeStyles.AllowWhiteSpaces |||
System.Globalization.DateTimeStyles.AdjustToUniversal) with
| true, parsedDate ->
printfn $"{dateString} --> {parsedDate:g}"
| _ ->
printfn $"Cannot convert {dateString}"
// The example displays the following output:
// 20130816 --> 8/16/2013 12:00 AM
// Cannot convert 20131608
// 20130816 --> 8/16/2013 12:00 AM
// 115216 --> 4/22/2013 11:52 AM
// Cannot convert 521116
// 115216 --> 4/22/2013 11:52 AM
Dim formats() As String = {"yyyyMMdd", "HHmmss"}
Dim dateStrings() As String = {"20130816", "20131608",
" 20130816 ", "115216",
"521116", " 115216 "}
Dim parsedDate As DateTime
For Each dateString As String In dateStrings
If DateTime.TryParseExact(dateString, formats, Nothing,
DateTimeStyles.AllowWhiteSpaces Or
DateTimeStyles.AdjustToUniversal,
parsedDate) Then
Console.WriteLine($"{dateString} --> {parsedDate:g}")
Else
Console.WriteLine($"Cannot convert {dateString}")
End If
Next
' The example displays the following output:
' 20130816 --> 8/16/2013 12:00 AM
' Cannot convert 20131608
' 20130816 --> 8/16/2013 12:00 AM
' 115216 --> 4/22/2013 11:52 AM
' Cannot convert 521116
' 115216 --> 4/22/2013 11:52 AM
için ParseExact yaygın kullanımlardan biri, web hizmetinden bir dize gösterimini, genellikle ISO 8601 standart biçiminde dönüştürmektir. Aşağıdaki kod, kullanılacak doğru biçim dizesini gösterir:
var iso8601String = "20080501T08:30:52Z";
DateTime dateISO8602 = DateTime.ParseExact(iso8601String, "yyyyMMddTHH:mm:ssZ",
System.Globalization.CultureInfo.InvariantCulture);
Console.WriteLine($"{iso8601String} --> {dateISO8602:g}");
let iso8601String = "20080501T08:30:52Z"
let dateISO8602 = DateTime.ParseExact(iso8601String, "yyyyMMddTHH:mm:ssZ", System.Globalization.CultureInfo.InvariantCulture)
printfn $"{iso8601String} --> {dateISO8602:g}"
Dim iso8601String As String = "20080501T08:30:52Z"
Dim dateISO8602 As DateTime = DateTime.ParseExact(iso8601String, "yyyyMMddTHH:mm:ssZ", CultureInfo.InvariantCulture)
Console.WriteLine($"{iso8601String} --> {dateISO8602:g}")
Bir dize ayrıştırılamıyorsa Parse ve ParseExact yöntemleri bir özel durum oluşturur. ve TryParseExact yöntemleri, TryParse dönüştürmenin başarılı mı yoksa başarısız mı olduğunu gösteren bir Boolean değer döndürür. Performansın TryParse önemli olduğu senaryolarda veya TryParseExact yöntemlerini kullanmanız gerekir. Tarih ve saat dizeleri için ayrıştırma işlemi yüksek hata oranına sahip olma eğilimindedir ve özel durum işleme pahalıdır. Dizeler kullanıcılar tarafından girdiyse veya bilinmeyen bir kaynaktan geliyorsa bu yöntemleri kullanın.
Tarih ve saat değerlerini ayrıştırma hakkında daha fazla bilgi için bkz . Tarih ve Saat Dizelerini Ayrıştırma.
DateTime değerleri
Türdeki saat değerlerinin DateTime açıklamaları genellikle Eşgüdümlü Evrensel Saat (UTC) standardı kullanılarak ifade edilir. Eşgüdümlü Evrensel Saat, Greenwich Saati (GMT) için uluslararası olarak tanınan addır. Eşgüdümlü Evrensel Saat, UTC çıkış noktası olan sıfır derece boylam cinsinden ölçülen süredir. Gün ışığından yararlanma saati UTC için geçerli değildir.
Yerel saat belirli bir saat dilimine göredir. Saat dilimi, saat dilimi uzaklığıyla ilişkilendirilir. Saat dilimi uzaklığı, UTC çıkış noktasından saat cinsinden ölçülen saat diliminin yer değiştirmesidir. Buna ek olarak, yerel saat isteğe bağlı olarak gün ışığından yararlanma saatinden etkilenir ve bu da zaman aralığı ayarlaması ekler veya çıkarır. Yerel saat, UTC'ye saat dilimi uzaklığı eklenerek ve gerekirse gün ışığından yararlanma saati için ayarlanarak hesaplanır. UTC başlangıç noktasında saat dilimi uzaklığı sıfırdır.
UTC saati hesaplamalar, karşılaştırmalar ve dosyalarda tarih ve saat depolamak için uygundur. Yerel saat, masaüstü uygulamalarının kullanıcı arabirimlerinde görüntülenmek için uygundur. Saat dilimine duyarlı uygulamaların (birçok Web uygulaması gibi) bir dizi diğer saat dilimiyle de çalışması gerekir.
Bir DateTime nesnenin Kind özelliği iseDateTimeKind.Unspecified, temsil edilen saatin yerel saat mi, UTC saati mi yoksa başka bir saat dilimindeki bir saat mi olduğu belirtilmez.
DateTime çözümlemesi
Not
Geçen süreyi ölçmek için değerlerde tarih ve saat aritmetiği DateTime gerçekleştirmeye alternatif olarak sınıfını Stopwatch kullanabilirsiniz.
özelliği, Ticks tarih ve saat değerlerini saniyenin on milyonda biri olan birimler halinde ifade eder. özelliği, Millisecond bir tarih ve saat değerinde saniyenin binde birini döndürür. Geçen süreyi ölçmek için özelliğine DateTime.Now yapılan yinelenen çağrıların kullanılması sistem saatine bağlıdır. Windows 7 ve Windows 8 sistemlerinde sistem saati yaklaşık 15 milisaniye çözünürlüğe sahiptir. Bu çözüm, 100 milisaniyeden küçük zaman aralıklarını etkiler.
Aşağıdaki örnekte, sistem saatinin çözünürlüğünde geçerli tarih ve saat değerlerinin bağımlılığı gösterilmektedir. Örnekte, dış döngü 20 kez yineler ve iç döngü dış döngünün gecikmesini sağlar. Dış döngü sayacının değeri 10 ise, yöntemine yapılan Thread.Sleep bir çağrı beş milisaniyelik bir gecikmeye neden olur. Aşağıdaki örnekte özelliği tarafından DateTime.Now.Milliseconds döndürülen milisaniye sayısı yalnızca çağrısından Thread.Sleepsonra gösterilir.
string output = "";
for (int ctr = 0; ctr <= 20; ctr++)
{
output += String.Format($"{DateTime.Now.Millisecond}\n");
// Introduce a delay loop.
for (int delay = 0; delay <= 1000; delay++)
{ }
if (ctr == 10)
{
output += "Thread.Sleep called...\n";
System.Threading.Thread.Sleep(5);
}
}
Console.WriteLine(output);
// Press "Run" to see the output.
let mutable output = ""
for i = 0 to 20 do
output <- output + $"{DateTime.Now.Millisecond}\n"
// Introduce a delay loop.
for _ = 0 to 1000 do ()
if i = 10 then
output <- output + "Thread.Sleep called...\n"
System.Threading.Thread.Sleep 5
printfn $"{output}"
// Press "Run" to see the output.
Dim output As String = ""
For ctr As Integer = 0 To 20
output += Date.Now.Millisecond.ToString() + vbCrLf
' Introduce a delay loop.
For delay As Integer = 0 To 1000
Next
If ctr = 10 Then
output += "Thread.Sleep called..." + vbCrLf
Thread.Sleep(5)
End If
Next
Console.WriteLine(output)
' The example displays output like the following:
' 111
' 111
' 111
' 111
' 111
' 111
' 111
' 111
' 111
' 111
' 111
' Thread.Sleep called...
' 143
' 143
' 143
' 143
' 143
' 143
' 143
' 143
' 143
' 143
DateTime işlemleri
veya Subtractgibi Add bir yapı kullanan bir DateTime hesaplama, yapının değerini değiştirmez. Bunun yerine, hesaplama değeri hesaplamanın sonucu olan yeni DateTime bir yapı döndürür.
Saat dilimleri arasındaki dönüştürme işlemleri (UTC ile yerel saat arasında veya bir saat dilimi ile başka bir saat dilimi arasında) gün ışığından yararlanma saatini dikkate alır, ancak aritmetik ve karşılaştırma işlemleri dikkate almaz.
Yapının DateTime kendisi, bir saat diliminden diğerine dönüştürme için sınırlı destek sunar. YÖNTEMINI kullanarak ToLocalTime UTC'yi yerel saate dönüştürebilir veya yöntemini kullanarak ToUniversalTime yerel saatten UTC'ye dönüştürebilirsiniz. Ancak, sınıfında tam bir saat dilimi dönüştürme yöntemleri kümesi kullanılabilir TimeZoneInfo . Bu yöntemleri kullanarak dünyanın herhangi bir saat dilimindeki saati başka bir saat dilimindeki saate dönüştürürsiniz.
Hesaplamalar ve nesnelerin karşılaştırmaları DateTime yalnızca nesneler aynı saat dilimindeki saatleri temsil ederse anlamlıdır. Bir değerin saat dilimini temsil DateTime etmek için bir nesne kullanabilirsinizTimeZoneInfo, ancak ikisi gevşek bir şekilde birleştirilmiştir. Nesnenin DateTime , bu tarih ve saat değerinin saat dilimini temsil eden bir nesne döndüren bir özelliği yoktur. Kind özelliği utc, yerel saat veya belirtilmemiş olup olmadığını DateTime gösterir. Saat dilimi kullanan bir uygulamada, bir DateTime nesnenin oluşturulduğu saat dilimini belirlemek için bazı dış mekanizmalara güvenmeniz gerekir. Hem değeri hem de değerin DateTime saat dilimini TimeZoneInfo temsil DateTime eden nesneyi sarmalayan bir yapı kullanabilirsiniz. Hesaplamalarda UTC kullanma ve değerlerle karşılaştırmalar hakkında DateTime ayrıntılı bilgi için bkz . Tarih ve Saatlerle Aritmetik İşlemler Gerçekleştirme.
Her DateTime üye, işlemini gerçekleştirmek için Gregoryen takvimi örtük olarak kullanır. Özel durumlar, örtük olarak bir takvim belirten yöntemlerdir. Bunlar, takvim belirten oluşturucuları ve gibi System.Globalization.DateTimeFormatInfoparametresinden IFormatProvidertüretilen yöntemleri içerir.
Türün üyelerine DateTime göre yapılan işlemler, artık yıllar ve ay içindeki gün sayısı gibi ayrıntıları dikkate alır.
DateTime değerleri ve takvimleri
.NET Sınıf Kitaplığı, tümü sınıfından türetilen Calendar bir dizi takvim sınıfı içerir. Bunlar:
- Sınıfı ChineseLunisolarCalendar .
- Sınıfı EastAsianLunisolarCalendar .
- Sınıfı GregorianCalendar .
- Sınıfı HebrewCalendar .
- Sınıfı HijriCalendar .
- Sınıfı JapaneseCalendar .
- Sınıfı JapaneseLunisolarCalendar .
- Sınıfı JulianCalendar .
- Sınıfı KoreanCalendar .
- Sınıfı KoreanLunisolarCalendar .
- Sınıfı PersianCalendar .
- Sınıfı TaiwanCalendar .
- Sınıfı TaiwanLunisolarCalendar .
- Sınıfı ThaiBuddhistCalendar .
- Sınıfı UmAlQuraCalendar .
Ö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çindeki Reiwa döneminin başlangıcını JapaneseCalendar 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 . .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 ç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.
Her kültür, salt CultureInfo.Calendar okunur özelliği tarafından tanımlanan varsayılan bir takvim kullanır. Her kültür, salt CultureInfo.OptionalCalendars okunur özelliği tarafından tanımlanan bir veya daha fazla takvimi destekleyemeyebilir. Şu anda belirli CultureInfo bir nesne tarafından kullanılan takvim özelliği tarafından DateTimeFormatInfo.Calendar tanımlanır. Dizide CultureInfo.OptionalCalendars bulunan takvimlerden biri olmalıdır.
Bir kültürün geçerli takvimi, bu kültürün tüm biçimlendirme işlemlerinde kullanılır. Örneğin, Tay Budist kültürünün varsayılan takvimi, sınıfı tarafından ThaiBuddhistCalendar temsil edilen Tay Budist Dönemi takvimidir. Tay Budist kültürünü temsil eden bir CultureInfo nesne bir tarih ve saat biçimlendirme işleminde kullanıldığında, Tay Budist Dönemi takvimi varsayılan olarak kullanılır. Gregoryen takvim yalnızca aşağıdaki örnekte gösterildiği gibi kültürün DateTimeFormatInfo.Calendar özelliği değiştirildiğinde kullanılır:
var thTH = new System.Globalization.CultureInfo("th-TH");
var value = new DateTime(2016, 5, 28);
Console.WriteLine(value.ToString(thTH));
thTH.DateTimeFormat.Calendar = new System.Globalization.GregorianCalendar();
Console.WriteLine(value.ToString(thTH));
// The example displays the following output:
// 28/5/2559 0:00:00
// 28/5/2016 0:00:00
let thTH = System.Globalization.CultureInfo "th-TH"
let value = DateTime(2016, 5, 28)
printfn $"{value.ToString thTH}"
thTH.DateTimeFormat.Calendar <- System.Globalization.GregorianCalendar()
printfn $"{value.ToString thTH}"
// The example displays the following output:
// 28/5/2559 0:00:00
// 28/5/2016 0:00:00
Dim thTH As New CultureInfo("th-TH")
Dim value As New DateTime(2016, 5, 28)
Console.WriteLine(value.ToString(thTH))
thTH.DateTimeFormat.Calendar = New GregorianCalendar()
Console.WriteLine(value.ToString(thTH))
' The example displays the following output:
' 28/5/2559 0:00:00
' 28/5/2016 0:00:00
Bir kültürün geçerli takvimi, aşağıdaki örnekte gösterildiği gibi bu kültür için tüm ayrıştırma işlemlerinde de kullanılır.
var thTH = new System.Globalization.CultureInfo("th-TH");
var value = DateTime.Parse("28/05/2559", thTH);
Console.WriteLine(value.ToString(thTH));
thTH.DateTimeFormat.Calendar = new System.Globalization.GregorianCalendar();
Console.WriteLine(value.ToString(thTH));
// The example displays the following output:
// 28/5/2559 0:00:00
// 28/5/2016 0:00:00
let thTH = System.Globalization.CultureInfo "th-TH"
let value = DateTime.Parse("28/05/2559", thTH)
printfn $"{value.ToString thTH}"
thTH.DateTimeFormat.Calendar <- System.Globalization.GregorianCalendar()
printfn $"{value.ToString thTH}"
// The example displays the following output:
// 28/5/2559 0:00:00
// 28/5/2016 0:00:00
Private Sub ThaiBuddhistEraParse()
Dim thTH As New CultureInfo("th-TH")
Dim value As DateTime = DateTime.Parse("28/5/2559", thTH)
Console.WriteLine(value.ToString(thTH))
thTH.DateTimeFormat.Calendar = New GregorianCalendar()
Console.WriteLine(value.ToString(thTH))
' The example displays the following output:
' 28/5/2559 0:00:00
' 28/5/2016 0:00:00
End Sub
Belirli bir DateTime takvimin tarih ve saat öğelerini (yıl, ay ve gün sayısı) kullanarak, parametre içeren bir DateTime oluşturucusu çağırıp bu takvimi temsil eden bir nesne geçirerek bir calendarCalendar değerin örneğini oluşturursunuz. Aşağıdaki örnek, takvimdeki tarih ve saat öğelerini ThaiBuddhistCalendar kullanır.
var thTH = new System.Globalization.CultureInfo("th-TH");
var dat = new DateTime(2559, 5, 28, thTH.DateTimeFormat.Calendar);
Console.WriteLine($"Thai Buddhist era date: {dat.ToString("d", thTH)}");
Console.WriteLine($"Gregorian date: {dat:d}");
// The example displays the following output:
// Thai Buddhist Era Date: 28/5/2559
// Gregorian Date: 28/05/2016
let thTH = System.Globalization.CultureInfo "th-TH"
let dat = DateTime(2559, 5, 28, thTH.DateTimeFormat.Calendar)
printfn $"""Thai Buddhist era date: {dat.ToString("d", thTH)}"""
printfn $"Gregorian date: {dat:d}"
// The example displays the following output:
// Thai Buddhist Era Date: 28/5/2559
// Gregorian Date: 28/05/2016
Dim thTH As New CultureInfo("th-TH")
Dim dat As New DateTime(2559, 5, 28, thTH.DateTimeFormat.Calendar)
Console.WriteLine($"Thai Buddhist Era date: {dat.ToString("d", thTH)}")
Console.WriteLine($"Gregorian date: {dat:d}")
' The example displays the following output:
' Thai Buddhist Era Date: 28/5/2559
' Gregorian Date: 28/05/2016
DateTime parametre içermeyen calendar oluşturucular, tarih ve saat öğelerinin Gregoryen takvimde birim olarak ifade edildiği varsayılır.
Diğer DateTime tüm özellikler ve yöntemler Gregoryen takvimi kullanır. Örneğin, DateTime.Year özelliği Gregoryen takvimdeki yılı döndürür ve DateTime.IsLeapYear(Int32) yöntemi parametrenin year Gregoryen takvimde bir yıl olduğunu varsayar. Gregoryen takvimi kullanan her DateTime üye, belirli bir takvimi kullanan sınıfının karşılık gelen bir üyesine Calendar sahiptir. Örneğin, Calendar.GetYear yöntemi belirli bir takvimdeki yılı döndürür ve Calendar.IsLeapYear yöntemi parametreyi year belirli bir takvimde yıl numarası olarak yorumlar. Aşağıdaki örnek, sınıfın hem hem DateTime de ilgili üyelerini ThaiBuddhistCalendar kullanır.
var thTH = new System.Globalization.CultureInfo("th-TH");
var cal = thTH.DateTimeFormat.Calendar;
var dat = new DateTime(2559, 5, 28, cal);
Console.WriteLine("Using the Thai Buddhist Era calendar:");
Console.WriteLine($"Date: {dat.ToString("d", thTH)}");
Console.WriteLine($"Year: {cal.GetYear(dat)}");
Console.WriteLine($"Leap year: {cal.IsLeapYear(cal.GetYear(dat))}\n");
Console.WriteLine("Using the Gregorian calendar:");
Console.WriteLine($"Date: {dat:d}");
Console.WriteLine($"Year: {dat.Year}");
Console.WriteLine($"Leap year: {DateTime.IsLeapYear(dat.Year)}");
// The example displays the following output:
// Using the Thai Buddhist Era calendar
// Date : 28/5/2559
// Year: 2559
// Leap year : True
//
// Using the Gregorian calendar
// Date : 28/05/2016
// Year: 2016
// Leap year : True
let thTH = System.Globalization.CultureInfo "th-TH"
let cal = thTH.DateTimeFormat.Calendar
let dat = DateTime(2559, 5, 28, cal)
printfn "Using the Thai Buddhist Era calendar:"
printfn $"""Date: {dat.ToString("d", thTH)}"""
printfn $"Year: {cal.GetYear dat}"
printfn $"Leap year: {cal.IsLeapYear(cal.GetYear dat)}\n"
printfn "Using the Gregorian calendar:"
printfn $"Date: {dat:d}"
printfn $"Year: {dat.Year}"
printfn $"Leap year: {DateTime.IsLeapYear dat.Year}"
// The example displays the following output:
// Using the Thai Buddhist Era calendar
// Date : 28/5/2559
// Year: 2559
// Leap year : True
//
// Using the Gregorian calendar
// Date : 28/05/2016
// Year: 2016
// Leap year : True
Dim thTH As New CultureInfo("th-TH")
Dim cal As Calendar = thTH.DateTimeFormat.Calendar
Dim dat As New DateTime(2559, 5, 28, cal)
Console.WriteLine("Using the Thai Buddhist Era calendar:")
Console.WriteLine($"Date: {dat.ToString("d", thTH)}")
Console.WriteLine($"Year: {cal.GetYear(dat)}")
Console.WriteLine($"Leap year: {cal.IsLeapYear(cal.GetYear(dat))}")
Console.WriteLine()
Console.WriteLine("Using the Gregorian calendar:")
Console.WriteLine($"Date: {dat:d}")
Console.WriteLine($"Year: {dat.Year}")
Console.WriteLine($"Leap year: {DateTime.IsLeapYear(dat.Year)}")
' The example displays the following output:
' Using the Thai Buddhist Era calendar
' Date : 28/5/2559
' Year: 2559
' Leap year : True
'
' Using the Gregorian calendar
' Date : 28/05/2016
' Year: 2016
' Leap year : True
Yapı, DateTime Gregoryen takvimde haftanın gününü döndüren bir DayOfWeek özellik içerir. Yılın hafta numarasını almanıza olanak tanıyan bir üye içermez. Yılın haftasını almak için tek tek takvimin yöntemini çağırın Calendar.GetWeekOfYear . Aşağıdaki örnek, bir gösterim sağlar.
var thTH = new System.Globalization.CultureInfo("th-TH");
var thCalendar = thTH.DateTimeFormat.Calendar;
var dat = new DateTime(1395, 8, 18, thCalendar);
Console.WriteLine("Using the Thai Buddhist Era calendar:");
Console.WriteLine($"Date: {dat.ToString("d", thTH)}");
Console.WriteLine($"Day of Week: {thCalendar.GetDayOfWeek(dat)}");
Console.WriteLine($"Week of year: {thCalendar.GetWeekOfYear(dat, System.Globalization.CalendarWeekRule.FirstDay, DayOfWeek.Sunday)}\n");
var greg = new System.Globalization.GregorianCalendar();
Console.WriteLine("Using the Gregorian calendar:");
Console.WriteLine($"Date: {dat:d}");
Console.WriteLine($"Day of Week: {dat.DayOfWeek}");
Console.WriteLine($"Week of year: {greg.GetWeekOfYear(dat, System.Globalization.CalendarWeekRule.FirstDay,DayOfWeek.Sunday)}");
// The example displays the following output:
// Using the Thai Buddhist Era calendar
// Date : 18/8/1395
// Day of Week: Sunday
// Week of year: 34
//
// Using the Gregorian calendar
// Date : 18/08/0852
// Day of Week: Sunday
// Week of year: 34
let thTH = System.Globalization.CultureInfo "th-TH"
let thCalendar = thTH.DateTimeFormat.Calendar
let dat = DateTime(1395, 8, 18, thCalendar)
printfn "Using the Thai Buddhist Era calendar:"
printfn $"""Date: {dat.ToString("d", thTH)}"""
printfn $"Day of Week: {thCalendar.GetDayOfWeek dat}"
printfn $"Week of year: {thCalendar.GetWeekOfYear(dat, System.Globalization.CalendarWeekRule.FirstDay, DayOfWeek.Sunday)}\n"
let greg = System.Globalization.GregorianCalendar()
printfn "Using the Gregorian calendar:"
printfn $"Date: {dat:d}"
printfn $"Day of Week: {dat.DayOfWeek}"
printfn $"Week of year: {greg.GetWeekOfYear(dat, System.Globalization.CalendarWeekRule.FirstDay, DayOfWeek.Sunday)}"
// The example displays the following output:
// Using the Thai Buddhist Era calendar
// Date : 18/8/1395
// Day of Week: Sunday
// Week of year: 34
//
// Using the Gregorian calendar
// Date : 18/08/0852
// Day of Week: Sunday
// Week of year: 34
Dim thTH As New CultureInfo("th-TH")
Dim thCalendar As Calendar = thTH.DateTimeFormat.Calendar
Dim dat As New DateTime(1395, 8, 18, thCalendar)
Console.WriteLine("Using the Thai Buddhist Era calendar:")
Console.WriteLine($"Date: {dat.ToString("d", thTH)}")
Console.WriteLine($"Day of Week: {thCalendar.GetDayOfWeek(dat)}")
Console.WriteLine($"Week of year: {thCalendar.GetWeekOfYear(dat, CalendarWeekRule.FirstDay, DayOfWeek.Sunday)}")
Console.WriteLine()
Dim greg As Calendar = New GregorianCalendar()
Console.WriteLine("Using the Gregorian calendar:")
Console.WriteLine($"Date: {dat:d}")
Console.WriteLine($"Day of Week: {dat.DayOfWeek}")
Console.WriteLine($"Week of year: {greg.GetWeekOfYear(dat, CalendarWeekRule.FirstDay, DayOfWeek.Sunday)}")
' The example displays the following output:
' Using the Thai Buddhist Era calendar
' Date : 18/8/1395
' Day of Week: Sunday
' Week of year: 34
'
' Using the Gregorian calendar
' Date : 18/08/0852
' Day of Week: Sunday
' Week of year: 34
Tarihler ve takvimler hakkında daha fazla bilgi için bkz . Takvimlerle Çalışma.
DateTime değerlerini kalıcı hale getirir
Değerleri aşağıdaki yollarla kalıcı DateTime hale getirmeniz gerekir:
- Bunları dizelere dönüştürün ve dizeleri kalıcı hale getirebilirsiniz.
- Bunları 64 bit tamsayı değerlerine (özelliğin Ticks değeri) dönüştürün ve tamsayıları kalıcı hale getirebilirsiniz.
- DateTime değerlerini seri hale getirme.
Değerleri geri yükleyen yordamın DateTime veri kaybetmediğinden veya seçtiğiniz teknikten bağımsız olarak bir özel durum oluşturmadığından emin olmanız gerekir. DateTime değerleri gidiş dönüş olmalıdır. Başka bir ifadeyle, özgün değer ve geri yüklenen değer aynı olmalıdır. Özgün DateTime değer tek bir zaman anını temsil ediyorsa, geri yüklendiğinde aynı zaman anını tanımlaması gerekir.
Değerleri dize olarak kalıcı hale
Dize olarak kalıcı olan değerleri başarıyla geri yüklemek DateTime için şu kuralları izleyin:
Dizeyi kalıcı hale getirdiğinizde olduğu gibi kültüre özgü biçimlendirme hakkında da aynı varsayımları yapın. Geçerli kültürü kaydedildiği sistemin kültüründen farklı olan bir sistemde bir dizenin geri yüklenebilmesini sağlamak için sabit kültürün kurallarını kullanarak dizeyi kaydetmek için aşırı yüklemeyi çağırın ToString . Sabit kültürün Parse(String, IFormatProvider, DateTimeStyles) kurallarını kullanarak dizeyi geri yüklemek için veya TryParse(String, IFormatProvider, DateTimeStyles, DateTime) aşırı yüklemesini çağırın. Hiçbir zaman geçerli kültürün ToString()kurallarını kullanan , Parse(String)veya TryParse(String, DateTime) aşırı yüklemelerini kullanmayın.
Tarih tek bir saati temsil ediyorsa, farklı bir saat diliminde bile geri yüklendiğinde aynı anı temsil ettiğinden emin olun. DateTime Kaydetmeden veya kullanmadan DateTimeOffsetönce değeri Eşgüdümlü Evrensel Saat'e (UTC) dönüştürün.
Değerleri dize olarak kalıcı hale getirirken DateTime yapılan en yaygın hata, varsayılan veya geçerli kültürün biçimlendirme kurallarına güvenmektir. Dizeleri kaydederken ve geri yüklerken geçerli kültür farklıysa sorunlar ortaya çıkar. Aşağıdaki örnekte bu sorunlar gösterilmektedir. Bu örnekte İngilizce (Birleşik Devletler) olan geçerli kültürün biçimlendirme kurallarını kullanarak beş tarih kaydeder. Bu örnekte İngilizce (Birleşik Krallık) olan farklı bir kültürün biçimlendirme kurallarını kullanarak tarihleri geri yükler. İki kültürün biçimlendirme kuralları farklı olduğundan, iki tarih geri yüklenemez ve kalan üç tarih yanlış yorumlanır. Ayrıca, özgün tarih ve saat değerleri zaman içindeki tek anları temsil ederse, saat dilimi bilgileri kaybolduğundan geri yüklenen saatler yanlıştır.
public static void PersistAsLocalStrings()
{
SaveLocalDatesAsString();
RestoreLocalDatesFromString();
}
private static void SaveLocalDatesAsString()
{
DateTime[] dates = { new DateTime(2014, 6, 14, 6, 32, 0),
new DateTime(2014, 7, 10, 23, 49, 0),
new DateTime(2015, 1, 10, 1, 16, 0),
new DateTime(2014, 12, 20, 21, 45, 0),
new DateTime(2014, 6, 2, 15, 14, 0) };
string? output = null;
Console.WriteLine($"Current Time Zone: {TimeZoneInfo.Local.DisplayName}");
Console.WriteLine($"The dates on an {Thread.CurrentThread.CurrentCulture.Name} system:");
for (int ctr = 0; ctr < dates.Length; ctr++)
{
Console.WriteLine(dates[ctr].ToString("f"));
output += dates[ctr].ToString() + (ctr != dates.Length - 1 ? "|" : "");
}
var sw = new StreamWriter(filenameTxt);
sw.Write(output);
sw.Close();
Console.WriteLine("Saved dates...");
}
private static void RestoreLocalDatesFromString()
{
TimeZoneInfo.ClearCachedData();
Console.WriteLine($"Current Time Zone: {TimeZoneInfo.Local.DisplayName}");
Thread.CurrentThread.CurrentCulture = CultureInfo.CreateSpecificCulture("en-GB");
StreamReader sr = new StreamReader(filenameTxt);
string[] inputValues = sr.ReadToEnd().Split(new char[] { '|' },
StringSplitOptions.RemoveEmptyEntries);
sr.Close();
Console.WriteLine("The dates on an {0} system:",
Thread.CurrentThread.CurrentCulture.Name);
foreach (var inputValue in inputValues)
{
DateTime dateValue;
if (DateTime.TryParse(inputValue, out dateValue))
{
Console.WriteLine($"'{inputValue}' --> {dateValue:f}");
}
else
{
Console.WriteLine($"Cannot parse '{inputValue}'");
}
}
Console.WriteLine("Restored dates...");
}
// When saved on an en-US system, the example displays the following output:
// Current Time Zone: (UTC-08:00) Pacific Time (US & Canada)
// The dates on an en-US system:
// Saturday, June 14, 2014 6:32 AM
// Thursday, July 10, 2014 11:49 PM
// Saturday, January 10, 2015 1:16 AM
// Saturday, December 20, 2014 9:45 PM
// Monday, June 02, 2014 3:14 PM
// Saved dates...
//
// When restored on an en-GB system, the example displays the following output:
// Current Time Zone: (UTC) Dublin, Edinburgh, Lisbon, London
// The dates on an en-GB system:
// Cannot parse //6/14/2014 6:32:00 AM//
// //7/10/2014 11:49:00 PM// --> 07 October 2014 23:49
// //1/10/2015 1:16:00 AM// --> 01 October 2015 01:16
// Cannot parse //12/20/2014 9:45:00 PM//
// //6/2/2014 3:14:00 PM// --> 06 February 2014 15:14
// Restored dates...
let saveLocalDatesAsString () =
let dates =
[ DateTime(2014, 6, 14, 6, 32, 0)
DateTime(2014, 7, 10, 23, 49, 0)
DateTime(2015, 1, 10, 1, 16, 0)
DateTime(2014, 12, 20, 21, 45, 0)
DateTime(2014, 6, 2, 15, 14, 0) ]
printfn $"Current Time Zone: {TimeZoneInfo.Local.DisplayName}"
printfn $"The dates on an {Thread.CurrentThread.CurrentCulture.Name} system:"
let output =
[ for date in dates do
printfn $"{date}"
string date ]
|> String.concat "|"
use sw = new StreamWriter(filenameTxt)
sw.Write output
printfn "Saved dates..."
let restoreLocalDatesFromString () =
TimeZoneInfo.ClearCachedData()
printfn $"Current Time Zone: {TimeZoneInfo.Local.DisplayName}"
Thread.CurrentThread.CurrentCulture <- CultureInfo.CreateSpecificCulture "en-GB"
use sr = new StreamReader(filenameTxt)
let inputValues =
sr.ReadToEnd().Split('|', StringSplitOptions.RemoveEmptyEntries)
printfn $"The dates on an {Thread.CurrentThread.CurrentCulture.Name} system:"
for inputValue in inputValues do
match DateTime.TryParse inputValue with
| true, dateValue ->
printfn $"'{inputValue}' --> {dateValue:f}"
| _ ->
printfn $"Cannot parse '{inputValue}'"
printfn "Restored dates..."
let persistAsLocalStrings () =
saveLocalDatesAsString ()
restoreLocalDatesFromString ()
// When saved on an en-US system, the example displays the following output:
// Current Time Zone: (UTC-08:00) Pacific Time (US & Canada)
// The dates on an en-US system:
// Saturday, June 14, 2014 6:32 AM
// Thursday, July 10, 2014 11:49 PM
// Saturday, January 10, 2015 1:16 AM
// Saturday, December 20, 2014 9:45 PM
// Monday, June 02, 2014 3:14 PM
// Saved dates...
//
// When restored on an en-GB system, the example displays the following output:
// Current Time Zone: (UTC) Dublin, Edinburgh, Lisbon, London
// The dates on an en-GB system:
// Cannot parse //6/14/2014 6:32:00 AM//
// //7/10/2014 11:49:00 PM// --> 07 October 2014 23:49
// //1/10/2015 1:16:00 AM// --> 01 October 2015 01:16
// Cannot parse //12/20/2014 9:45:00 PM//
// //6/2/2014 3:14:00 PM// --> 06 February 2014 15:14
// Restored dates...
Gidiş dönüş DateTime değerlerini başarıyla almak için şu adımları izleyin:
- Değerler tek bir zaman anını temsil ediyorsa, yöntemini çağırarak bunları yerel saatten UTC'ye dönüştürün ToUniversalTime .
- veya String.Format(IFormatProvider, String, Object[]) aşırı yüklemesini çağırarak ToString(String, IFormatProvider) tarihleri dize gösterimlerine dönüştürün. Bağımsız değişken olarak belirterek CultureInfo.InvariantCulture sabit kültürün
providerbiçimlendirme kurallarını kullanın. Değerin "O" veya "R" standart biçim dizesini kullanarak gidiş dönüş yapması gerektiğini belirtin.
Kalıcı DateTime değerleri veri kaybı olmadan geri yüklemek için şu adımları izleyin:
- veya TryParseExact aşırı yüklemesini çağırarak verileri ayrıştırınParseExact. Bağımsız değişken olarak
providerbelirtin CultureInfo.InvariantCulture ve dönüştürme sırasında bağımsız değişken için kullandığınız standart biçim dizesiniformatkullanın. DateTimeStyles.RoundtripKind Değeri bağımsız değişkenestylesekleyin. - Değerler zaman içindeki DateTime tek anları temsil ediyorsa, ayrıştırılan tarihi UTC'den yerel saate dönüştürmek için yöntemini çağırın ToLocalTime .
Aşağıdaki örnek, kaydedilen ve geri yüklenen değerlerin kaynak ve hedef sistemlerin sistem, kültür veya saat diliminden bağımsız olarak aynı anı temsil etmesini sağlamak DateTime için sabit kültürü ve "O" standart biçim dizesini kullanır.
public static void PersistAsInvariantStrings()
{
SaveDatesAsInvariantStrings();
RestoreDatesAsInvariantStrings();
}
private static void SaveDatesAsInvariantStrings()
{
DateTime[] dates = { new DateTime(2014, 6, 14, 6, 32, 0),
new DateTime(2014, 7, 10, 23, 49, 0),
new DateTime(2015, 1, 10, 1, 16, 0),
new DateTime(2014, 12, 20, 21, 45, 0),
new DateTime(2014, 6, 2, 15, 14, 0) };
string? output = null;
Console.WriteLine($"Current Time Zone: {TimeZoneInfo.Local.DisplayName}");
Console.WriteLine($"The dates on an {Thread.CurrentThread.CurrentCulture.Name} system:");
for (int ctr = 0; ctr < dates.Length; ctr++)
{
Console.WriteLine(dates[ctr].ToString("f"));
output += dates[ctr].ToUniversalTime().ToString("O", CultureInfo.InvariantCulture)
+ (ctr != dates.Length - 1 ? "|" : "");
}
var sw = new StreamWriter(filenameTxt);
sw.Write(output);
sw.Close();
Console.WriteLine("Saved dates...");
}
private static void RestoreDatesAsInvariantStrings()
{
TimeZoneInfo.ClearCachedData();
Console.WriteLine("Current Time Zone: {0}",
TimeZoneInfo.Local.DisplayName);
Thread.CurrentThread.CurrentCulture = CultureInfo.CreateSpecificCulture("en-GB");
StreamReader sr = new StreamReader(filenameTxt);
string[] inputValues = sr.ReadToEnd().Split(new char[] { '|' },
StringSplitOptions.RemoveEmptyEntries);
sr.Close();
Console.WriteLine("The dates on an {0} system:",
Thread.CurrentThread.CurrentCulture.Name);
foreach (var inputValue in inputValues)
{
DateTime dateValue;
if (DateTime.TryParseExact(inputValue, "O", CultureInfo.InvariantCulture,
DateTimeStyles.RoundtripKind, out dateValue))
{
Console.WriteLine($"'{inputValue}' --> {dateValue.ToLocalTime():f}");
}
else
{
Console.WriteLine("Cannot parse '{0}'", inputValue);
}
}
Console.WriteLine("Restored dates...");
}
// When saved on an en-US system, the example displays the following output:
// Current Time Zone: (UTC-08:00) Pacific Time (US & Canada)
// The dates on an en-US system:
// Saturday, June 14, 2014 6:32 AM
// Thursday, July 10, 2014 11:49 PM
// Saturday, January 10, 2015 1:16 AM
// Saturday, December 20, 2014 9:45 PM
// Monday, June 02, 2014 3:14 PM
// Saved dates...
//
// When restored on an en-GB system, the example displays the following output:
// Current Time Zone: (UTC) Dublin, Edinburgh, Lisbon, London
// The dates on an en-GB system:
// '2014-06-14T13:32:00.0000000Z' --> 14 June 2014 14:32
// '2014-07-11T06:49:00.0000000Z' --> 11 July 2014 07:49
// '2015-01-10T09:16:00.0000000Z' --> 10 January 2015 09:16
// '2014-12-21T05:45:00.0000000Z' --> 21 December 2014 05:45
// '2014-06-02T22:14:00.0000000Z' --> 02 June 2014 23:14
// Restored dates...
let saveDatesAsInvariantStrings () =
let dates =
[ DateTime(2014, 6, 14, 6, 32, 0)
DateTime(2014, 7, 10, 23, 49, 0)
DateTime(2015, 1, 10, 1, 16, 0)
DateTime(2014, 12, 20, 21, 45, 0)
DateTime(2014, 6, 2, 15, 14, 0) ]
printfn $"Current Time Zone: {TimeZoneInfo.Local.DisplayName}"
printfn $"The dates on an {Thread.CurrentThread.CurrentCulture.Name} system:"
let output =
[ for date in dates do
printfn $"{date:f}"
date.ToUniversalTime().ToString("O", CultureInfo.InvariantCulture) ]
|> String.concat "|"
use sw = new StreamWriter(filenameTxt)
sw.Write output
printfn "Saved dates..."
let restoreDatesAsInvariantStrings () =
TimeZoneInfo.ClearCachedData()
printfn $"Current Time Zone: {TimeZoneInfo.Local.DisplayName}"
Thread.CurrentThread.CurrentCulture <- CultureInfo.CreateSpecificCulture "en-GB"
use sr = new StreamReader(filenameTxt)
let inputValues =
sr.ReadToEnd().Split('|', StringSplitOptions.RemoveEmptyEntries)
printfn $"The dates on an {Thread.CurrentThread.CurrentCulture.Name} system:"
for inputValue in inputValues do
match DateTime.TryParseExact(inputValue, "O", CultureInfo.InvariantCulture, DateTimeStyles.RoundtripKind) with
| true, dateValue ->
printfn $"'{inputValue}' --> {dateValue.ToLocalTime():f}"
| _ ->
printfn $"Cannot parse '{inputValue}'"
printfn "Restored dates..."
let persistAsInvariantStrings () =
saveDatesAsInvariantStrings ()
restoreDatesAsInvariantStrings ()
// When saved on an en-US system, the example displays the following output:
// Current Time Zone: (UTC-08:00) Pacific Time (US & Canada)
// The dates on an en-US system:
// Saturday, June 14, 2014 6:32 AM
// Thursday, July 10, 2014 11:49 PM
// Saturday, January 10, 2015 1:16 AM
// Saturday, December 20, 2014 9:45 PM
// Monday, June 02, 2014 3:14 PM
// Saved dates...
//
// When restored on an en-GB system, the example displays the following output:
// Current Time Zone: (UTC) Dublin, Edinburgh, Lisbon, London
// The dates on an en-GB system:
// '2014-06-14T13:32:00.0000000Z' --> 14 June 2014 14:32
// '2014-07-11T06:49:00.0000000Z' --> 11 July 2014 07:49
// '2015-01-10T09:16:00.0000000Z' --> 10 January 2015 09:16
// '2014-12-21T05:45:00.0000000Z' --> 21 December 2014 05:45
// '2014-06-02T22:14:00.0000000Z' --> 02 June 2014 23:14
// Restored dates...
Değerleri tamsayı olarak kalıcı hale
Bir tarih ve saati, bir dizi onay işaretini temsil eden bir Int64 değer olarak kalıcı hale getirirsiniz. Bu durumda, değerlerin kalıcı ve geri yüklendiği sistemlerin DateTime kültürünü göz önünde bulundurmanız gerekmez.
Bir DateTime değeri tamsayı olarak kalıcı hale getirmek için:
- Değerler zaman içindeki DateTime tek anları temsil ediyorsa yöntemini çağırarak bunları UTC'ye dönüştürün ToUniversalTime .
- Özelliğinden Ticks değerle DateTime temsil edilen değer sayısını alın.
Tamsayı olarak kalıcı olan bir DateTime değeri geri yüklemek için:
- Değeri oluşturucuya geçirerek Int64 yeni DateTime bir nesne örneği DateTime(Int64) oluşturma.
- Değer zaman içinde DateTime tek bir anı temsil ediyorsa yöntemini çağırarak UTC'den yerel saate dönüştürün ToLocalTime .
Aşağıdaki örnek, BIR değer dizisini DateTime ABD Pasifik Saat dilimindeki bir sistemde tamsayı olarak kalıcı hale getirir. UTC bölgesindeki bir sisteme geri yükler. Tamsayıları içeren dosya, hemen izleyen değerlerin toplam sayısını Int64 gösteren bir Int32 değer içerir.
public static void PersistAsIntegers()
{
SaveDatesAsInts();
RestoreDatesAsInts();
}
private static void SaveDatesAsInts()
{
DateTime[] dates = { new DateTime(2014, 6, 14, 6, 32, 0),
new DateTime(2014, 7, 10, 23, 49, 0),
new DateTime(2015, 1, 10, 1, 16, 0),
new DateTime(2014, 12, 20, 21, 45, 0),
new DateTime(2014, 6, 2, 15, 14, 0) };
Console.WriteLine($"Current Time Zone: {TimeZoneInfo.Local.DisplayName}");
Console.WriteLine($"The dates on an {Thread.CurrentThread.CurrentCulture.Name} system:");
var ticks = new long[dates.Length];
for (int ctr = 0; ctr < dates.Length; ctr++)
{
Console.WriteLine(dates[ctr].ToString("f"));
ticks[ctr] = dates[ctr].ToUniversalTime().Ticks;
}
var fs = new FileStream(filenameInts, FileMode.Create);
var bw = new BinaryWriter(fs);
bw.Write(ticks.Length);
foreach (var tick in ticks)
bw.Write(tick);
bw.Close();
Console.WriteLine("Saved dates...");
}
private static void RestoreDatesAsInts()
{
TimeZoneInfo.ClearCachedData();
Console.WriteLine($"Current Time Zone: {TimeZoneInfo.Local.DisplayName}");
Thread.CurrentThread.CurrentCulture = CultureInfo.CreateSpecificCulture("en-GB");
FileStream fs = new FileStream(filenameInts, FileMode.Open);
BinaryReader br = new BinaryReader(fs);
int items;
DateTime[] dates;
try
{
items = br.ReadInt32();
dates = new DateTime[items];
for (int ctr = 0; ctr < items; ctr++)
{
long ticks = br.ReadInt64();
dates[ctr] = new DateTime(ticks).ToLocalTime();
}
}
catch (EndOfStreamException)
{
Console.WriteLine("File corruption detected. Unable to restore data...");
return;
}
catch (IOException)
{
Console.WriteLine("Unspecified I/O error. Unable to restore data...");
return;
}
// Thrown during array initialization.
catch (OutOfMemoryException)
{
Console.WriteLine("File corruption detected. Unable to restore data...");
return;
}
finally
{
br.Close();
}
Console.WriteLine($"The dates on an {Thread.CurrentThread.CurrentCulture.Name} system:");
foreach (var value in dates)
Console.WriteLine(value.ToString("f"));
Console.WriteLine("Restored dates...");
}
// When saved on an en-US system, the example displays the following output:
// Current Time Zone: (UTC-08:00) Pacific Time (US & Canada)
// The dates on an en-US system:
// Saturday, June 14, 2014 6:32 AM
// Thursday, July 10, 2014 11:49 PM
// Saturday, January 10, 2015 1:16 AM
// Saturday, December 20, 2014 9:45 PM
// Monday, June 02, 2014 3:14 PM
// Saved dates...
//
// When restored on an en-GB system, the example displays the following output:
// Current Time Zone: (UTC) Dublin, Edinburgh, Lisbon, London
// The dates on an en-GB system:
// 14 June 2014 14:32
// 11 July 2014 07:49
// 10 January 2015 09:16
// 21 December 2014 05:45
// 02 June 2014 23:14
// Restored dates...
let saveDatesAsInts () =
let dates =
[ DateTime(2014, 6, 14, 6, 32, 0)
DateTime(2014, 7, 10, 23, 49, 0)
DateTime(2015, 1, 10, 1, 16, 0)
DateTime(2014, 12, 20, 21, 45, 0)
DateTime(2014, 6, 2, 15, 14, 0) ]
printfn $"Current Time Zone: {TimeZoneInfo.Local.DisplayName}"
printfn $"The dates on an {Thread.CurrentThread.CurrentCulture.Name} system:"
let ticks =
[| for date in dates do
printfn $"{date:f}"
date.ToUniversalTime().Ticks |]
use fs = new FileStream(filenameInts, FileMode.Create)
use bw = new BinaryWriter(fs)
bw.Write ticks.Length
for tick in ticks do
bw.Write tick
printfn "Saved dates..."
let restoreDatesAsInts () =
TimeZoneInfo.ClearCachedData()
printfn $"Current Time Zone: {TimeZoneInfo.Local.DisplayName}"
Thread.CurrentThread.CurrentCulture <- CultureInfo.CreateSpecificCulture "en-GB"
use fs = new FileStream(filenameInts, FileMode.Open)
use br = new BinaryReader(fs)
try
let items = br.ReadInt32()
let dates =
[| for _ in 0..items do
let ticks = br.ReadInt64()
DateTime(ticks).ToLocalTime() |]
printfn $"The dates on an {Thread.CurrentThread.CurrentCulture.Name} system:"
for value in dates do
printfn $"{value:f}"
with
| :? EndOfStreamException ->
printfn "File corruption detected. Unable to restore data..."
| :? IOException ->
printfn "Unspecified I/O error. Unable to restore data..."
// Thrown during array initialization.
| :? OutOfMemoryException ->
printfn"File corruption detected. Unable to restore data..."
printfn "Restored dates..."
let persistAsIntegers () =
saveDatesAsInts ()
restoreDatesAsInts ()
// When saved on an en-US system, the example displays the following output:
// Current Time Zone: (UTC-08:00) Pacific Time (US & Canada)
// The dates on an en-US system:
// Saturday, June 14, 2014 6:32 AM
// Thursday, July 10, 2014 11:49 PM
// Saturday, January 10, 2015 1:16 AM
// Saturday, December 20, 2014 9:45 PM
// Monday, June 02, 2014 3:14 PM
// Saved dates...
//
// When restored on an en-GB system, the example displays the following output:
// Current Time Zone: (UTC) Dublin, Edinburgh, Lisbon, London
// The dates on an en-GB system:
// 14 June 2014 14:32
// 11 July 2014 07:49
// 10 January 2015 09:16
// 21 December 2014 05:45
// 02 June 2014 23:14
// Restored dates...
DateTime değerlerini seri hale getirme
Serileştirme yoluyla değerleri bir akışa veya dosyaya kalıcı DateTime hale getirerek seri durumdan çıkarma yoluyla geri yükleyebilirsiniz. DateTime veriler belirli bir nesne biçiminde serileştirilir. Nesneler seri durumdan çıkarıldığında geri yüklenir. veya XmlSerializergibi JsonSerializer bir biçimlendirici veya seri hale getirici, seri hale getirme ve seri durumdan çıkarma işlemini işler. Serileştirme ve .NET tarafından desteklenen serileştirme türleri hakkında daha fazla bilgi için bkz . Serileştirme.
Aşağıdaki örnek, değerleri seri hale getirmek ve seri durumdan DateTime çıkarmak için sınıfını kullanırXmlSerializer. Değerler yirmi birinci yüzyıldaki tüm artık yıl günlerini temsil eder. Çıkış, örnek geçerli kültürü İngilizce (Birleşik Krallık) olan bir sistemde çalıştırılıyorsa sonucu temsil eder. Nesnenin kendisini seri durumdan çıkardığınızdan DateTime , kodun tarih ve saat biçimlerindeki kültürel farklılıkları işlemesi gerekmez.
public static void PersistAsXML()
{
// Serialize the data.
var leapYears = new List<DateTime>();
for (int year = 2000; year <= 2100; year += 4)
{
if (DateTime.IsLeapYear(year))
leapYears.Add(new DateTime(year, 2, 29));
}
DateTime[] dateArray = leapYears.ToArray();
var serializer = new XmlSerializer(dateArray.GetType());
TextWriter sw = new StreamWriter(filenameXml);
try
{
serializer.Serialize(sw, dateArray);
}
catch (InvalidOperationException e)
{
Console.WriteLine(e.InnerException?.Message);
}
finally
{
if (sw != null) sw.Close();
}
// Deserialize the data.
DateTime[]? deserializedDates;
using (var fs = new FileStream(filenameXml, FileMode.Open))
{
deserializedDates = (DateTime[]?)serializer.Deserialize(fs);
}
// Display the dates.
Console.WriteLine($"Leap year days from 2000-2100 on an {Thread.CurrentThread.CurrentCulture.Name} system:");
int nItems = 0;
if (deserializedDates is not null)
{
foreach (var dat in deserializedDates)
{
Console.Write($" {dat:d} ");
nItems++;
if (nItems % 5 == 0)
Console.WriteLine();
}
}
}
// The example displays the following output:
// Leap year days from 2000-2100 on an en-GB system:
// 29/02/2000 29/02/2004 29/02/2008 29/02/2012 29/02/2016
// 29/02/2020 29/02/2024 29/02/2028 29/02/2032 29/02/2036
// 29/02/2040 29/02/2044 29/02/2048 29/02/2052 29/02/2056
// 29/02/2060 29/02/2064 29/02/2068 29/02/2072 29/02/2076
// 29/02/2080 29/02/2084 29/02/2088 29/02/2092 29/02/2096
let persistAsXML () =
// Serialize the data.
let leapYears =
[| for year in 2000..4..2100 do
if DateTime.IsLeapYear year then
DateTime(year, 2, 29) |]
let serializer = XmlSerializer(leapYears.GetType())
use sw = new StreamWriter(filenameXml)
try
serializer.Serialize(sw, leapYears)
with :? InvalidOperationException as e ->
printfn $"{e.InnerException.Message}"
// Deserialize the data.
use fs = new FileStream(filenameXml, FileMode.Open)
let deserializedDates = serializer.Deserialize fs :?> DateTime []
// Display the dates.
printfn $"Leap year days from 2000-2100 on an {Thread.CurrentThread.CurrentCulture.Name} system:"
let mutable nItems = 0
for dat in deserializedDates do
printf $" {dat:d} "
nItems <- nItems + 1
if nItems % 5 = 0 then
printfn ""
// The example displays the following output:
// Leap year days from 2000-2100 on an en-GB system:
// 29/02/2000 29/02/2004 29/02/2008 29/02/2012 29/02/2016
// 29/02/2020 29/02/2024 29/02/2028 29/02/2032 29/02/2036
// 29/02/2040 29/02/2044 29/02/2048 29/02/2052 29/02/2056
// 29/02/2060 29/02/2064 29/02/2068 29/02/2072 29/02/2076
// 29/02/2080 29/02/2084 29/02/2088 29/02/2092 29/02/2096
Önceki örnekte zaman bilgileri yer almaz. Bir DateTime değer zaman içindeki bir anı temsil ediyorsa ve yerel saat olarak ifade edilirse, yöntemini çağırarak seri hale getirmeden önce yerel saatten UTC'ye dönüştürün ToUniversalTime . Seri durumdan çıkardıktan sonra yöntemini çağırarak UTC'den yerel saate dönüştürün ToLocalTime .
DateTime ve TimeSpan karşılaştırması
DateTime ve TimeSpan değer türleri, a'nın DateTime zaman içindeki bir anlık değeri, bir TimeSpan zaman aralığını temsil ettiği için farklılık gösterir. Aralarındaki zaman aralığını temsil eden bir nesne elde etmek için bir örneğini başka bir TimeSpan örneğinden DateTime çıkarabilirsiniz. Alternatif olarak, gelecekteki bir tarihi temsil eden bir DateTime değer elde etmek için geçerli DateTime değere pozitif TimeSpan de ekleyebilirsiniz.
Bir nesneye DateTime zaman aralığı ekleyebilir veya bir zaman aralığını çıkarabilirsiniz. Zaman aralıkları negatif veya pozitif olabilir ve bunlar değer, saniye veya TimeSpan nesne olarak ifade edilebilir.
Tolerans içinde eşitlik için karşılaştırma
Değerler için DateTime eşitlik karşılaştırmaları tamdır. Eşit kabul edilmesi için iki değerin aynı sayıda değer olarak ifade edilmesi gerekir. Bu duyarlık çoğu uygulama için genellikle gereksiz ve hatta yanlıştır. Genellikle, nesnelerin kabaca eşit olup olmadığını DateTime test etmek istersiniz.
Aşağıdaki örnekte kabaca eşdeğer DateTime değerlerin nasıl karşılaştırılacağ gösterilmektedir. Eşit olarak bildirildiğinde küçük bir fark marjı kabul eder.
public static bool RoughlyEquals(DateTime time, DateTime timeWithWindow, int windowInSeconds, int frequencyInSeconds)
{
long delta = (long)((TimeSpan)(timeWithWindow - time)).TotalSeconds % frequencyInSeconds;
delta = delta > windowInSeconds ? frequencyInSeconds - delta : delta;
return Math.Abs(delta) < windowInSeconds;
}
public static void TestRoughlyEquals()
{
int window = 10;
int freq = 60 * 60 * 2; // 2 hours;
DateTime d1 = DateTime.Now;
DateTime d2 = d1.AddSeconds(2 * window);
DateTime d3 = d1.AddSeconds(-2 * window);
DateTime d4 = d1.AddSeconds(window / 2);
DateTime d5 = d1.AddSeconds(-window / 2);
DateTime d6 = (d1.AddHours(2)).AddSeconds(2 * window);
DateTime d7 = (d1.AddHours(2)).AddSeconds(-2 * window);
DateTime d8 = (d1.AddHours(2)).AddSeconds(window / 2);
DateTime d9 = (d1.AddHours(2)).AddSeconds(-window / 2);
Console.WriteLine($"d1 ({d1}) ~= d1 ({d1}): {RoughlyEquals(d1, d1, window, freq)}");
Console.WriteLine($"d1 ({d1}) ~= d2 ({d2}): {RoughlyEquals(d1, d2, window, freq)}");
Console.WriteLine($"d1 ({d1}) ~= d3 ({d3}): {RoughlyEquals(d1, d3, window, freq)}");
Console.WriteLine($"d1 ({d1}) ~= d4 ({d4}): {RoughlyEquals(d1, d4, window, freq)}");
Console.WriteLine($"d1 ({d1}) ~= d5 ({d5}): {RoughlyEquals(d1, d5, window, freq)}");
Console.WriteLine($"d1 ({d1}) ~= d6 ({d6}): {RoughlyEquals(d1, d6, window, freq)}");
Console.WriteLine($"d1 ({d1}) ~= d7 ({d7}): {RoughlyEquals(d1, d7, window, freq)}");
Console.WriteLine($"d1 ({d1}) ~= d8 ({d8}): {RoughlyEquals(d1, d8, window, freq)}");
Console.WriteLine($"d1 ({d1}) ~= d9 ({d9}): {RoughlyEquals(d1, d9, window, freq)}");
}
// The example displays output similar to the following:
// d1 (1/28/2010 9:01:26 PM) ~= d1 (1/28/2010 9:01:26 PM): True
// d1 (1/28/2010 9:01:26 PM) ~= d2 (1/28/2010 9:01:46 PM): False
// d1 (1/28/2010 9:01:26 PM) ~= d3 (1/28/2010 9:01:06 PM): False
// d1 (1/28/2010 9:01:26 PM) ~= d4 (1/28/2010 9:01:31 PM): True
// d1 (1/28/2010 9:01:26 PM) ~= d5 (1/28/2010 9:01:21 PM): True
// d1 (1/28/2010 9:01:26 PM) ~= d6 (1/28/2010 11:01:46 PM): False
// d1 (1/28/2010 9:01:26 PM) ~= d7 (1/28/2010 11:01:06 PM): False
// d1 (1/28/2010 9:01:26 PM) ~= d8 (1/28/2010 11:01:31 PM): True
// d1 (1/28/2010 9:01:26 PM) ~= d9 (1/28/2010 11:01:21 PM): True
let roughlyEquals (time: DateTime) (timeWithWindow: DateTime) windowInSeconds frequencyInSeconds =
let delta =
int64 (timeWithWindow - time).TotalSeconds % frequencyInSeconds
let delta = if delta > windowInSeconds then frequencyInSeconds - delta else delta
abs delta < windowInSeconds
let testRoughlyEquals () =
let window = 10
let window' = 10.
let freq = 60 * 60 * 2 // 2 hours
let d1 = DateTime.Now
let d2 = d1.AddSeconds(2. * window')
let d3 = d1.AddSeconds(-2. * window')
let d4 = d1.AddSeconds(window' / 2.)
let d5 = d1.AddSeconds(-window' / 2.)
let d6 = (d1.AddHours 2).AddSeconds(2. * window')
let d7 = (d1.AddHours 2).AddSeconds(-2. * window')
let d8 = (d1.AddHours 2).AddSeconds(window' / 2.)
let d9 = (d1.AddHours 2).AddSeconds(-window' / 2.)
printfn $"d1 ({d1}) ~= d1 ({d1}): {roughlyEquals d1 d1 window freq}"
printfn $"d1 ({d1}) ~= d2 ({d2}): {roughlyEquals d1 d2 window freq}"
printfn $"d1 ({d1}) ~= d3 ({d3}): {roughlyEquals d1 d3 window freq}"
printfn $"d1 ({d1}) ~= d4 ({d4}): {roughlyEquals d1 d4 window freq}"
printfn $"d1 ({d1}) ~= d5 ({d5}): {roughlyEquals d1 d5 window freq}"
printfn $"d1 ({d1}) ~= d6 ({d6}): {roughlyEquals d1 d6 window freq}"
printfn $"d1 ({d1}) ~= d7 ({d7}): {roughlyEquals d1 d7 window freq}"
printfn $"d1 ({d1}) ~= d8 ({d8}): {roughlyEquals d1 d8 window freq}"
printfn $"d1 ({d1}) ~= d9 ({d9}): {roughlyEquals d1 d9 window freq}"
// The example displays output similar to the following:
// d1 (1/28/2010 9:01:26 PM) ~= d1 (1/28/2010 9:01:26 PM): True
// d1 (1/28/2010 9:01:26 PM) ~= d2 (1/28/2010 9:01:46 PM): False
// d1 (1/28/2010 9:01:26 PM) ~= d3 (1/28/2010 9:01:06 PM): False
// d1 (1/28/2010 9:01:26 PM) ~= d4 (1/28/2010 9:01:31 PM): True
// d1 (1/28/2010 9:01:26 PM) ~= d5 (1/28/2010 9:01:21 PM): True
// d1 (1/28/2010 9:01:26 PM) ~= d6 (1/28/2010 11:01:46 PM): False
// d1 (1/28/2010 9:01:26 PM) ~= d7 (1/28/2010 11:01:06 PM): False
// d1 (1/28/2010 9:01:26 PM) ~= d8 (1/28/2010 11:01:31 PM): True
// d1 (1/28/2010 9:01:26 PM) ~= d9 (1/28/2010 11:01:21 PM): True
Public Shared Function RoughlyEquals(time As DateTime, timeWithWindow As DateTime,
windowInSeconds As Integer,
frequencyInSeconds As Integer) As Boolean
Dim delta As Long = (timeWithWindow.Subtract(time)).TotalSeconds _
Mod frequencyInSeconds
If delta > windowInSeconds Then
delta = frequencyInSeconds - delta
End If
Return Math.Abs(delta) < windowInSeconds
End Function
Public Shared Sub TestRoughlyEquals()
Dim window As Integer = 10
Dim freq As Integer = 60 * 60 * 2 ' 2 hours;
Dim d1 As DateTime = DateTime.Now
Dim d2 As DateTime = d1.AddSeconds(2 * window)
Dim d3 As DateTime = d1.AddSeconds(-2 * window)
Dim d4 As DateTime = d1.AddSeconds(window / 2)
Dim d5 As DateTime = d1.AddSeconds(-window / 2)
Dim d6 As DateTime = d1.AddHours(2).AddSeconds(2 * window)
Dim d7 As DateTime = d1.AddHours(2).AddSeconds(-2 * window)
Dim d8 As DateTime = d1.AddHours(2).AddSeconds(window / 2)
Dim d9 As DateTime = d1.AddHours(2).AddSeconds(-window / 2)
Console.WriteLine($"d1 ({d1}) ~= d1 ({d1}): {RoughlyEquals(d1, d1, window, freq)}")
Console.WriteLine($"d1 ({d1}) ~= d2 ({d2}): {RoughlyEquals(d1, d2, window, freq)}")
Console.WriteLine($"d1 ({d1}) ~= d3 ({d3}): {RoughlyEquals(d1, d3, window, freq)}")
Console.WriteLine($"d1 ({d1}) ~= d4 ({d4}): {RoughlyEquals(d1, d4, window, freq)}")
Console.WriteLine($"d1 ({d1}) ~= d5 ({d5}): {RoughlyEquals(d1, d5, window, freq)}")
Console.WriteLine($"d1 ({d1}) ~= d6 ({d6}): {RoughlyEquals(d1, d6, window, freq)}")
Console.WriteLine($"d1 ({d1}) ~= d7 ({d7}): {RoughlyEquals(d1, d7, window, freq)}")
Console.WriteLine($"d1 ({d1}) ~= d8 ({d8}): {RoughlyEquals(d1, d8, window, freq)}")
Console.WriteLine($"d1 ({d1}) ~= d9 ({d9}): {RoughlyEquals(d1, d9, window, freq)}")
End Sub
' The example displays output similar to the following:
' d1 (1/28/2010 9:01:26 PM) ~= d1 (1/28/2010 9:01:26 PM): True
' d1 (1/28/2010 9:01:26 PM) ~= d2 (1/28/2010 9:01:46 PM): False
' d1 (1/28/2010 9:01:26 PM) ~= d3 (1/28/2010 9:01:06 PM): False
' d1 (1/28/2010 9:01:26 PM) ~= d4 (1/28/2010 9:01:31 PM): True
' d1 (1/28/2010 9:01:26 PM) ~= d5 (1/28/2010 9:01:21 PM): True
' d1 (1/28/2010 9:01:26 PM) ~= d6 (1/28/2010 11:01:46 PM): False
' d1 (1/28/2010 9:01:26 PM) ~= d7 (1/28/2010 11:01:06 PM): False
' d1 (1/28/2010 9:01:26 PM) ~= d8 (1/28/2010 11:01:31 PM): True
' d1 (1/28/2010 9:01:26 PM) ~= d9 (1/28/2010 11:01:21 PM): True
COM birlikte çalışabilirlik değerlendirmeleri
DateTime BIR COM uygulamasına aktarılan ve ardından yönetilen bir uygulamaya geri aktarılan bir değerin gidiş dönüş olduğu söylenir. Ancak, yalnızca bir saat belirten bir DateTime değer beklediğiniz gibi gidiş dönüş yapmaz.
Yalnızca 15:00 gibi bir saatte gidiş dönüş yaparsanız, son tarih ve saat 15:00 yerine 30 Aralık 1899 C.E.'dir. NET ve COM, yalnızca bir saat belirtildiğinde varsayılan bir tarih olduğunu varsayar. Ancak COM sistemi 30 Aralık 1899 C.E.'nin temel tarihini, .NET ise 1 Ocak 0001 C.E.'nin temel tarihini varsayar.
.NET'ten COM'a yalnızca bir zaman geçirildiğinde, zamanı COM tarafından kullanılan biçime dönüştüren özel işlem gerçekleştirilir. COM'dan .NET'e yalnızca bir zaman geçirildiğinde, 30 Aralık 1899 veya öncesinde geçerli tarih ve saatleri bozacağından özel bir işlem yapılmaz. Bir tarih COM'dan gidiş dönüşe başlarsa, .NET ve COM tarihi korur.
.NET ve COM'un davranışı, uygulamanız yalnızca bir saat belirten bir DateTime gidiş dönüşlüyse, uygulamanızın son DateTime nesnedeki hatalı tarihi değiştirmeyi veya yoksaymaya dikkat etmesi gerektiği anlamına gelir.
Geri Bildirim
Ç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. https://aka.ms/ContentUserFeedback.
Gönderin ve geri bildirimi görüntüleyin