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, JapaneseCalendar ve JapaneseLunisolarCalendarReiwa döneminin başlangıcını işaretledi. Bu tür bir dönem değişikliği, bu takvimleri kullanan tüm uygulamaları etkiler. Daha fazla bilgi edinmek ve uygulamalarınızın etkilenip etkilenmediğini belirlemek için bkz. .NETJapon takviminde yeni bir çağı işleme. Zaman değişikliğine hazır olduğundan emin olmak için uygulamalarınızı Windows sistemlerinde test etme hakkında bilgi için bkz. Uygulamanızı Japon çağı değişikliğine hazırlama. .NET'te birden çok çağa sahip takvimleri destekleyen özellikler ve birden çok çağı destekleyen takvimlerle çalışırken en iyi yöntemler için bkz. Dönemlerle çalışma.

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ğerleri olan tarih ve saatleri temsil eder.

Zaman değerleri, tık olarak adlandırılan 100 nanosaniye birimleriyle ölçülür. Belirli bir tarih, GregorianCalendar takviminde 1 Ocak 0001 M.S. (MS) tarihinden bu yana geçen tik sayısıdır. Sayı, artık saniyelerle eklenmesi gereken tikleri içermez. Örneğin, 31241376000000000L değeri, 01 Ocak 0100 Cuma gece yarısı 12:00:00 tarihini temsil eder. DateTime değeri her zaman açık veya varsayılan takvim bağlamında ifade edilir.

Uyarı

Dakika veya saniye gibi başka bir zaman aralığına dönüştürmek istediğiniz bir değer işaretiyle çalışıyorsanız, dönüştürmeyi gerçekleştirmek için TimeSpan.TicksPerDay, TimeSpan.TicksPerHour, TimeSpan.TicksPerMinute, TimeSpan.TicksPerSecondveya TimeSpan.TicksPerMillisecond sabitini kullanmanız gerekir. Örneğin, belirtilen sayıda tikin temsil ettiği saniye sayısını bir Second değerinin DateTime bileşenine eklemek için dateValue.Second + nTicks/Timespan.TicksPerSecondifadesini kullanabilirsiniz.

Bu makaledeki örnek kümesinin tamamının kaynağını Visual Basic, F#veya C#görüntüleyebilirsiniz.

Uyarı

Belirli saat dilimlerindeki tarih ve saat değerleriyle çalışmaya yönelik DateTime yapısının bir alternatifi de DateTimeOffset yapısıdır. DateTimeOffset yapısı, tarih ve saat bilgilerini özel bir DateTime alanında ve özel bir Int16 alanında bu tarih ve saatin UTC'den farklı olduğu dakika sayısını depolar. Bu, bir DateTimeOffset değerinin belirli bir saat dilimindeki saati yansıtmasını mümkün kılarken, DateTime değeri yalnızca UTC ve yerel saat diliminin saatini açıkça yansıtabilir. Tarih ve saat değerleriyle çalışırken DateTime yapısının veya DateTimeOffset yapısının ne zaman kullanılacağı hakkında bir tartışma için bkz. DateTime, DateTimeOffset, TimeSpan ve TimeZoneInfo arasında seçim.

Örnek koda hızlı bağlantılar

Uyarı

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üttükten sonra, kodu değiştirebilir ve değiştirilen kodu yeniden çalıştır'ı seçerek ç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 durum, DateTime, DateTimeOffset ve TimeZoneInfo türlerini ve üyelerini gösteren örneklerin davranışını ve çıktısını etkileyebilir.

Bu makale, DateTime türünü kullanan birkaç örnek içerir:

Başlatma örnekleri

• Bir oluşturucu çağırma
• Örtük parametresiz oluşturucuyu çağırın
• Dönüş değerinden atama
• Tarih ve saati temsil eden bir dizeyi ayrıştırma
• Visual Basic söz dizimini kullanarak tarih ve saat başlatmak

DateTime nesnelerini dize örnekleri olarak biçimlendirme

• Varsayılan tarih saat biçimini kullan
• Belirli bir kültür kullanarak tarih ve saat biçimlendirme
• Standart veya özel biçim dizesi kullanarak tarih saatini biçimlendirme
• Hem biçim dizesi hem de belirli bir kültür belirtin
• Web hizmetleri için ISO 8601 standardını kullanarak tarih saatini biçimlendirme

Dizeleri DateTime nesne örnekleri olarak ayrıştırma

• Parse dönüştürmek için TryParse veya kullanma
• Bilinen biçimdeki bir dizeyi dönüştürmek için ParseExact veya TryParseExact kullanma
• ISO 8601 dize gösterimini tarihe ve saate dönüştür

DateTime çözüm örnekleri

• Tarih ve saat değerlerinin çözümlemesini keşfetme
• Eşitlik karşılaştırması tolerans dahilinde

Kültür ve takvim örnekleri

• Kültüre özgü takvimleri kullanarak tarih ve saat değerlerini görüntüleme
• Kültüre özgü spesifik takvime göre dizeleri ayrıştır
• Belirli bir kültürün takviminden bir tarih ve saati başlat
• Belirli bir kültürün takvim kullanarak tarih ve saat özelliklerine erişme
• Kültüre özgü takvimleri kullanarak yılın haftasını alma

Kalıcılık örnekleri

• yerel saat diliminde dize olarak tarih ve saat değerlerini kalıcı hale
• tarih ve saat değerlerini kültür ve saat sabit biçiminde dizeler olarak kalıcı hale
• Tarih ve saat değerlerini tamsayılar olarak saklama
• Tarih ve saat değerlerini XmlSerializer kullanarak kalıcı olarak saklamak

DateTime nesnesini başlatma

Yeni bir DateTime değerine birçok farklı yolla başlangıç değeri 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 özelliğin veya yöntemin dönüş değerine DateTime atama.
• Bir DateTime değerini dize gösteriminden ayrıştırma.
• DateTimeörneği oluş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, gün veya anlık zaman birimi sayısı gibi) belirten DateTime yapıcısının aşırı yüklemelerinden herhangi birini çağırırsınız. Aşağıdaki kod, yıl, ay, gün, saat, dakika ve saniyeyi belirten DateTime oluşturucuyu kullanarak 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}"

bir DateTime varsayılan değerine başlatılmasını istediğinizde, DateTime yapısı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 DateTime değeri bildirmeyi de destekler. Açık bir başlatma olmadan bir değer oluşturmak da varsayılan değerle sonuç verir. Aşağıdaki örnek, C# ve Visual Basic'teki DateTime örtük parametresiz oluşturucunun yanı sıra Visual Basic'te atama olmadan DateTime bildirimini gösterir.

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 bir değeri ata

DateTime nesnesine 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şkenine 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

Parse, ParseExact, TryParseve TryParseExact yöntemleri bir dizeyi eşdeğer tarih ve saat değerine dönüştürür. Aşağıdaki örnekler, bir dizeyi ayrıştırmak ve Parse bir değere dönüştürmek için ParseExact ve DateTime yöntemlerini kullanır. İkinci biçim, dize biçiminde tarih ve saati 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 DateTime değerin geçerli bir gösterimi olup olmadığını gösterir ve varsa dönüştürmeyi gerçekleştirir.

Visual Basic için dile özgü söz dizimi

Aşağıdaki Visual Basic deyimi yeni bir DateTime değeri 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ğerleri 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ğeri, bu değerin görüntülenme şekline bağımsızdır. 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. DateTime yapısı, ToString'in aşırı yüklemeleriyle tarih ve saat değerlerini biçimlendirme esnekliği sunar. Varsayılan DateTime.ToString() yöntemi, 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öntemini 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 DateTime.ToString(IFormatProvider) yöntemini kullanarak kültürü belirtirsiniz. Aşağıdaki örnek, fr-FR kültürü için kısa tarih ve uzun saat desenini kullanarak tarih ve saati görüntülemek için DateTime.ToString(IFormatProvider) 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. DateTime.ToString(String) yöntemi, 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, DateTime.ToString(String) yöntemini kullanarak en-US kültürün tam tarih ve saat desenini( örneğin çalıştırıldığı bilgisayardaki geçerli kültürü) görüntüler.

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, DateTime.ToString(String, IFormatProvider) yöntemini kullanarak hem kültürü hem de biçimi belirtebilirsiniz. Aşağıdaki örnek, fr-FR kültürü için tam tarih ve saat desenini görüntülemek için DateTime.ToString(String, IFormatProvider) 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

DateTime.ToString(String) aşırı yüklemesi, 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

DateTime değerlerini biçimlendirme 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, bir 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 tarih değeri girişine izin verir. Geçerli kültürü en-gb olan bir kullanıcının bir tarih değerini "15/12/2013" veya "15 Aralık 2013" olarak girmesine 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.

Parse veya TryParse yöntemini kullanarak bir dizeyi bir kültür tarafından kullanılan ortak tarih ve saat biçimlerinden birinden DateTime bir değere dönüştürebilirsiniz. Aşağıdaki örnekte, kültüre özgü farklı biçimlerdeki tarih dizelerini TryParse bir değere dönüştürmek için DateTime nasıl kullanabileceğiniz 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 GetDateTimeFormats() yöntemini çağırır. Ardından dizideki her öğeyi TryParse yöntemine 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 ParseExact bir değere dönüştürmek için TryParseExact ve DateTime yöntemlerini kullanırsınız. Ayrıştırma yöntemine parametre olarak bir veya daha fazla tarih ve saat biçimi dizesi belirtirsiniz. Aşağıdaki örnek, "yyyyMMdd" biçiminde veya "HHmmss" biçiminde olması gereken dizeleri, TryParseExact(String, String[], IFormatProvider, DateTimeStyles, DateTime) değerlerine dönüştürmek için DateTime yöntemini kullanır.

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

ParseExact için yaygın kullanılanlardan biri, web hizmetinden bir dize gösterimini, genellikle ISO 8601 standart biçimde 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. TryParse ve TryParseExact yöntemleri, dönüştürmenin başarılı mı yoksa başarısız mı olduğunu gösteren bir Boolean değeri döndürür. Performansın önemli olduğu senaryolarda TryParse 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

DateTime türündeki saat değerlerinin 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 bir zaman aralığı ayarlaması ekleyebilir veya çıkarabilir. 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 Kind nesnesinin DateTime özelliği DateTimeKind.Unspecifiedise, temsil edilen saatin yerel saat, UTC saati veya başka bir saat dilimindeki bir saat olup olmadığı belirtilmez.

DateTime çözünürlüğü

Uyarı

Geçen süreyi ölçmek için DateTime değerlerde tarih ve saat aritmetiği gerçekleştirmeye alternatif olarak, Stopwatch sınıfını kullanabilirsiniz.

Ticks özelliği, tarih ve saat değerlerini saniyenin on milyonda biri cinsinden ifade eder. Millisecond özelliği, bir tarih ve saat değerinde saniyenin binde birini döndürür. Geçen süreyi ölçmek için DateTime.Now özelliğine 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, Thread.Sleep yöntemine yapılan bir çağrı beş milisaniyelik bir gecikmeye neden olur. Aşağıdaki örnek, yalnızca DateTime.Now.Millisecondsçağrısından sonra Thread.Sleep özelliği tarafından döndürülen milisaniye sayısını gösterir.

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

DateTime veya Addgibi Subtract bir yapı kullanan hesaplama, yapının değerini değiştirmez. Bunun yerine hesaplama, değeri hesaplamanın sonucu olan yeni bir DateTime yapısı 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.

DateTime yapısının kendisi, bir saat diliminden diğerine dönüştürme için sınırlı destek sunar. UTC'yi yerel saate dönüştürmek için ToLocalTime yöntemini veya yerel saatten UTC'ye dönüştürmek için ToUniversalTime yöntemini kullanabilirsiniz. Ancak, TimeZoneInfo sınıfında tam bir saat dilimi dönüştürme yöntemleri kümesi kullanılabilir. Bu yöntemleri kullanarak dünyanın herhangi bir saat dilimindeki saati başka bir saat dilimindeki saate dönüştürürsiniz.

DateTime nesnelerin hesaplamaları ve karşılaştırmaları, ancak nesneler aynı saat dilimindeki saatleri temsil ederse anlamlıdır. TimeZoneInfo değerin saat dilimini temsil etmek için bir DateTime nesnesi kullanabilirsiniz, ancak ikisi gevşek bir şekilde birleştirilmiştir. DateTime nesnesinin, bu tarih ve saat değerinin saat dilimini temsil eden bir nesne döndüren bir özelliği yoktur. Kind özelliği, bir DateTime UTC'yi, yerel saati veya belirtilmemiş bir saati temsil eder. Saat dilimi kullanan bir uygulamada, bir DateTime nesnesinin oluşturulduğu saat dilimini belirlemek için bazı dış mekanizmalara güvenmeniz gerekir. hem DateTime değerini hem de TimeZoneInfo değerinin saat dilimini temsil eden DateTime nesnesini sarmalayan bir yapı kullanabilirsiniz. hesaplamalarda UTC kullanma ve DateTime değerlerle karşılaştırmalar hakkında ayrıntılı bilgi için bkz. Tarih ve Saatlerle Aritmetik İşlemler Gerçekleştirme.

Her DateTime üyesi, 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 IFormatProvidergibi System.Globalization.DateTimeFormatInfotüretilmiş bir parametreye sahip yöntemleri içerir.

DateTime türünün üyelerine göre yapılan işlemler, artık yıllar ve bir ayın gün sayısı gibi ayrıntıları dikkate alır.

DateTime değerleri ve takvimleri

.NET Sınıf Kitaplığı, tümü Calendar sınıfından türetilen bir dizi takvim sınıfı içerir. Bunlar şunlardır:

• 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 sınıfı.

Önemli

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

Her kültür, salt okunur CultureInfo.Calendar özelliği tarafından tanımlanan varsayılan bir takvim kullanır. Her kültür, salt okunur CultureInfo.OptionalCalendars özelliği tarafından tanımlanan bir veya daha fazla takvimi destekleyebilir. Şu anda belirli bir CultureInfo nesnesi tarafından kullanılan takvim, DateTimeFormatInfo.Calendar özelliği tarafından tanımlanır. CultureInfo.OptionalCalendars dizisinde 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, ThaiBuddhistCalendar sınıfı tarafından temsil edilen Tay Budist Dönemi takvimidir. Tay Budist kültürünü temsil eden bir CultureInfo nesnesi 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 takvimin yıl, ay ve gün sayısı gibi tarih ve saat öğelerini kullanarak bir DateTime değeri örneklemek için, bir nesnesi ile o takvimi temsil eden ve calendar parametresini içeren bir Calendar çağırırsınız. Aşağıdaki örnek, ThaiBuddhistCalendar takvimindeki tarih ve saat öğelerini 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 parametresi içermeyen calendar oluşturucular, tarih ve saat öğelerinin Gregoryen takvimde birim olarak ifade edildiği varsayılır.

Diğer tüm DateTime özellikleri ve yöntemleri Gregoryen takvimi kullanır. Örneğin, DateTime.Year özelliği Gregoryen takvimdeki yılı döndürür ve DateTime.IsLeapYear(Int32) yöntemi year parametresinin Gregoryen takvimde bir yıl olduğunu varsayar. Gregoryen takvimi kullanan her DateTime üyesi, belirli bir takvimi kullanan Calendar sınıfının karşılık gelen bir üyesine sahiptir. Örneğin, Calendar.GetYear yöntemi belirli bir takvimdeki yılı döndürür ve Calendar.IsLeapYear yöntemi year parametresini belirli bir takvimde yıl numarası olarak yorumlar. Aşağıdaki örnek hem DateTime hem de ThaiBuddhistCalendar sınıfının ilgili üyelerini 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

DateTime yapısı, Gregoryen takvimde haftanın gününü döndüren bir DayOfWeek özelliği 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 bireysel takvimin Calendar.GetWeekOfYear yöntemini çağırın. 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

DateTime değerlerini aşağıdaki yollarla kalıcı hale getirmeniz gerekir:

• Bunları dizelere dönüştürün ve dizeleri kalıcı hale getirebilirsiniz.
• Bunları 64 bit tamsayı değerlerine dönüştürün (Ticks özelliğinin değeri) ve tamsayıları kalıcı hale getirebilirsiniz.
• DateTime değerlerini serileştirin.

DateTime değerlerini geri yükleyen yordamın hangi tekniği seçerseniz seçin veri kaybetmediğinden veya ö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ğeri tek bir zaman anını temsil ediyorsa, geri yüklendiğinde aynı zaman anını tanımlaması gerekir.

Değerleri metin olarak sakla

Dize olarak kalıcı olan DateTime değerleri başarıyla geri yüklemek için şu kuralları izleyin:

• Dizeyi geri yüklediğinizde, onu kalıcı hale getirdiğiniz zamanki gibi, kültüre özgü biçimlendirme hakkında da aynı varsayımları yapın. Bir dizenin, kaydedildiği sistemin kültüründen farklı olan güncel bir kültüre sahip bir sistemde geri yüklenebilmesini sağlamak için, değişmez kültürün kurallarını kullanarak dizenin kaydedilmesi amacıyla ToString aşırı yüklemesini çağırın. Sabit kültürün kurallarını kullanarak dizeyi geri yüklemek için Parse(String, IFormatProvider, DateTimeStyles) veya TryParse(String, IFormatProvider, DateTimeStyles, DateTime) metodunun aşırı yüklemesini çağırın. Hiçbir zaman geçerli kültürün kurallarını kullanan ToString(), 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. kaydetmeden önce DateTime değerini Eşgüdümlü Evrensel Saat'e (UTC) dönüştürün veya DateTimeOffsetkullanın.

DateTime değerleri dize olarak kalıcı hale getirirken yapılan en yaygın hata, varsayılan veya geçerli kültürün biçimlendirme kurallarına güvenmektir. Geçerli kültür farklıysa, dizeleri kaydederken ve geri yüklerken sorunlar ortaya çıkar. Aşağıdaki örnekte bu sorunlar gösterilmektedir. Bu örnekte İngilizce (ABD) 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 {Thread.CurrentThread.CurrentCulture.Name} system:");
    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...

DateTime değerlerini başarıyla geri dönüştürmek için şu adımları izleyin:

1. Değerler tek bir zaman anını temsil ediyorsa, ToUniversalTime yöntemini çağırarak bunları yerel saatten UTC'ye dönüştürün.
2. ToString(String, IFormatProvider) veya String.Format(IFormatProvider, String, Object[]) aşırı yüklemesini çağırarak tarihleri dize gösterimlerine dönüştürün. Sabit kültürün biçimlendirme kurallarını kullanmak için CultureInfo.InvariantCulture bağımsız değişken olarak provider belirtin. Değerin "O" veya "R" standart biçim dizesini kullanarak gidiş dönüş yapması gerektiğini belirtin.

Kalıcı DateTime değerlerini veri kaybı olmadan geri yüklemek için şu adımları izleyin:

1. ParseExact veya TryParseExact aşırı yüklemesini çağırarak verileri ayrıştırın. CultureInfo.InvariantCulture bağımsız değişkeni olarak provider belirtin ve dönüştürme sırasında format bağımsız değişkeni için kullandığınız standart biçim dizesini kullanın. DateTimeStyles.RoundtripKind bağımsız değişkenine styles değerini ekleyin.
2. DateTime değerleri zaman içindeki tek anları temsil ediyorsa, ayrıştırılan tarihi UTC'den yerel saate dönüştürmek için ToLocalTime yöntemini çağırın.

Aşağıdaki örnek, kaydedilen ve geri yüklenen DateTime değerlerinin kaynak ve hedef sistemlerin sistem, kültür veya saat diliminden bağımsız olarak aynı anı temsil etmesini sağlamak 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: {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 {Thread.CurrentThread.CurrentCulture.Name} system:");
    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 '{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 sakla

Bir tarih ve saati, bir dizi tık sayısını temsil eden bir Int64 değeri olarak kalıcı hale getirebilirsiniz. Bu durumda, DateTime değerlerinin kalıcı hale getirilip geri yüklendiği sistemlerin kültürünü göz önünde bulundurmanız gerekmez.

bir DateTime değerini tamsayı olarak kalıcı hale getirmek için:

1. DateTime değerleri zaman içindeki tek anları temsil ediyorsa, ToUniversalTime yöntemini çağırarak bunları UTC'ye dönüştürün.
2. DateTime özelliğinden Ticks değeriyle temsil edilen tık sayısını alın.

Tamsayı olarak kalıcı olan bir DateTime değerini geri yüklemek için:

1. DateTime değerini Int64 oluşturucuya geçirerek yeni bir DateTime(Int64) nesnesi örneği oluşturma.
2. DateTime değeri zaman içinde tek bir anı temsil ediyorsa, ToLocalTime yöntemini çağırarak UTC'den yerel saate dönüştürün.

Aşağıdaki örnek, ABD Pasifik Saat dilimindeki bir sistemde tamsayılar olarak bir DateTime değerleri dizisini kalıcı hale getirir. Onu UTC bölgesindeki bir sisteme geri yükler. Tamsayıları içeren dosya, hemen izleyen Int32 değerlerinin toplam sayısını gösteren bir Int64 değeri 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 DateTime değerlerini bir akışa veya dosyaya saklayabilir ve ardından 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. JsonSerializer veya XmlSerializergibi bir biçimlendirici veya serileştirici, serileştirme ve seriden çıkarma işlemlerini 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, XmlSerializer değerlerini serileştirmek ve seriden çıkarmak için DateTime sınıfını kullanır. Değerler yirmi birinci yüzyıldaki tüm artık yıllara ait günleri 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. DateTime nesnesinin kendisini seri durumdan çıkardığınızdan, 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. DateTime değeri bir anı temsil ediyorsa ve yerel saat olarak ifade edilirse, ToUniversalTime yöntemini çağırarak seri hale getirmeden önce yerel saatten UTC'ye dönüştürün. Seriden çıkardıktan sonra, ToLocalTime yöntemini çağırarak UTC'den yerel saate dönüştürün.

DateTime ve TimeSpan karşılaştırması

DateTime ve TimeSpan değer türleri, DateTime anlık bir zamanı temsil ederken, TimeSpan zaman aralığını temsil eder. Aralarındaki zaman aralığını temsil eden bir DateTime nesnesi elde etmek için bir TimeSpan örneğini başka bir örnekten çıkarabilirsiniz. Alternatif olarak, geçerli TimeSpan'e olumlu bir DateTime ekleyerek, gelecekteki bir tarihi temsil eden bir DateTime değeri elde edebilirsiniz.

bir DateTime nesnesine zaman aralığı ekleyebilir veya çıkarabilirsiniz. Zaman aralıkları negatif veya pozitif olabilir ve tıklamalar, saniyeler veya TimeSpan nesnesi olarak ifade edilebilir.

Tolerans içinde eşitlik için karşılaştırma

DateTime değerleri için eşitlik karşılaştırmaları kesindir. İki değerin eşit kabul edilmesi için, aynı sayıda tıklama olarak ifade edilmeleri gerekir. Bu kesinlik çoğu uygulama için genellikle gereksiz veya hatta yanlıştır. Genellikle, DateTime nesnelerin kabacaeşit olup olmadığını test etmek istersiniz.

Aşağıdaki örnekte kabaca eşdeğer DateTime değerlerinin nasıl karşılaştırılacağ gösterilmektedir. Eşit oldukları kabul edildiğinde küçük bir fark payını 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ışma konuları

COM uygulamasına aktarılan ve ardından yönetilen bir uygulamaya geri döndürülen DateTime değerine çift yönlü geçiş denir. Ancak, yalnızca bir saat belirten bir DateTime değeri beklediğiniz gibi gidiş dönüş yapmaz.

Sadece bir zaman, örneğin 15:00 belirtilirse, son tarih ve saat 1 Ocak 0001 M.S. 15:00 yerine 30 Aralık 1899 M.S. 15:00 olur. .NET ve COM, yalnızca bir saat verildiğinde varsayılan bir tarihi 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ın sadece saati belirten bir DateTime verisinin gidiş-dönüş işlemini yapıyorsa, son DateTime nesnesindeki hatalı tarihi düzeltmesi veya göz ardı etmesi gerektiği anlamına gelir.