DateTime Yapı

Tanım

Genellikle günün tarih ve saati olarak ifade edilen bir anlık zamanı temsil eder.

public value class DateTime : IComparable, IComparable<DateTime>, IConvertible, IEquatable<DateTime>, IFormattable
public value class DateTime : IComparable, IComparable<DateTime>, IConvertible, IEquatable<DateTime>, IFormattable, System::Runtime::Serialization::ISerializable
public value class DateTime : IComparable, IComparable<DateTime>, IConvertible, IEquatable<DateTime>, ISpanFormattable, System::Runtime::Serialization::ISerializable
public value class DateTime : IComparable, IComparable<DateTime>, IConvertible, IEquatable<DateTime>, IParsable<DateTime>, ISpanFormattable, ISpanParsable<DateTime>, System::Runtime::Serialization::ISerializable
public value class DateTime : IComparable, IConvertible, IFormattable
public value class DateTime : IComparable, IComparable<DateTime>, IEquatable<DateTime>, IFormattable
public struct DateTime : IComparable, IComparable<DateTime>, IConvertible, IEquatable<DateTime>, IFormattable
public readonly struct DateTime : IComparable, IComparable<DateTime>, IConvertible, IEquatable<DateTime>, IFormattable, System.Runtime.Serialization.ISerializable
public readonly struct DateTime : IComparable, IComparable<DateTime>, IConvertible, IEquatable<DateTime>, ISpanFormattable, System.Runtime.Serialization.ISerializable
public readonly struct DateTime : IComparable, IComparable<DateTime>, IConvertible, IEquatable<DateTime>, IParsable<DateTime>, ISpanFormattable, ISpanParsable<DateTime>, System.Runtime.Serialization.ISerializable
public struct DateTime : IComparable, IComparable<DateTime>, IConvertible, IEquatable<DateTime>, IFormattable, System.Runtime.Serialization.ISerializable
[System.Serializable]
public struct DateTime : IComparable, IConvertible, IFormattable
[System.Serializable]
public struct DateTime : IComparable, IComparable<DateTime>, IConvertible, IEquatable<DateTime>, IFormattable, System.Runtime.Serialization.ISerializable
public struct DateTime : IComparable, IComparable<DateTime>, IEquatable<DateTime>, IFormattable
type DateTime = struct
    interface IConvertible
    interface IFormattable
type DateTime = struct
    interface IConvertible
    interface IFormattable
    interface ISerializable
type DateTime = struct
    interface IConvertible
    interface ISpanFormattable
    interface IFormattable
    interface ISerializable
type DateTime = struct
    interface IConvertible
    interface IFormattable
    interface IParsable<DateTime>
    interface ISpanFormattable
    interface ISpanParsable<DateTime>
    interface ISerializable
[<System.Serializable>]
type DateTime = struct
    interface IFormattable
    interface IConvertible
[<System.Serializable>]
type DateTime = struct
    interface IFormattable
    interface IConvertible
    interface ISerializable
type DateTime = struct
    interface IFormattable
Public Structure DateTime
Implements IComparable, IComparable(Of DateTime), IConvertible, IEquatable(Of DateTime), IFormattable
Public Structure DateTime
Implements IComparable, IComparable(Of DateTime), IConvertible, IEquatable(Of DateTime), IFormattable, ISerializable
Public Structure DateTime
Implements IComparable, IComparable(Of DateTime), IConvertible, IEquatable(Of DateTime), ISerializable, ISpanFormattable
Public Structure DateTime
Implements IComparable, IComparable(Of DateTime), IConvertible, IEquatable(Of DateTime), IParsable(Of DateTime), ISerializable, ISpanFormattable, ISpanParsable(Of DateTime)
Public Structure DateTime
Implements IComparable, IConvertible, IFormattable
Public Structure DateTime
Implements IComparable, IComparable(Of DateTime), IEquatable(Of DateTime), IFormattable
Devralma
DateTime
Öznitelikler
Uygulamalar

Açıklamalar

Önemli

Japonca takvimlerde dönemler, yağışın temellerini temel almaktadır ve bu nedenle değişmesi beklenir. Örneğin, 1 Mayıs 2019, ve 'de Reiwa döneminin başlangıcını işaret JapaneseCalendar JapaneseLunisolarCalendar etti. Bu tür bir dönem değişikliği, bu takvimleri kullanan tüm uygulamaları etkiler. Daha fazla bilgi için ve uygulamalarınızı etkilendiğini belirlemek için bkz. .NET'te Japonca takviminde yeni bir dönemi işleme. Uygulamalarınızı dönem değişikliğine hazır Windows için uygulamalarınızı farklı sistemlerde test etme hakkında bilgi için bkz. Uygulamalarınızı Japonca dönemi değişikliğine hazırlama. .NET'te birden çok dönem içeren takvimleri destekleyen özellikler ve birden çok dönemi destekleyen takvimlerle çalışırken en iyi yöntemler için bkz. Silmelerle çalışma.

Not

Bu makaledeki bazı C# örnekleri TRY.net satır içi kod Çalıştırıcısı ve PLAYIN içinde çalışır. Etkileşimli bir pencerede örnek çalıştırmak için Çalıştır düğmesini seçin. Kodu yürüttüğünüzde, bunu değiştirebilir ve yeniden Çalıştır ' ı seçerek 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# Derleyici hata iletileri görüntülenir.

TRY.net satır içi kod Çalıştırıcısı ve playzemin 'nin Yerel Saat dilimi Eşgüdümlü Evrensel Saat veya UTC 'dir. Bu durum,, DateTime DateTimeOffset , ve türlerini ve üyelerini gösteren örneklerin, davranışını ve çıkışını etkileyebilir TimeZoneInfo .

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

Başlatma Örnekleri

Nesneleri dize olarak biçimlendirme DateTime

Dizeleri nesne olarak DateTime ayrıştırma

DateTime Çözünürlük

Kültür ve takvimler

Kalıcılık

Bu bölüm, yapısında birçok yaygın kullanım için DateTime konular içerir:

DateTime Değer türü, 00:00:00 (gece yarısı), 1 Ocak 0001 Anno Domini (Common Era) ile 11:59:59 P.M., 31 Aralık 9999 A.D arasında değişen değerlerle tarihleri ve saatleri temsil eder. (C.E.) Gregoryen takvimde.

Zaman değerleri, değer çizgisi adı verilen 100 nanosaniye cinsinden ölçülür. Belirli bir tarih, 12:00 gece yarısından (1 Ocak 0001) bu yana olan değer çizgisi sayısıdır. (C.E.) GregorianCalendar öğesini seçin. Sayı, artık saniyeler tarafından eklenecek değer işaretlerini dışlar. Örneğin, 3124137600000000L değer çizgisi, 01 Ocak 0100 Cuma 12:00:00 gece yarısı tarihini temsil eder. Değer DateTime 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ğer çizgisiyle çalışıyorsanız, dönüştürmeyi TimeSpan.TicksPerDaygerçekleştirmek için , TimeSpan.TicksPerHour, TimeSpan.TicksPerMinute, TimeSpan.TicksPerSecondveya TimeSpan.TicksPerMillisecond sabitini kullanmalısınız. Örneğin, bir DateTime değerin bileşenine belirtilen sayıda değer çizgisiyle temsil edilen saniye sayısını eklemek için Second ifadesini dateValue.Second + nTicks/Timespan.TicksPerSecondkullanabilirsiniz.

Tüm örnek kümesinin kaynağını bu makaledeki Visual Basic, F# veya C# ile GitHub'daki docs deposunda görüntüleyebilirsiniz.

Not

Belirli saat dilimlerindeki 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 depolar ve bu DateTime tarih ve saatin özel Int16 alanda UTC'den farklı olduğu dakika sayısını 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'yi ve yerel saat dilimini açıkça yansıtabilir. Tarih ve saat değerleriyle çalışırken yapının veya 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.DateTimeOffset

DateTime nesnesini başlatma

Yeni DateTime bir değere başlangıç değerini birçok farklı yolla atayabilirsiniz:

  • Değerlerin bağımsız değişkenlerini belirttiğiniz bir oluşturucuyu çağırma veya örtük parametresiz oluşturucuyu kullanma.
  • DateTime Bir özelliğin veya yöntemin dönüş değerine atama.
  • Bir DateTime değ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österilir:

Oluşturucuları Çağırma

Tarih ve saat değerinin öğelerini (yıl, ay ve gün veya değer çizgisi sayısı gibi) belirten oluşturucunun aşırı yüklemelerinden DateTime herhangi birini çağırırsınız. Aşağıdaki kod yıl, ay, gün, saat, dakika ve saniyeyi belirten oluşturucuyu kullanarak DateTime 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 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

Parse, ParseExact, TryParseve TryParseExact yöntemlerinin tümü bir dizeyi eşdeğer tarih ve saat değerine dönüştürür. Aşağıdaki örneklerde bir dizeyi Parse ayrıştırmak ve bir değere dönüştürmek için DateTime ve ParseExact yöntemleri kullanılı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 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 çizgisi sayısı (100 nanosaniyelik aralık sayısı) olarak temsil edilir. Gerçek DateTime değer, görüntülendiğinde bu değerin görüntülenme biçiminden bağımsızdır. Değerin DateTime 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 tarih ve saat değerlerinin aşırı yüklemeleriyle ToStringbiçimlendirilirken esneklik sağlar. Varsayılan DateTime.ToString() yöntem, geçerli kültürün kısa tarih ve uzun saat desenini kullanarak bir 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, 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 DateTime.ToString(IFormatProvider) .

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ünün 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, 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 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 kültür tarafından kullanılan ortak tarih ve saat biçimlerinden 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 (Büyük Britanya) 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, "yyyyMMdd" 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 yaygın kullanımlardan ParseExact biri, genellikle ISO 8601 standart biçiminde bir web hizmetinden dize gösterimini 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 giriş olarak kullanılıyorsa 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. Ayrıca, yerel saat isteğe bağlı olarak gün ışığından yararlanma saatinden etkilenir ve bu da bir 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 çıkış noktasında saat dilimi uzaklığı sıfırdır.

UTC saati hesaplamalar, karşılaştırmalar ve tarihlerle saati dosyalarda 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ünürlüğü

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 sistemlerindeki 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, bir 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 örnek, özelliği tarafından döndürülen milisaniye sayısını yalnızca çağrısından DateTime.Now.Milliseconds Thread.Sleepsonra 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

veya Subtractgibi Add bir yapı kullanan hesaplamaDateTime, 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 UTC'yi yerel saate dönüştürebilir ToLocalTime 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 mevcuttur TimeZoneInfo . Bu yöntemleri kullanarak dünyanın herhangi bir saat dilimindeki saati başka bir saat dilimindeki saate dönüştürürsunuz.

Hesaplamalar ve nesnelerin karşılaştırmaları DateTime ancak nesneler aynı saat dilimindeki saatleri temsil ederse anlamlıdır. Bir değerin saat dilimini temsil etmek için bir DateTime nesne kullanabilirsinizTimeZoneInfo, ancak ikisi gevşek bir şekilde birbirine bağlanmış olur. Bir DateTime nesnenin, 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 dilimine duyarlı bir uygulamada, bir DateTime nesnenin oluşturulduğu saat dilimini belirlemek için bazı dış mekanizmalara güvenmeniz gerekir. Değerin saat dilimini DateTime temsil DateTime eden hem değeri hem TimeZoneInfo de 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. Tarihler ve Saatler ile 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 bir ayın gün sayısı gibi ayrıntıları hesaba katar.

DateTime değerleri ve takvimleri

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

Önemli

Japonca takvimlerde dönemler, yağışın temellerini temel almaktadır ve bu nedenle değişmesi beklenir. Örneğin, 1 Mayıs 2019, ve 'de Reiwa döneminin başlangıcını işaret JapaneseCalendar JapaneseLunisolarCalendar etti. Bu tür bir dönem değişikliği, bu takvimleri kullanan tüm uygulamaları etkiler. Daha fazla bilgi için ve uygulamalarınızı etkilendiğini belirlemek için bkz. .NET'te Japonca takviminde yeni bir dönemi işleme. Uygulamalarınızı dönem değişikliğine hazır Windows için uygulamalarınızı farklı sistemlerde test etme hakkında bilgi için bkz. Uygulamalarınızı Japonca dönemi değişikliğine hazırlama. .NET'te birden çok dönem içeren takvimleri destekleyen özellikler ve birden çok dönemi destekleyen takvimlerle çalışırken en iyi yöntemler için bkz. Silmelerle çalışma.

Her kültür, salt CultureInfo.Calendar okunur özelliği tarafından tanımlanan varsayılan takvimi kullanır. Her kültür, salt CultureInfo.OptionalCalendars okunur özelliğiyle 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 Çağı takvimidir. CultureInfo Tarih ve saat biçimlendirme işleminde Tay Budist kültürünü temsil eden bir nesne kullanıldığında, Tay Budist Çağı 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

Parametre içeren bir DateTime oluşturucuyu çağırıp bu takvimi temsil eden bir DateTime nesne geçirerek belirli bir takvimin tarih ve saat öğelerini (yıl, ay ve gün sayısı) kullanarak bir calendar Calendar değerin örneğini oluşturursunuz. Aşağıdaki örnekte takvimdeki tarih ve saat öğeleri ThaiBuddhistCalendar kullanılı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 birimler 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 takvimde 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 ilgili 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 takvimdeki 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 izin veren 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 dört şekilde kalıcı DateTime hale getirmeniz için:

Değerleri geri yükleyen DateTime 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üş yapmalıdır. Yani, özgün değer ve geri yüklenen değer aynı olmalıdır. Özgün DateTime değer tek bir anlık zamanı temsil ederse, geri yüklendiğinde aynı zaman anını tanımlamalıdır.

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 önce değeri Eşgüdümlü Evrensel Saat 'e (UTC) dönüştürün. Ayrıca değeri saat dilimi bilgileriyle birlikte seri hale getirebilirsiniz. Bu yaklaşım hakkında daha fazla bilgi için bkz. DateTime ve saat dilimi verilerini serileştirme.

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ş tarihi kaydeder. Bu örnekte İngilizce (Büyük Britanya) 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...
Public Sub PersistAsLocalStrings()
    SaveDatesAsStrings()
    RestoreDatesAsStrings()
End Sub

Private Sub SaveDatesAsStrings()
    Dim dates As Date() = {#6/14/2014 6:32AM#, #7/10/2014 11:49PM#,
                          #1/10/2015 1:16AM#, #12/20/2014 9:45PM#,
                          #6/2/2014 3:14PM#}
    Dim output As String = Nothing

    Console.WriteLine($"Current Time Zone: {TimeZoneInfo.Local.DisplayName}")
    Console.WriteLine($"The dates on an {Thread.CurrentThread.CurrentCulture.Name} system:")
    For ctr As Integer = 0 To dates.Length - 1
        Console.WriteLine(dates(ctr).ToString("f"))
        output += dates(ctr).ToString() + If(ctr <> dates.Length - 1, "|", "")
    Next
    Dim sw As New StreamWriter(filenameTxt)
    sw.Write(output)
    sw.Close()
    Console.WriteLine("Saved dates...")
End Sub

Private Sub RestoreDatesAsStrings()
    TimeZoneInfo.ClearCachedData()
    Console.WriteLine($"Current Time Zone: {TimeZoneInfo.Local.DisplayName}")
    Thread.CurrentThread.CurrentCulture = CultureInfo.CreateSpecificCulture("en-GB")
    Dim sr As New StreamReader(filenameTxt)
    Dim inputValues As String() = sr.ReadToEnd().Split({"|"c}, StringSplitOptions.RemoveEmptyEntries)
    sr.Close()
    Console.WriteLine($"The dates on an {Thread.CurrentThread.CurrentCulture.Name} system:")
    For Each inputValue In inputValues
        Dim dateValue As Date
        If DateTime.TryParse(inputValue, dateValue) Then
            Console.WriteLine($"'{inputValue}' --> {dateValue:f}")
        Else
            Console.WriteLine($"Cannot parse '{inputValue}'")
        End If
    Next
    Console.WriteLine("Restored dates...")
End Sub
' 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 göndermek için şu adımları izleyin:

  1. Değerler tek bir zaman anını temsil ediyorsa, yöntemini çağırarak bunları yerel saatten UTC'ye dönüştürün ToUniversalTime .
  2. 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 provider biç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:

  1. veya TryParseExact aşırı yüklemesini çağırarak verileri ayrıştırınParseExact. Bağımsız değişken olarak provider belirtin CultureInfo.InvariantCulture ve dönüştürme sırasında bağımsız değişken için kullandığınız standart biçim dizesini format kullanın. Bağımsız değişkene DateTimeStyles.RoundtripKind değerini styles ekleyin.
  2. 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 DateTime 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: {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...
Public Sub PersistAsInvariantStrings()
    SaveDatesAsInvariantStrings()
    RestoreDatesAsInvariantStrings()
End Sub

Private Sub SaveDatesAsInvariantStrings()
    Dim dates As Date() = {#6/14/2014 6:32AM#, #7/10/2014 11:49PM#,
                          #1/10/2015 1:16AM#, #12/20/2014 9:45PM#,
                          #6/2/2014 3:14PM#}
    Dim output As String = Nothing

    Console.WriteLine($"Current Time Zone: {TimeZoneInfo.Local.DisplayName}")
    Console.WriteLine($"The dates on an {Thread.CurrentThread.CurrentCulture.Name} system:")
    For ctr As Integer = 0 To dates.Length - 1
        Console.WriteLine(dates(ctr).ToString("f"))
        output += dates(ctr).ToUniversalTime().ToString("O", CultureInfo.InvariantCulture) +
                                   If(ctr <> dates.Length - 1, "|", "")
    Next
    Dim sw As New StreamWriter(filenameTxt)
    sw.Write(output)
    sw.Close()
    Console.WriteLine("Saved dates...")
End Sub

Private Sub RestoreDatesAsInvariantStrings()
    TimeZoneInfo.ClearCachedData()
    Console.WriteLine("Current Time Zone: {0}",
                    TimeZoneInfo.Local.DisplayName)
    Thread.CurrentThread.CurrentCulture = CultureInfo.CreateSpecificCulture("en-GB")
    Dim sr As New StreamReader(filenameTxt)
    Dim inputValues As String() = sr.ReadToEnd().Split({"|"c}, StringSplitOptions.RemoveEmptyEntries)
    sr.Close()
    Console.WriteLine($"The dates on an {Thread.CurrentThread.CurrentCulture.Name} system:")
    For Each inputValue In inputValues
        Dim dateValue As Date
        If DateTime.TryParseExact(inputValue, "O", CultureInfo.InvariantCulture,
                          DateTimeStyles.RoundtripKind, dateValue) Then
            Console.WriteLine($"'{inputValue}' --> {dateValue.ToLocalTime():f}")
        Else
            Console.WriteLine($"Cannot parse '{inputValue}'")
        End If
    Next
    Console.WriteLine("Restored dates...")
End Sub
' 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 değer değerini temsil eden bir Int64 değer olarak kalıcı hale gelebilirsiniz. Bu durumda, değerlerin kalıcı hale getirilip geri yüklendiği sistemlerin DateTime kültürünü dikkate almanı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 işaretlerinin sayısını alın.

Tamsayı olarak kalıcı hale getirilmiş bir DateTime değeri geri yüklemek için:

  1. Değeri oluşturucuya geçirerek Int64 yeni DateTime bir nesne örneği DateTime(Int64) oluşturma.
  2. 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, ABD Pasifik Saat dilimindeki DateTime bir sistemde bir değer dizisini tamsayılar olarak kalıcı hale gelir. 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...
Public Sub PersistAsIntegers()
    SaveDatesAsIntegers()
    RestoreDatesAsIntegers()
End Sub

Private Sub SaveDatesAsIntegers()
    Dim dates As Date() = {#6/14/2014 6:32AM#, #7/10/2014 11:49PM#,
                          #1/10/2015 1:16AM#, #12/20/2014 9:45PM#,
                          #6/2/2014 3:14PM#}

    Console.WriteLine($"Current Time Zone: {TimeZoneInfo.Local.DisplayName}")
    Console.WriteLine($"The dates on an {Thread.CurrentThread.CurrentCulture.Name} system:")
    Dim ticks(dates.Length - 1) As Long
    For ctr As Integer = 0 To dates.Length - 1
        Console.WriteLine(dates(ctr).ToString("f"))
        ticks(ctr) = dates(ctr).ToUniversalTime().Ticks
    Next
    Dim fs As New FileStream(filenameInts, FileMode.Create)
    Dim bw As New BinaryWriter(fs)
    bw.Write(ticks.Length)
    For Each tick In ticks
        bw.Write(tick)
    Next
    bw.Close()
    Console.WriteLine("Saved dates...")
End Sub

Private Sub RestoreDatesAsIntegers()
    TimeZoneInfo.ClearCachedData()
    Console.WriteLine($"Current Time Zone: {TimeZoneInfo.Local.DisplayName}")
    Thread.CurrentThread.CurrentCulture = CultureInfo.CreateSpecificCulture("en-GB")
    Dim fs As New FileStream(filenameInts, FileMode.Open)
    Dim br As New BinaryReader(fs)
    Dim items As Integer
    Dim dates As DateTime()

    Try
        items = br.ReadInt32()
        ReDim dates(items - 1)

        For ctr As Integer = 0 To items - 1
            Dim ticks As Long = br.ReadInt64()
            dates(ctr) = New DateTime(ticks).ToLocalTime()
        Next
    Catch e As EndOfStreamException
        Console.WriteLine("File corruption detected. Unable to restore data...")
        Exit Sub
    Catch e As IOException
        Console.WriteLine("Unspecified I/O error. Unable to restore data...")
        Exit Sub
    Catch e As OutOfMemoryException     'Thrown in array initialization.
        Console.WriteLine("File corruption detected. Unable to restore data...")
        Exit Sub
    Finally
        br.Close()
    End Try

    Console.WriteLine($"The dates on an {Thread.CurrentThread.CurrentCulture.Name} system:")
    For Each value In dates
        Console.WriteLine(value.ToString("f"))
    Next
    Console.WriteLine("Restored dates...")
End Sub
' 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

Seri hale getirme yoluyla değerleri bir akışa veya dosyaya kalıcı DateTime hale getirebilir ve seri durumdan çıkarma yoluyla geri yükleyebilirsiniz. DateTime veriler belirli bir nesne biçiminde seri hale getirilir. Nesneler seri durumdan çıkarıldığında geri yüklenir. veya BinaryFormattergibi XmlSerializer bir biçimlendirici veya seri hale getirici, serileştirme ve seri durumdan çıkarma işlemini işler. Serileştirme ve .NET Framework 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 çıkarabilmek 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 (Büyük Britanya) olan bir sistemde çalıştırılırsa sonucu temsil eder. Nesnenin kendisini seri durumdan DateTime çıkardığınız için 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;
    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
Public Sub PersistAsXml()
    ' Serialize the data.
    Dim leapYears As New List(Of DateTime)()
    For year As Integer = 2000 To 2100 Step 4
        If Date.IsLeapYear(year) Then
            leapYears.Add(New Date(year, 2, 29))
        End If
    Next
    Dim dateArray As DateTime() = leapYears.ToArray()

    Dim serializer As New XmlSerializer(dateArray.GetType())
    Dim sw As TextWriter = New StreamWriter(filenameXml)

    Try
        serializer.Serialize(sw, dateArray)
    Catch e As InvalidOperationException
        Console.WriteLine(e.InnerException.Message)
    Finally
        If sw IsNot Nothing Then sw.Close()
    End Try

    ' Deserialize the data.
    Dim deserializedDates As Date()
    Using fs As New FileStream(filenameXml, FileMode.Open)
        deserializedDates = CType(serializer.Deserialize(fs), Date())
    End Using

    ' Display the dates.
    Console.WriteLine($"Leap year days from 2000-2100 on an {Thread.CurrentThread.CurrentCulture.Name} system:")
    Dim nItems As Integer
    For Each dat In deserializedDates
        Console.Write($"   {dat:d}     ")
        nItems += 1
        If nItems Mod 5 = 0 Then Console.WriteLine()
    Next
End Sub
' 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 bilgisi yoktur. Bir DateTime değer 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 . Aşağıdaki örnek, ABD Pasifik Standart Saat dilimindeki bir sistemdeki verileri seri hale DateTime getirmek ve ABD Orta Standart bölgesindeki bir sistemde seri durumdan çıkartmak için sınıfını kullanırBinaryFormatter.

public static void PersistBinary()
{
    SaveDatesBinary();
    RestoreDatesBinary();
}

private static void SaveDatesBinary()
{
    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) };
    var fs = new FileStream(filenameBin, FileMode.Create);
    var bin = new BinaryFormatter();

    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"));
        dates[ctr] = dates[ctr].ToUniversalTime();
    }
    bin.Serialize(fs, dates);
    fs.Close();
    Console.WriteLine("Saved dates...");
}

private static void RestoreDatesBinary()
{
    TimeZoneInfo.ClearCachedData();
    Console.WriteLine($"Current Time Zone: {TimeZoneInfo.Local.DisplayName}");
    Thread.CurrentThread.CurrentCulture = CultureInfo.CreateSpecificCulture("en-GB");

    FileStream fs = new FileStream(filenameBin, FileMode.Open);
    BinaryFormatter bin = new BinaryFormatter();
    var dates = (DateTime[])bin.Deserialize(fs);
    fs.Close();

    Console.WriteLine($"The dates on an {Thread.CurrentThread.CurrentCulture.Name} system:");
    foreach (var value in dates)
        Console.WriteLine(value.ToLocalTime().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-6:00) Central Time (US & Canada)
//       The dates on an en-GB system:
//       14 June 2014 08:32
//       11 July 2014 01:49
//       10 January 2015 03:16
//       20 December 2014 23:45
//       02 June 2014 17:14
//       Restored dates...
// BinaryFormatter serialization is obsolete and should not be used. See https://aka.ms/binaryformatter for more information.

let saveDatesBinary () =
    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) |]
        |> Array.map (fun date -> 
            printfn $"{date:f}"
            date.ToUniversalTime() )

    use fs = new FileStream(filenameBin, FileMode.Create)
    let bin = BinaryFormatter()

    printfn $"Current Time Zone: {TimeZoneInfo.Local.DisplayName}"
    printfn $"The dates on an {Thread.CurrentThread.CurrentCulture.Name} system:"
    
    bin.Serialize(fs, dates)
    printfn "Saved dates..."

let restoreDatesBinary () =
    TimeZoneInfo.ClearCachedData()
    printfn $"Current Time Zone: {TimeZoneInfo.Local.DisplayName}"
    Thread.CurrentThread.CurrentCulture <- CultureInfo.CreateSpecificCulture "en-GB"

    use fs = new FileStream(filenameBin, FileMode.Open)
    let bin = BinaryFormatter()
    let dates = bin.Deserialize fs :?> DateTime []

    printfn $"The dates on an {Thread.CurrentThread.CurrentCulture.Name} system:"
    for value in dates do
        printfn $"{value.ToLocalTime():f}"

    printfn "Restored dates..."

let persistBinary () =
    saveDatesBinary ()
    restoreDatesBinary ()

// 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-6:00) Central Time (US & Canada)
//       The dates on an en-GB system:
//       14 June 2014 08:32
//       11 July 2014 01:49
//       10 January 2015 03:16
//       20 December 2014 23:45
//       02 June 2014 17:14
//       Restored dates...
Public Sub PersistBinary()
    SaveDatesBinary()
    RestoreDatesBinary()
End Sub

Private Sub SaveDatesBinary()
    Dim dates As Date() = {#6/14/2014 6:32AM#, #7/10/2014 11:49PM#,
                          #1/10/2015 1:16AM#, #12/20/2014 9:45PM#,
                          #6/2/2014 3:14PM#}
    Dim fs As New FileStream(filenameBin, FileMode.Create)
    Dim bin As New BinaryFormatter()

    Console.WriteLine($"Current Time Zone: {TimeZoneInfo.Local.DisplayName}")
    Console.WriteLine("The dates on an {Thread.CurrentThread.CurrentCulture.Name} system:")
    For ctr As Integer = 0 To dates.Length - 1
        Console.WriteLine(dates(ctr).ToString("f"))
        dates(ctr) = dates(ctr).ToUniversalTime()
    Next
    bin.Serialize(fs, dates)
    fs.Close()
    Console.WriteLine("Saved dates...")
End Sub

Private Sub RestoreDatesBinary()
    TimeZoneInfo.ClearCachedData()
    Console.WriteLine("Current Time Zone: {TimeZoneInfo.Local.DisplayName}")
    Thread.CurrentThread.CurrentCulture = CultureInfo.CreateSpecificCulture("en-GB")

    Dim fs As New FileStream(filenameBin, FileMode.Open)
    Dim bin As New BinaryFormatter()
    Dim dates As DateTime() = DirectCast(bin.Deserialize(fs), Date())
    fs.Close()

    Console.WriteLine("The dates on an {Thread.CurrentThread.CurrentCulture.Name} system:")
    For Each value In dates
        Console.WriteLine(value.ToLocalTime().ToString("f"))
    Next
    Console.WriteLine("Restored dates...")
End Sub
' 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-6:00) Central Time (US & Canada)
'       The dates on an en-GB system:
'       14 June 2014 08:32
'       11 July 2014 01:49
'       10 January 2015 03:16
'       20 December 2014 11:45
'       02 June 2014 17:14
'       Restored dates...

DateTime ve saat dilimi verilerini seri hale getirme

Önceki örneklerin tümü değerlerin DateTime yerel saat olarak ifade edildiği varsayılmıştır. Kod değerleri UTC ile yerel saat arasında dönüştürerek kaynak ve hedef sistemlerde aynı anı yansıtmasını sağlar. DateTime değerleri, yerel ve UTC dışında bir saat diliminde saat içindeki anları da yansıtabilir. Yapı saat dilimine DateTime duyarlı olmadığından, hem değeri TimeZoneInfo hem de DateTime saat dilimini temsil eden nesneyi seri hale getirmeniz gerekir. Alanları hem değeri hem de DateTime saat dilimini içeren bir tür oluşturun. Aşağıdaki örnek bir DateWithTimeZone yapı tanımlar.

using System;

namespace DateTimeExtensions
{
    [Serializable]
    public struct DateWithTimeZone
    {
        private TimeZoneInfo tz;
        private DateTime dt;

        public DateWithTimeZone(DateTime dateValue, TimeZoneInfo timeZone)
        {
            dt = dateValue;
            tz = timeZone ?? TimeZoneInfo.Local;
        }

        public TimeZoneInfo TimeZone
        {
            get { return (tz); }
            set { tz = value; }
        }

        public DateTime DateTime
        {
            get { return (dt); }
            set { dt = value; }
        }
    }
}
namespace DateTimeExtensions

open System

[<Serializable>]
type DateWithTimeZone =
    struct
        val TimeZone: TimeZoneInfo
        val DateTime: DateTime
        new (dateValue, timeZone) = 
            { DateTime = dateValue; 
              TimeZone = 
                if isNull timeZone then TimeZoneInfo.Local
                else timeZone }
    end
Namespace DateTimeExtensions
    <Serializable> Public Structure DateWithTimeZone
        Private tz As TimeZoneInfo
        Private dt As DateTime

        Public Sub New(dateValue As DateTime, timeZone As TimeZoneInfo)
            dt = dateValue
            tz = If(timeZone, TimeZoneInfo.Local)
        End Sub

        Public Property TimeZone As TimeZoneInfo
            Get
                Return tz
            End Get
            Set
                tz = Value
            End Set
        End Property

        Public Property DateTime As Date
            Get
                Return dt
            End Get
            Set
                dt = Value
            End Set
        End Property
    End Structure
End Namespace

Önemli

Yapı DateWithTimeZone , bir nesne dizisini DateWithTimeZone seri hale getirip seri durumdan çıkaran sonraki iki örnekte kullanılır. Tüm örnek kümesinin kaynağını bu makaledeki Visual Basic, F# veya C# ile GitHub'daki docs deposunda görüntüleyebilirsiniz.

Bu yapıyı DateWithTimeZone kullanarak, saat dilimi bilgileriyle birlikte tarih ve saati kalıcı hale getirirsiniz. Aşağıdaki örnek, bir nesne dizisini BinaryFormatter serileştirmek için sınıfını DateWithTimeZone kullanır.

public static void SaveDateWithTimeZone()
{
    DateWithTimeZone[] dates = { new DateWithTimeZone(new DateTime(2014, 8, 9, 19, 30, 0),
                              TimeZoneInfo.FindSystemTimeZoneById("Eastern Standard Time")),
                          new DateWithTimeZone(new DateTime(2014, 8, 15, 19, 0, 0),
                              TimeZoneInfo.FindSystemTimeZoneById("Pacific Standard Time")),
                          new DateWithTimeZone(new DateTime(2014, 8, 22, 19, 30, 0),
                              TimeZoneInfo.FindSystemTimeZoneById("Eastern Standard Time")),
                          new DateWithTimeZone(new DateTime(2014, 8, 28, 19, 0, 0),
                              TimeZoneInfo.FindSystemTimeZoneById("Eastern Standard Time")) };
    var fs = new FileStream(@".\Schedule.bin", FileMode.Create);
    var formatter = new BinaryFormatter();
    try
    {
        formatter.Serialize(fs, dates);
        // Display dates.
        foreach (var date in dates)
        {
            TimeZoneInfo tz = date.TimeZone;
            Console.WriteLine($"{date.DateTime} {(tz.IsDaylightSavingTime(date.DateTime) ? tz.DaylightName : tz.StandardName)}");
        }
    }
    catch (SerializationException e)
    {
        Console.WriteLine($"Serialization failed. Reason: {e.Message}");
    }
    finally
    {
        if (fs != null) fs.Close();
    }
}
// The example displays the following output:
//       8/9/2014 7:30:00 PM Eastern Daylight Time
//       8/15/2014 7:00:00 PM Pacific Daylight Time
//       8/22/2014 7:30:00 PM Eastern Daylight Time
//       8/28/2014 7:00:00 PM Eastern Daylight Time
// BinaryFormatter serialization is obsolete and should not be used. See https://aka.ms/binaryformatter for more information.

let saveDateWithTimeZone () =
    let dates = 
        [| DateWithTimeZone(DateTime(2014, 8, 9, 19, 30, 0),
                                TimeZoneInfo.FindSystemTimeZoneById "Eastern Standard Time")
           DateWithTimeZone(DateTime(2014, 8, 15, 19, 0, 0),
                                TimeZoneInfo.FindSystemTimeZoneById "Pacific Standard Time")
           DateWithTimeZone(DateTime(2014, 8, 22, 19, 30, 0),
                                TimeZoneInfo.FindSystemTimeZoneById "Eastern Standard Time")
           DateWithTimeZone(DateTime(2014, 8, 28, 19, 0, 0),
                                TimeZoneInfo.FindSystemTimeZoneById "Eastern Standard Time") |]

    use fs = new FileStream(@".\Schedule.bin", FileMode.Create)
    let formatter = BinaryFormatter()
    try
        formatter.Serialize(fs, dates)
        // Display dates.
        for date in dates do
            let tz = date.TimeZone
            printfn $"{date.DateTime} {if tz.IsDaylightSavingTime date.DateTime then tz.DaylightName else tz.StandardName}"
    with :? SerializationException as e ->
        printfn $"Serialization failed. Reason: {e.Message}"

// The example displays the following output:
//       8/9/2014 7:30:00 PM Eastern Daylight Time
//       8/15/2014 7:00:00 PM Pacific Daylight Time
//       8/22/2014 7:30:00 PM Eastern Daylight Time
//       8/28/2014 7:00:00 PM Eastern Daylight Time
Public Sub SaveDateWithTimeZone()
    Dim dates As DateWithTimeZone() = {New DateWithTimeZone(#8/9/2014 7:30PM#,
                                      TimeZoneInfo.FindSystemTimeZoneById("Eastern Standard Time")),
                                  New DateWithTimeZone(#8/15/2014 7:00PM#,
                                      TimeZoneInfo.FindSystemTimeZoneById("Pacific Standard Time")),
                                  New DateWithTimeZone(#8/22/2014 7:30PM#,
                                      TimeZoneInfo.FindSystemTimeZoneById("Eastern Standard Time")),
                                  New DateWithTimeZone(#8/28/2014 7:00PM#,
                                      TimeZoneInfo.FindSystemTimeZoneById("Eastern Standard Time"))}
    Dim fs As New FileStream(".\Schedule.bin", FileMode.Create)
    Dim formatter As New BinaryFormatter()
    Try
        formatter.Serialize(fs, dates)
    Catch e As SerializationException
        Console.WriteLine($"Serialization failed. Reason: {e.Message}")
    Finally
        If fs IsNot Nothing Then fs.Close()
    End Try
    ' Display dates.
    For Each dateInfo In dates
        Dim tz As TimeZoneInfo = dateInfo.TimeZone
        Console.WriteLine($"{dateInfo.DateTime} {If(tz.IsDaylightSavingTime(dateInfo.DateTime), tz.DaylightName, tz.StandardName)}")
    Next
End Sub
' The example displays the following output:
'       8/9/2014 7:30:00 PM Eastern Daylight Time
'       8/15/2014 7:00:00 PM Pacific Daylight Time
'       8/22/2014 7:30:00 PM Eastern Daylight Time
'       8/28/2014 7:00:00 PM Eastern Daylight Time

Aşağıdaki örnek daha sonra seri durumdan BinaryFormatter.Deserialize çıkarma yöntemini çağırır.

public static void RestoreDateWithTimeZone()
{
    const string filename = @".\Schedule.bin";
    FileStream fs;
    if (File.Exists(filename))
    {
        fs = new FileStream(filename, FileMode.Open);
    }
    else
    {
        Console.WriteLine("Unable to find file to deserialize.");
        return;
    }

    var formatter = new BinaryFormatter();
    DateWithTimeZone[] dates;
    try
    {
        dates = (DateWithTimeZone[])formatter.Deserialize(fs);
        // Display dates.
        foreach (var date in dates)
        {
            TimeZoneInfo tz = date.TimeZone;
            Console.WriteLine($"{ date.DateTime} {(tz.IsDaylightSavingTime(date.DateTime) ? tz.DaylightName : tz.StandardName)}");
        }
    }
    catch (SerializationException e)
    {
        Console.WriteLine($"Deserialization failed. Reason: {e.Message}");
    }
    finally
    {
        if (fs != null) fs.Close();
    }
}
// The example displays the following output:
//       8/9/2014 7:30:00 PM Eastern Daylight Time
//       8/15/2014 7:00:00 PM Pacific Daylight Time
//       8/22/2014 7:30:00 PM Eastern Daylight Time
//       8/28/2014 7:00:00 PM Eastern Daylight Time
let restoreDateWithTimeZone () =
    let filename = @".\Schedule.bin"
    if File.Exists filename then
        use fs = new FileStream(filename, FileMode.Open)

        let formatter = BinaryFormatter()
        try
            let dates = formatter.Deserialize fs :?> DateWithTimeZone []
            // Display dates.
            for date in dates do
                let tz = date.TimeZone
                printfn $"{date.DateTime} {if tz.IsDaylightSavingTime date.DateTime then tz.DaylightName else tz.StandardName}"
        with :? SerializationException as e ->
            printfn $"Deserialization failed. Reason: {e.Message}"
    else
        printfn "Unable to find file to deserialize."

// The example displays the following output:
//       8/9/2014 7:30:00 PM Eastern Daylight Time
//       8/15/2014 7:00:00 PM Pacific Daylight Time
//       8/22/2014 7:30:00 PM Eastern Daylight Time
//       8/28/2014 7:00:00 PM Eastern Daylight Time
Public Sub RestoreDateWithTimeZone()
    Dim fs As FileStream
    If File.Exists(filename) Then
        fs = New FileStream(filename, FileMode.Open)
    Else
        Console.WriteLine("Unable to find file to deserialize.")
        Exit Sub
    End If

    Dim formatter As New BinaryFormatter()
    Dim dates As DateWithTimeZone ()= Nothing
    Try
        dates = DirectCast(formatter.Deserialize(fs), DateWithTimeZone())
        ' Display dates.
        For Each dateInfo In dates
            Dim tz As TimeZoneInfo = dateInfo.TimeZone
            Console.WriteLine($"{dateInfo.DateTime} {If(tz.IsDaylightSavingTime(dateInfo.DateTime), tz.DaylightName, tz.StandardName)}")
        Next
    Catch e As SerializationException
        Console.WriteLine("Deserialization failed. Reason: {e.Message}")
    Finally
        If fs IsNot Nothing Then fs.Close()
    End Try
End Sub
' The example displays the following output:
'       8/9/2014 7:30:00 PM Eastern Daylight Time
'       8/15/2014 7:00:00 PM Pacific Daylight Time
'       8/22/2014 7:30:00 PM Eastern Daylight Time
'       8/28/2014 7:00:00 PM Eastern Daylight Time

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

DateTime ve TimeSpan değer türleri, bir DateTime zaman aralığını temsil eden bir anlık değeri temsil ederTimeSpan. 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 nesneden DateTime zaman aralığı ekleyebilir veya çıkarabilirsiniz. Zaman aralıkları negatif veya pozitif olabilir ve bunlar keneler, saniyeler veya bir TimeSpan nesne olarak ifade edilebilir.

Tolerans içinde eşitlik karşılaştırması

Değerler için DateTime eşitlik karşılaştırmaları tamdır. Bu, iki değerin eşit olarak kabul edilmesi için aynı sayıda kene olarak ifade edilmesi gerektiği anlamına gelir. 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 örnek kabaca eşdeğer DateTime değerlerin nasıl karşılaştırılacağını göstermektedir. 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 COM uygulamasına aktarılan ve ardından yönetilen bir uygulamaya geri aktarılan değerin gidiş dönüş olduğu söylenir. Ancak, yalnızca bir saati 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 30 Aralık 1899 C.E'dir. Saat 15:00'te, 1 Ocak 0001 C.E. yerine saat 15:00'te .NET Framework ve COM, yalnızca bir saat belirtildiğinde varsayılan bir tarih olduğunu varsayar. Ancak COM sistemi 30 Aralık 1899 C.E. temel tarihini, .NET Framework ise 1 Ocak 0001 C.E. temel tarihini varsayar.

.NET Framework COM'a yalnızca bir zaman geçirildiğinde, saati COM tarafından kullanılan biçime dönüştüren özel işleme gerçekleştirilir. COM'dan .NET Framework 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 Framework ve COM tarihi korur.

.NET Framework 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 yoksaymayı hatırlaması gerektiği anlamına gelir.

Oluşturucular

DateTime(Int32, Int32, Int32)

Belirtilen yıl, ay ve gün için yapının yeni bir örneğini DateTime başlatır.

DateTime(Int32, Int32, Int32, Calendar)

Belirtilen takvim için belirtilen yıl, ay ve gün için yapının yeni bir örneğini DateTime başlatır.

DateTime(Int32, Int32, Int32, Int32, Int32, Int32)

Belirtilen yıl, ay, gün, saat, dakika ve saniye için yapının yeni bir örneğini DateTime başlatır.

DateTime(Int32, Int32, Int32, Int32, Int32, Int32, Calendar)

Belirtilen takvim için belirtilen yıl, ay, gün, saat, dakika ve saniye için yapının yeni bir örneğini DateTime başlatır.

DateTime(Int32, Int32, Int32, Int32, Int32, Int32, DateTimeKind)

Belirtilen yıl, ay, gün, saat, dakika, saniye ve Eşgüdümlü Evrensel Saat (UTC) veya yerel saat için yapının yeni bir örneğini DateTime başlatır.

DateTime(Int32, Int32, Int32, Int32, Int32, Int32, Int32)

Belirtilen yıl, ay, gün, saat, dakika, saniye ve milisaniye için yeni bir yapı örneği DateTime başlatır.

DateTime(Int32, Int32, Int32, Int32, Int32, Int32, Int32, Calendar)

Belirtilen takvim için belirtilen yıl, ay, gün, saat, dakika, saniye ve milisaniye için yapının yeni bir örneğini DateTime başlatır.

DateTime(Int32, Int32, Int32, Int32, Int32, Int32, Int32, Calendar, DateTimeKind)

Belirtilen takvim için belirtilen yıl, ay, gün, saat, dakika, saniye, milisaniye ve Eşgüdümlü Evrensel Saat (UTC) veya yerel saat için yapının yeni bir örneğini DateTime başlatır.

DateTime(Int32, Int32, Int32, Int32, Int32, Int32, Int32, DateTimeKind)

Belirtilen yıl, ay, gün, saat, dakika, saniye, milisaniye ve Eşgüdümlü Evrensel Saat (UTC) veya yerel saat için yapının yeni bir örneğini DateTime başlatır.

DateTime(Int32, Int32, Int32, Int32, Int32, Int32, Int32, Int32)

Belirtilen takvim için belirtilen yıl, ay, gün, saat, dakika, saniye, milisaniye ve Eşgüdümlü Evrensel Saat (UTC) veya yerel saat için yapının yeni bir örneğini DateTime başlatır.

DateTime(Int32, Int32, Int32, Int32, Int32, Int32, Int32, Int32, Calendar)

Belirtilen takvim için belirtilen yıl, ay, gün, saat, dakika, saniye, milisaniye ve Eşgüdümlü Evrensel Saat (UTC) veya yerel saat için yapının yeni bir örneğini DateTime başlatır.

DateTime(Int32, Int32, Int32, Int32, Int32, Int32, Int32, Int32, Calendar, DateTimeKind)

Belirtilen takvim için belirtilen yıl, ay, gün, saat, dakika, saniye, milisaniye ve Eşgüdümlü Evrensel Saat (UTC) veya yerel saat için yapının yeni bir örneğini DateTime başlatır.

DateTime(Int32, Int32, Int32, Int32, Int32, Int32, Int32, Int32, DateTimeKind)

Belirtilen takvim için belirtilen yıl, ay, gün, saat, dakika, saniye, milisaniye ve Eşgüdümlü Evrensel Saat (UTC) veya yerel saat için yapının yeni bir örneğini DateTime başlatır.

DateTime(Int64)

Belirtilen sayıda değer çizgisi için yapının yeni bir örneğini DateTime başlatır.

DateTime(Int64, DateTimeKind)

Yapının yeni bir örneğini DateTime belirtilen sayıda değer çizgisine ve Eşgüdümlü Evrensel Saat (UTC) veya yerel saate başlatır.

Alanlar

MaxValue

mümkün olan en büyük değerini DateTimetemsil eder. Bu alan salt okunur durumdadır.

MinValue

mümkün olan en küçük değerini DateTimetemsil eder. Bu alan salt okunur durumdadır.

UnixEpoch

Bu sabitin değeri Gregoryen takvimde 00:00:00.0000000 UTC, 1 Ocak 1970'e eşdeğerdir. UnixEpoch Unix saatinin 0'a eşit olduğu noktayı tanımlar.

Özellikler

Date

Bu örneğin tarih bileşenini alır.

Day

Bu örnekle gösterilen ayın gününü alır.

DayOfWeek

Bu örnekle temsil edilen haftanın gününü alır.

DayOfYear

Bu örnek tarafından temsil edilen yılın gününü alır.

Hour

Bu örnek tarafından temsil edilen tarihin saat bileşenini alır.

Kind

Bu örnek tarafından temsil edilen saatin yerel saat, Eşgüdümlü Evrensel Saat (UTC) veya hiçbirini temel aldığını belirten bir değer alır.

Microsecond

0 ile 999 arasında bir değer olarak ifade edilen mikrosaniye bileşeni.

Millisecond

Bu örnek tarafından temsil edilen tarihin milisaniye bileşenini alır.

Minute

Bu örnek tarafından temsil edilen tarihin dakika bileşenini alır.

Month

Bu örnek tarafından temsil edilen tarihin ay bileşenini alır.

Nanosecond

0 ile 900 arasında bir değer olarak ifade edilen nanosaniye bileşeni (100 nanosaniyelik artışlarla).

Now

Yerel saat olarak ifade edilen, bu bilgisayardaki geçerli tarih ve saate ayarlanmış bir DateTime nesneyi alır.

Second

Bu örnek tarafından temsil edilen tarihin saniye bileşenini alır.

Ticks

Bu örneğin tarihini ve saatini temsil eden değer işaretlerinin sayısını alır.

TimeOfDay

Bu örnek için günün saatini alır.

Today

Geçerli tarihi alır.

UtcNow

Eşgüdümlü Evrensel Saat (UTC) olarak ifade edilen, bu bilgisayardaki geçerli tarih ve saate ayarlanmış bir DateTime nesneyi alır.

Year

Bu örnek tarafından temsil edilen tarihin yıl bileşenini alır.

Yöntemler

Add(TimeSpan)

Belirtilen TimeSpan değerini bu örneğin değerine ekleyen yeni DateTime bir döndürür.

AddDays(Double)

Bu örneğin değerine belirtilen gün sayısını ekleyen yeni DateTime bir döndürür.

AddHours(Double)

Bu örneğin değerine belirtilen saat sayısını ekleyen yeni DateTime bir döndürür.

AddMicroseconds(Double)

Bu örneğin değerine belirtilen sayıda mikrosaniye ekleyen yeni DateTime bir döndürür.

AddMilliseconds(Double)

Bu örneğin değerine belirtilen sayıda milisaniye ekleyen yeni DateTime bir değer döndürür.

AddMinutes(Double)

Bu örneğin değerine belirtilen dakika sayısını ekleyen yeni DateTime bir döndürür.

AddMonths(Int32)

Bu örneğin değerine belirtilen sayıda ay ekleyen yeni DateTime bir döndürür.

AddSeconds(Double)

Bu örneğin değerine belirtilen saniye sayısını ekleyen yeni DateTime bir döndürür.

AddTicks(Int64)

Bu örneğin değerine belirtilen sayıda değer ekleyen yeni DateTime bir değer döndürür.

AddYears(Int32)

Belirtilen yıl sayısını bu örneğin değerine ekleyen yeni DateTime bir değer döndürür.

Compare(DateTime, DateTime)

öğesinin DateTime iki örneğini karşılaştırır ve ilk örneğin ikinci örnekten önceki, aynı veya daha sonraki bir örnek olup olmadığını belirten bir tamsayı döndürür.

CompareTo(DateTime)

Bu örneğin değerini belirtilen bir değerle karşılaştırır ve bu örneğin belirtilen DateTime DateTime değerden önce mi, ile aynı mı yoksa daha sonra mı olduğunu belirten bir tamsayı döndürür.

CompareTo(Object)

Bu örneğin değerini, belirtilen değeri içeren belirtilen bir nesneyle karşılaştırır ve bu örneğin belirtilen DateTime değerden önce mi, ile aynı mı yoksa daha DateTime geç mi olduğunu belirten bir tamsayı döndürür.

DaysInMonth(Int32, Int32)

Belirtilen ay ve yıl içindeki gün sayısını döndürür.

Equals(DateTime)

Bu örneğin değerinin belirtilen DateTime örneğin değerine eşit olup olmadığını belirten bir değer döndürür.

Equals(DateTime, DateTime)

İki DateTime örneğin aynı tarih ve saat değerine sahip olup olmadığını gösteren bir değer döndürür.

Equals(Object)

Bu örneğin, belirtilen bir nesneye eşit olup olmadığını gösteren bir değeri döndürür.

FromBinary(Int64)

64 bitlik ikili değeri seri durumdan çıkararak özgün bir serileştirilmiş DateTime nesneyi yeniden oluşturur.

FromFileTime(Int64)

Belirtilen Windows dosya süresini eşdeğer bir yerel saate dönüştürür.

FromFileTimeUtc(Int64)

Belirtilen Windows dosya süresini eşdeğer bir UTC saatine dönüştürür.

FromOADate(Double)

Belirtilen OLE Otomasyon Tarihi'ne eşdeğer bir DateTime değer döndürür.

GetDateTimeFormats()

Bu örneğin değerini standart tarih ve saat biçimi tanımlayıcıları tarafından desteklenen tüm dize gösterimlerine dönüştürür.

GetDateTimeFormats(Char)

Bu örneğin değerini belirtilen standart tarih ve saat biçimi tanımlayıcısı tarafından desteklenen tüm dize gösterimlerine dönüştürür.

GetDateTimeFormats(Char, IFormatProvider)

Bu örneğin değerini, belirtilen standart tarih ve saat biçimi tanımlayıcısı ve kültüre özgü biçimlendirme bilgileri tarafından desteklenen tüm dize gösterimlerine dönüştürür.

GetDateTimeFormats(IFormatProvider)

Bu örneğin değerini, standart tarih ve saat biçimi tanımlayıcıları ve belirtilen kültüre özgü biçimlendirme bilgileri tarafından desteklenen tüm dize gösterimlerine dönüştürür.

GetHashCode()

Bu örneğe ilişkin karma kodu döndürür.

GetTypeCode()

değer türü DateTimeiçin değerini TypeCode döndürür.

IsDaylightSavingTime()

Bu örneğinin DateTime geçerli saat dilimi için gün ışığından yararlanma zaman aralığı içinde olup olmadığını gösterir.

IsLeapYear(Int32)

Belirtilen yılın artık yıl olup olmadığını gösteren bir gösterge döndürür.

Parse(ReadOnlySpan<Char>, IFormatProvider)

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

Parse(ReadOnlySpan<Char>, IFormatProvider, DateTimeStyles)

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

Parse(String)

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

Parse(String, IFormatProvider)

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

Parse(String, IFormatProvider, DateTimeStyles)

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

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

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

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

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

ParseExact(String, String, IFormatProvider)

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

ParseExact(String, String, IFormatProvider, DateTimeStyles)

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

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

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

SpecifyKind(DateTime, DateTimeKind)

Belirtilen ile aynı sayıda değer çizgisine sahip olan ancak belirtilen DateTimedeğerle DateTimeKind belirtildiği gibi yerel saat, Eşgüdümlü Evrensel Saat (UTC) veya hiçbiri olarak belirlenen yeni DateTime bir nesne oluşturur.

Subtract(DateTime)

Belirtilen tarih ve saati bu örneğin değerinden çıkaran yeni TimeSpan bir döndürür.

Subtract(TimeSpan)

Belirtilen süreyi bu örneğin değerinden çıkaran yeni DateTime bir döndürür.

ToBinary()

Geçerli DateTime nesneyi daha sonra nesneyi yeniden oluşturmak için kullanılabilecek 64 bitlik ikili değere DateTime serileştirir.

ToFileTime()

Geçerli DateTime nesnenin değerini Windows dosya zamanına dönüştürür.

ToFileTimeUtc()

Geçerli DateTime nesnenin değerini Windows dosya zamanına dönüştürür.

ToLocalTime()

Geçerli DateTime nesnenin değerini yerel saate dönüştürür.

ToLongDateString()

Geçerli DateTime nesnenin değerini eşdeğer uzun tarih dizesi gösterimine dönüştürür.

ToLongTimeString()

Geçerli DateTime nesnenin değerini eşdeğer uzun süreli dize gösterimine dönüştürür.

ToOADate()

Bu örneğin değerini eşdeğer OLE Otomasyonu tarihine dönüştürür.

ToShortDateString()

Geçerli DateTime nesnenin değerini eşdeğer kısa tarih dizesi gösterimine dönüştürür.

ToShortTimeString()

Geçerli DateTime nesnenin değerini eşdeğer kısa zaman dizesi gösterimine dönüştürür.

ToString()

Geçerli kültürün biçimlendirme kurallarını kullanarak geçerli DateTime nesnenin değerini eşdeğer dize gösterimine dönüştürür.

ToString(IFormatProvider)

Belirtilen kültüre özgü biçim bilgilerini kullanarak geçerli DateTime nesnenin değerini eşdeğer dize gösterimine dönüştürür.

ToString(String)

Geçerli nesnenin değerini, belirtilen biçimi ve geçerli DateTime kültürün biçimlendirme kurallarını kullanarak eşdeğer dize gösterimine dönüştürür.

ToString(String, IFormatProvider)

Belirtilen biçim ve kültüre özgü biçim bilgilerini kullanarak geçerli DateTime nesnenin değerini eşdeğer dize gösterimine dönüştürür.

ToUniversalTime()

Geçerli DateTime nesnenin değerini Eşgüdümlü Evrensel Saat'e (UTC) dönüştürür.

TryFormat(Span<Char>, Int32, ReadOnlySpan<Char>, IFormatProvider)

Geçerli datetime örneğinin değerini sağlanan karakter aralığına biçimlendirmeye çalışır.

TryParse(ReadOnlySpan<Char>, DateTime)

Tarih ve saatin belirtilen karakter aralığını eşdeğerine DateTime dönüştürür ve dönüştürmenin başarılı olup olmadığını belirten bir değer döndürür.

TryParse(ReadOnlySpan<Char>, IFormatProvider, DateTime)

Bir karakter aralığını bir değere ayrıştırmaya çalışır.

TryParse(ReadOnlySpan<Char>, IFormatProvider, DateTimeStyles, DateTime)

Belirtilen kültüre özgü biçim bilgilerini ve biçimlendirme stilini kullanarak tarih ve saatin span gösterimini eşdeğerine DateTime dönüştürür ve dönüştürmenin başarılı olup olmadığını belirten bir değer döndürür.

TryParse(String, DateTime)

Bir tarih ve saatin belirtilen dize gösterimini eşdeğerine DateTime dönüştürür ve dönüştürmenin başarılı olup olmadığını belirten bir değer döndürür.

TryParse(String, IFormatProvider, DateTime)

Bir dizeyi bir değere ayrıştırmaya çalışır.

TryParse(String, IFormatProvider, DateTimeStyles, DateTime)

Tarih ve saatin belirtilen dize gösterimini, belirtilen kültüre özgü biçim bilgilerini ve biçimlendirme stilini kullanarak eşdeğerine DateTime dönüştürür ve dönüştürmenin başarılı olup olmadığını gösteren bir değer döndürür.

TryParseExact(ReadOnlySpan<Char>, ReadOnlySpan<Char>, IFormatProvider, DateTimeStyles, DateTime)

Belirtilen biçimi, kültüre özgü biçim bilgilerini ve stili kullanarak bir tarih ve saatin belirtilen span gösterimini eşdeğerine DateTime dönüştürür. Dize gösteriminin biçimi belirtilen biçimle tam olarak eşleşmelidir. Yöntem, dönüştürmenin başarılı olup olmadığını gösteren bir değeri döndürür.

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

Tarih ve saatin belirtilen karakter aralığını eşdeğerine DateTime dönüştürür ve dönüştürmenin başarılı olup olmadığını gösteren bir değer döndürür.

TryParseExact(String, String, IFormatProvider, DateTimeStyles, DateTime)

Belirtilen biçimi, kültüre özgü biçim bilgilerini ve stili kullanarak bir tarih ve saatin belirtilen dize gösterimini eşdeğerine DateTime dönüştürür. Dize gösteriminin biçimi belirtilen biçimle tam olarak eşleşmelidir. Yöntem, dönüştürmenin başarılı olup olmadığını gösteren bir değeri döndürür.

TryParseExact(String, String[], IFormatProvider, DateTimeStyles, DateTime)

Belirtilen biçim dizisini, kültüre özgü biçim bilgilerini ve stili kullanarak bir tarih ve saatin belirtilen dize gösterimini DateTime eşdeğerine dönüştürür. Dize gösteriminin biçimi, belirtilen biçimlerden en az biriyle tam olarak eşleşmelidir. Yöntem, dönüştürmenin başarılı olup olmadığını gösteren bir değeri döndürür.

İşleçler

Addition(DateTime, TimeSpan)

Belirtilen tarih ve saate belirtilen zaman aralığını ekler ve yeni bir tarih ve saat verir.

Equality(DateTime, DateTime)

Belirtilen iki DateTime örneğinin eşit olup olmadığını belirler.

GreaterThan(DateTime, DateTime)

Belirtilen bir öğesinin, belirtilen DateTime başka bir DateTimedeğerinden sonra olup olmadığını belirler.

GreaterThanOrEqual(DateTime, DateTime)

Belirtilenlerden birinin, belirtilen DateTime başka bir ile aynı veya daha sonraki DateTimebir tarih ve saati temsil edip etmediğini belirler.

Inequality(DateTime, DateTime)

Belirtilen iki DateTime örneğinin eşit olup olmadığını belirler.

LessThan(DateTime, DateTime)

Belirtilen bir öğesinin başka bir belirtilenden DateTime DateTimeönce olup olmadığını belirler.

LessThanOrEqual(DateTime, DateTime)

Belirtilenlerden birinin, belirtilen DateTime başka DateTimebir ile aynı veya önceki bir tarih ve saati temsil edip etmediğini belirler.

Subtraction(DateTime, DateTime)

Belirtilen tarih ve saati başka bir belirtilen tarih ve saatten çıkarır ve bir zaman aralığı döndürür.

Subtraction(DateTime, TimeSpan)

Belirtilen zaman aralığını belirtilen tarih ve saatten çıkarır ve yeni bir tarih ve saat döndürür.

Belirtik Arabirim Kullanımları

IComparable.CompareTo(Object)

Mevcut örneği aynı türdeki başka bir nesne ile karşılaştırır ve geçerli örneğin, diğer nesneyle aynı sıralama düzeni konumunda mı olduğunu, önünde mi olduğunu, yoksa arkasında mı olduğunu belirten bir tamsayı döndürür.

IConvertible.GetTypeCode()

Bu örneğin değerini TypeCode döndürür.

IConvertible.ToBoolean(IFormatProvider)

Bu dönüşüm desteklenmiyor. Bu yöntem kullanılmaya çalışılması bir InvalidCastExceptionoluşturur.

IConvertible.ToByte(IFormatProvider)

Bu dönüşüm desteklenmiyor. Bu yöntem kullanılmaya çalışılması bir InvalidCastExceptionoluşturur.

IConvertible.ToChar(IFormatProvider)

Bu dönüşüm desteklenmiyor. Bu yöntem kullanılmaya çalışılması bir InvalidCastExceptionoluşturur.

IConvertible.ToDateTime(IFormatProvider)

Geçerli DateTime nesneyi döndürür.

IConvertible.ToDecimal(IFormatProvider)

Bu dönüşüm desteklenmiyor. Bu yöntem kullanılmaya çalışılması bir InvalidCastExceptionoluşturur.

IConvertible.ToDouble(IFormatProvider)

Bu dönüşüm desteklenmiyor. Bu yöntem kullanılmaya çalışılması bir InvalidCastExceptionoluşturur.

IConvertible.ToInt16(IFormatProvider)

Bu dönüşüm desteklenmiyor. Bu yöntem kullanılmaya çalışılması bir InvalidCastExceptionoluşturur.

IConvertible.ToInt32(IFormatProvider)

Bu dönüşüm desteklenmiyor. Bu yöntem kullanılmaya çalışılması bir InvalidCastExceptionoluşturur.

IConvertible.ToInt64(IFormatProvider)

Bu dönüşüm desteklenmiyor. Bu yöntem kullanılmaya çalışılması bir InvalidCastExceptionoluşturur.

IConvertible.ToSByte(IFormatProvider)

Bu dönüşüm desteklenmiyor. Bu yöntem kullanılmaya çalışılması bir InvalidCastExceptionoluşturur.

IConvertible.ToSingle(IFormatProvider)

Bu dönüşüm desteklenmiyor. Bu yöntem kullanılmaya çalışılması bir InvalidCastExceptionoluşturur.

IConvertible.ToType(Type, IFormatProvider)

Geçerli DateTime nesneyi belirtilen türde bir nesneye dönüştürür.

IConvertible.ToUInt16(IFormatProvider)

Bu dönüşüm desteklenmiyor. Bu yöntem kullanılmaya çalışılması bir InvalidCastExceptionoluşturur.

IConvertible.ToUInt32(IFormatProvider)

Bu dönüşüm desteklenmiyor. Bu yöntem kullanılmaya çalışılması bir InvalidCastExceptionoluşturur.

IConvertible.ToUInt64(IFormatProvider)

Bu dönüşüm desteklenmiyor. Bu yöntem kullanılmaya çalışılması bir InvalidCastExceptionoluşturur.

ISerializable.GetObjectData(SerializationInfo, StreamingContext)

Bir SerializationInfo nesneyi geçerli DateTime nesneyi seri hale getirmek için gereken verilerle doldurur.

Şunlara uygulanır

İş Parçacığı Güvenliği

Bu türün tüm üyeleri iş parçacığı güvenlidir. Örneğin durumunu değiştirmek için görüntülenen üyeler, gerçekte yeni değer ile başlatılan yeni bir örneği döndürür. Diğer türlerde olduğu gibi, bu türün örneğini içeren paylaşılan değişkenini okuma ve yazma, iş parçacığı güvenliğini sağlamak için bir kilit tarafından korunmalıdır.

Ayrıca bkz.