DateTime Struktur

Definisi

Ruang nama:

System

Rakitan:

System.Runtime.dll

Mewakili instan dalam waktu, biasanya dinyatakan sebagai tanggal dan jam hari.

public value class DateTime : IComparable, IComparable<DateTime>, IConvertible, IEquatable<DateTime>, IParsable<DateTime>, ISpanFormattable, ISpanParsable<DateTime>, IUtf8SpanFormattable, System::Runtime::Serialization::ISerializable

public readonly struct DateTime : IComparable, IComparable<DateTime>, IConvertible, IEquatable<DateTime>, IParsable<DateTime>, ISpanFormattable, ISpanParsable<DateTime>, IUtf8SpanFormattable, System.Runtime.Serialization.ISerializable

type DateTime = struct
    interface IConvertible
    interface IFormattable
    interface IParsable<DateTime>
    interface ISpanFormattable
    interface ISpanParsable<DateTime>
    interface ISerializable
    interface IUtf8SpanFormattable

Public Structure DateTime
Implements IComparable, IComparable(Of DateTime), IConvertible, IEquatable(Of DateTime), IParsable(Of DateTime), ISerializable, ISpanFormattable, ISpanParsable(Of DateTime), IUtf8SpanFormattable

Warisan

Object

ValueType

DateTime

Penerapan

IComparable IComparable<DateTime> IConvertible IEquatable<DateTime> IFormattable ISerializable ISpanFormattable IParsable<DateTime> IParsable<TSelf> ISpanParsable<DateTime> IUtf8SpanFormattable

Keterangan

Penting

Era dalam kalender Jepang didasarkan pada pemerintahan kaisar dan karenanya diharapkan berubah. Misalnya, 1 Mei 2019 menandai awal era Reiwa di JapaneseCalendar dan JapaneseLunisolarCalendar. Perubahan era seperti itu mempengaruhi semua aplikasi yang menggunakan kalender ini. Untuk informasi selengkapnya dan untuk menentukan apakah aplikasi Anda terpengaruh, lihat Menangani era baru di kalender Jepang di .NET. Untuk informasi tentang menguji aplikasi Anda pada sistem Windows untuk memastikan kesiapannya untuk perubahan era, lihat Menyiapkan aplikasi Anda untuk perubahan era Jepang. Untuk fitur di .NET yang mendukung kalender dengan beberapa era dan untuk praktik terbaik saat bekerja dengan kalender yang mendukung beberapa era, lihat Bekerja dengan era.

Tautan cepat ke kode contoh

Catatan

Beberapa contoh C# dalam artikel ini berjalan di Try.NET runner kode sebaris dan taman bermain. Pilih tombol Jalankan untuk menjalankan contoh di jendela interaktif. Setelah Anda menjalankan kode, Anda dapat memodifikasinya dan menjalankan kode yang dimodifikasi dengan memilih Jalankan lagi. Kode yang dimodifikasi berjalan di jendela interaktif atau, jika kompilasi gagal, jendela interaktif menampilkan semua pesan kesalahan pengompilasi C#.

Zona waktu lokal dari pengeksekusi dan playground code sebaris Try.NET adalah Waktu Universal Terkoordinasi, atau UTC. Hal ini dapat memengaruhi perilaku dan output contoh yang mengilustrasikan jenis DateTime, DateTimeOffset, dan TimeZoneInfo serta anggotanya.

Artikel ini menyertakan beberapa contoh yang menggunakan DateTime jenis :

Contoh Inisialisasi

• Memanggil konstruktor
• Memanggil konstruktor tanpa parameter implisit
• Penugasan dari nilai yang dikembalikan
• Mengurai string yang mewakili tanggal dan waktu
• Sintaks Visual Basic untuk menginisialisasi tanggal dan waktu

DateTime Memformat objek sebagai string

• Menggunakan format waktu tanggal default
• Memformat tanggal dan waktu menggunakan budaya tertentu
• Memformat waktu tanggal menggunakan string format standar atau kustom
• Tentukan string format dan budaya tertentu
• Memformat waktu tanggal menggunakan standar ISO 8601 untuk layanan web

Mengurai string sebagai DateTime objek

• Menggunakan Parse atau TryParse untuk mengonversi string menjadi tanggal dan waktu
• Menggunakan ParseExact atau TryParseExact untuk mengonversi string dalam format yang diketahui
• Mengonversi dari representasi string ISO 8601 menjadi tanggal dan waktu

DateTime Resolusi

• Menjelajahi resolusi nilai tanggal dan waktu
• Membandingkan kesetaraan dalam toleransi

Budaya dan kalender

• Menampilkan nilai tanggal dan waktu menggunakan kalender khusus budaya
• Mengurai string sesuai dengan kalender khusus budaya
• Menginisialisasi tanggal dan waktu dari kalender budaya tertentu
• Mengakses properti tanggal dan waktu menggunakan kalender budaya tertentu
• Mengambil minggu dalam setahun menggunakan kalender khusus budaya

Persistensi

• Mempertahankan nilai tanggal dan waktu sebagai string di zona waktu lokal
• Mempertahankan nilai tanggal dan waktu sebagai string dalam format invarian budaya dan waktu
• Mempertahankan nilai tanggal dan waktu sebagai bilangan bulat
• Mempertahankan nilai tanggal dan waktu menggunakan XmlSerializer

Tautan cepat ke topik Keterangan

Bagian ini berisi topik untuk banyak penggunaan DateTime umum struct:

• Menginisialisasi DateTime objek
• Nilai DateTime dan representasi stringnya
• Mengurai nilai DateTime dari string
• Nilai DateTime
• Operasi DateTime
• Resolusi DateTime
• Nilai dan kalender DateTime
• Pertahankan nilai DateTime
• DateTime vs. TimeSpan
• Bandingkan untuk kesetaraan dalam toleransi
• Pertimbangan interop COM

Jenis DateTime nilai mewakili tanggal dan waktu dengan nilai mulai dari 00:00:00 (tengah malam), 1 Januari 0001 Anno Domini (Era Umum) hingga 11:59:59 P.M., 31 Desember 9999 A.D. (C.E.) di kalender Gregorian.

Nilai waktu diukur dalam unit 100 nanodetik yang disebut tick. Tanggal tertentu adalah jumlah kutu sejak 12:00 tengah malam, 1 Januari 0001 A.D. (C.E.) di GregorianCalendar kalender. Angka tersebut mengecualikan tanda centang yang akan ditambahkan dengan detik lompatan. Misalnya, nilai ticks 3124137600000000L menunjukkan tanggal Jumat, 01 Januari 0100 12:00:00 tengah malam. Nilai DateTime selalu dinyatakan dalam konteks kalender eksplisit atau default.

Catatan

Jika Anda bekerja dengan nilai centang yang ingin Anda konversi ke interval waktu lain, seperti menit atau detik, Anda harus menggunakan TimeSpan.TicksPerDay, , TimeSpan.TicksPerHourTimeSpan.TicksPerMinute, TimeSpan.TicksPerSecond, atau TimeSpan.TicksPerMillisecond konstanta untuk melakukan konversi. Misalnya, untuk menambahkan jumlah detik yang diwakili oleh jumlah tanda centang tertentu ke Second komponen DateTime nilai, Anda dapat menggunakan ekspresi dateValue.Second + nTicks/Timespan.TicksPerSecond.

Anda dapat melihat sumber untuk seluruh set contoh dari artikel ini baik di Visual Basic, F#, atau C# dari repositori dokumen di GitHub.

Catatan

Alternatif untuk DateTime struktur untuk bekerja dengan nilai tanggal dan waktu di zona waktu tertentu adalah strukturnya DateTimeOffset . Struktur DateTimeOffset menyimpan informasi tanggal dan waktu di bidang privat DateTime dan jumlah menit di mana tanggal dan waktu tersebut berbeda dari UTC di bidang privat Int16 . Ini memungkinkan nilai untuk DateTimeOffset mencerminkan waktu di zona waktu tertentu, sedangkan DateTime nilai dapat secara tidak ambigu hanya mencerminkan UTC dan waktu zona waktu lokal. Untuk diskusi tentang kapan menggunakan struktur atau DateTimeOffset struktur saat bekerja dengan nilai tanggal dan waktu, lihat Memilih Antara DateTime, DateTimeOffset, TimeSpan, dan TimeZoneInfo.DateTime

Menginisialisasi objek DateTime

Anda dapat menetapkan nilai awal ke nilai baru DateTime dengan berbagai cara:

• Memanggil konstruktor, baik di mana Anda menentukan argumen untuk nilai, atau menggunakan konstruktor tanpa parameter implisit.
• Menetapkan DateTime ke nilai yang dikembalikan dari properti atau metode.
• Mengurai DateTime nilai dari representasi stringnya.
• Menggunakan fitur bahasa khusus Visual Basic untuk membuat instans DateTime.

Cuplikan kode berikut menunjukkan contoh masing-masing.

Memanggil konstruktor

Anda memanggil salah satu kelebihan beban DateTime konstruktor yang menentukan elemen nilai tanggal dan waktu (seperti tahun, bulan, dan hari, atau jumlah tanda centang). Kode berikut membuat tanggal tertentu menggunakan DateTime konstruktor yang menentukan tahun, bulan, hari, jam, menit, dan detik.

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}"

Anda memanggil DateTime konstruktor tanpa parameter implisit struktur saat Anda ingin menginisialisasi DateTime ke nilai defaultnya. (Untuk detail tentang konstruktor tanpa parameter implisit dari jenis nilai, lihat Jenis Nilai.) Beberapa kompilator juga mendukung mendeklarasikan DateTime nilai tanpa secara eksplisit menetapkan nilai ke nilai tersebut. Membuat nilai tanpa inisialisasi eksplisit juga menghasilkan nilai default. Contoh berikut mengilustrasikan DateTime konstruktor tanpa parameter implisit dalam C# dan Visual Basic, serta DateTime deklarasi tanpa penugasan di Visual Basic.

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}"

Menetapkan nilai komputasi

Anda dapat menetapkan objek nilai DateTime tanggal dan waktu yang dikembalikan oleh properti atau metode. Contoh berikut menetapkan tanggal dan waktu saat ini, tanggal dan waktu Waktu Universal Terkoordinasi (UTC) saat ini, dan tanggal dan waktu saat ini ke tiga variabel baru DateTime .

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

Mengurai string yang mewakili DateTime

Metode Parse, ParseExact, TryParse, dan TryParseExact semuanya mengonversi string ke nilai tanggal dan waktu yang setara. Contoh berikut menggunakan Parse metode dan ParseExact untuk mengurai string dan mengonversinya menjadi DateTime nilai. Format kedua menggunakan formulir yang didukung oleh standar ISO 8601 untuk tanggal dan waktu yang mewakili dalam format string. Representasi standar ini sering digunakan untuk mentransfer informasi tanggal di layanan web.

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)

Metode TryParse dan TryParseExact menunjukkan apakah string adalah representasi nilai yang DateTime valid dan, jika ya, melakukan konversi.

Sintaksis khusus bahasa untuk Visual Basic

Pernyataan Visual Basic berikut menginisialisasi nilai baru DateTime .

Dim date1 As Date = #5/1/2008 8:30:52AM#

Nilai DateTime dan representasi stringnya

Secara internal, semua DateTime nilai dinyatakan sebagai jumlah tanda centang (jumlah interval 100 nanodetik) yang telah berlalu sejak 12:00:00 tengah malam, 1 Januari 0001. Nilai aktual DateTime tidak bergantung pada cara nilai tersebut muncul saat ditampilkan. Tampilan DateTime nilai adalah hasil dari operasi pemformatan yang mengonversi nilai ke representasi stringnya.

Munculnya nilai tanggal dan waktu tergantung pada budaya, standar internasional, persyaratan aplikasi, dan preferensi pribadi. Struktur menawarkan DateTime fleksibilitas dalam memformat nilai tanggal dan waktu melalui kelebihan beban ToString. Metode default DateTime.ToString() mengembalikan representasi string dari nilai tanggal dan waktu menggunakan pola tanggal pendek dan waktu panjang budaya saat ini. Contoh berikut menggunakan metode default DateTime.ToString() . Ini menampilkan tanggal dan waktu menggunakan pola tanggal pendek dan waktu yang lama untuk budaya saat ini. Budaya en-US adalah budaya saat ini di komputer tempat contoh dijalankan.

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

Anda mungkin perlu memformat tanggal dalam budaya tertentu untuk mendukung skenario web di mana server mungkin berada dalam budaya yang berbeda dari klien. Anda menentukan budaya menggunakan DateTime.ToString(IFormatProvider) metode untuk membuat representasi tanggal pendek dan waktu yang lama dalam budaya tertentu. Contoh berikut menggunakan DateTime.ToString(IFormatProvider) metode untuk menampilkan tanggal dan waktu menggunakan tanggal dan pola waktu singkat untuk budaya fr-FR.

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

Aplikasi lain mungkin memerlukan representasi string yang berbeda dari tanggal. Metode mengembalikan DateTime.ToString(String) representasi string yang ditentukan oleh penentu format standar atau kustom menggunakan konvensi pemformatan budaya saat ini. Contoh berikut menggunakan DateTime.ToString(String) metode untuk menampilkan pola tanggal dan waktu penuh untuk budaya en-US, budaya saat ini di komputer tempat contoh dijalankan.

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

Terakhir, Anda dapat menentukan budaya dan format menggunakan metode .DateTime.ToString(String, IFormatProvider) Contoh berikut menggunakan DateTime.ToString(String, IFormatProvider) metode untuk menampilkan pola tanggal dan waktu penuh untuk budaya fr-FR.

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

Kelebihan DateTime.ToString(String) beban juga dapat digunakan dengan string format kustom untuk menentukan format lain. Contoh berikut menunjukkan cara memformat string menggunakan format standar ISO 8601 yang sering digunakan untuk layanan web. Format Iso 8601 tidak memiliki string format standar yang sesuai.

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

Untuk informasi selengkapnya tentang nilai pemformatan DateTime , lihat String Format Tanggal dan Waktu Standar dan String Format Tanggal dan Waktu Kustom.

Mengurai nilai DateTime dari string

Penguraian mengonversi representasi string tanggal dan waktu menjadi DateTime nilai. Biasanya, string tanggal dan waktu memiliki dua penggunaan yang berbeda dalam aplikasi:

• Tanggal dan waktu membutuhkan berbagai bentuk dan mencerminkan konvensi budaya saat ini atau budaya tertentu. Misalnya, aplikasi memungkinkan pengguna yang budayanya saat ini en-US untuk memasukkan nilai tanggal sebagai "15/12/2013" atau "15 Desember 2013". Ini memungkinkan pengguna yang budayanya saat ini en-gb untuk memasukkan nilai tanggal sebagai "15/12/2013" atau "15 Desember 2013."

• Tanggal dan waktu diwakili dalam format yang telah ditentukan sebelumnya. Misalnya, aplikasi menserialisasikan tanggal sebagai "20130103" secara independen dari budaya tempat aplikasi berjalan. Aplikasi mungkin memerlukan tanggal input dalam format tanggal pendek budaya saat ini.

Anda menggunakan Parse metode atau TryParse untuk mengonversi string dari salah satu format tanggal dan waktu umum yang digunakan oleh budaya menjadi DateTime nilai. Contoh berikut menunjukkan bagaimana Anda dapat menggunakan TryParse untuk mengonversi string tanggal dalam format khusus budaya yang berbeda menjadi DateTime nilai. Ini mengubah budaya saat ini menjadi Bahasa Inggris (Inggris Raya) dan memanggil GetDateTimeFormats() metode untuk menghasilkan array string tanggal dan waktu. Kemudian meneruskan setiap elemen dalam array ke TryParse metode . Output dari contoh menunjukkan metode penguraian berhasil mengonversi setiap string tanggal dan waktu khusus budaya.

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

Anda menggunakan ParseExact metode dan TryParseExact untuk mengonversi string yang harus cocok dengan format atau format tertentu ke DateTime nilai. Anda menentukan satu atau beberapa string format tanggal dan waktu sebagai parameter untuk metode penguraian. Contoh berikut menggunakan TryParseExact(String, String[], IFormatProvider, DateTimeStyles, DateTime) metode untuk mengonversi string yang harus dalam format "yyyyMMdd" atau format "HHmmss" ke DateTime nilai.

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

Salah satu penggunaan umum untuk ParseExact adalah mengonversi representasi string dari layanan web, biasanya dalam format standar ISO 8601 . Kode berikut menunjukkan string format yang benar untuk digunakan:

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}")

Jika string tidak dapat diurai, Parse metode dan ParseExact melemparkan pengecualian. Metode TryParse dan TryParseExact mengembalikan Boolean nilai yang menunjukkan apakah konversi berhasil atau gagal. Anda harus menggunakan TryParse metode atau TryParseExact dalam skenario di mana performa penting. Operasi penguraian untuk string tanggal dan waktu cenderung memiliki tingkat kegagalan yang tinggi, dan penanganan pengecualian mahal. Gunakan metode ini jika string diinput oleh pengguna atau berasal dari sumber yang tidak diketahui.

Untuk informasi selengkapnya tentang mengurai nilai tanggal dan waktu, lihat Mengurai String Tanggal dan Waktu.

Nilai DateTime

Deskripsi nilai waktu dalam jenis sering diekspresikan DateTime menggunakan standar Waktu Universal Terkoordinasi (UTC). Waktu Universal Terkoordinasi adalah nama yang diakui secara internasional untuk Greenwich Mean Time (GMT). Waktu Universal Terkoordinasi adalah waktu seperti yang diukur pada bujur nol derajat, titik asal UTC. Waktu musim panas tidak berlaku untuk UTC.

Waktu lokal relatif terhadap zona waktu tertentu. Zona waktu dikaitkan dengan offset zona waktu. Offset zona waktu adalah perpindahan zona waktu yang diukur dalam jam dari titik asal UTC. Selain itu, waktu lokal secara opsional dipengaruhi oleh waktu musim panas, yang menambahkan atau mengurangi penyesuaian interval waktu. Waktu lokal dihitung dengan menambahkan offset zona waktu ke UTC dan menyesuaikan waktu musim panas jika perlu. Offset zona waktu pada titik asal UTC adalah nol.

Waktu UTC cocok untuk perhitungan, perbandingan, dan penyimpanan tanggal dan waktu dalam file. Waktu lokal sesuai untuk ditampilkan di antarmuka pengguna aplikasi desktop. Aplikasi yang sadar zona waktu (seperti banyak aplikasi Web) juga perlu bekerja dengan sejumlah zona waktu lainnya.

Kind Jika properti objek DateTime adalah DateTimeKind.Unspecified, itu tidak ditentukan apakah waktu yang diwakili adalah waktu lokal, waktu UTC, atau waktu di beberapa zona waktu lainnya.

Resolusi DateTime

Catatan

Sebagai alternatif untuk melakukan aritmatika tanggal dan waktu pada DateTime nilai untuk mengukur waktu yang berlalu, Anda dapat menggunakan Stopwatch kelas .

Properti Ticks mengekspresikan nilai tanggal dan waktu dalam satuan sepuluh juta detik. Properti Millisecond mengembalikan seribu detik dalam nilai tanggal dan waktu. Menggunakan panggilan berulang ke DateTime.Now properti untuk mengukur waktu yang berlalu tergantung pada jam sistem. Jam sistem pada sistem Windows 7 dan Windows 8 memiliki resolusi sekitar 15 milidetik. Resolusi ini memengaruhi interval waktu kecil kurang dari 100 milidetik.

Contoh berikut mengilustrasikan dependensi nilai tanggal dan waktu saat ini pada resolusi jam sistem. Dalam contoh, perulangan luar berulang 20 kali, dan perulangan dalam berfungsi untuk menunda perulangan luar. Jika nilai penghitung perulangan luar adalah 10, panggilan ke Thread.Sleep metode memperkenalkan penundaan lima milidetik. Contoh berikut menunjukkan jumlah milidetik yang dikembalikan oleh DateTime.Now.Milliseconds properti berubah hanya setelah panggilan ke Thread.Sleep.

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

Operasi DateTime

Perhitungan menggunakan DateTime struktur, seperti Add atau Subtract, tidak mengubah nilai struktur. Sebaliknya, perhitungan mengembalikan struktur baru DateTime yang nilainya adalah hasil penghitungan.

Operasi konversi antara zona waktu (seperti antara UTC dan waktu setempat, atau antara satu zona waktu dan zona waktu lainnya) membutuhkan waktu musim panas, tetapi operasi aritmatika dan perbandingan tidak.

Struktur itu DateTime sendiri menawarkan dukungan terbatas untuk mengonversi dari satu zona waktu ke zona lain. Anda dapat menggunakan ToLocalTime metode untuk mengonversi UTC ke waktu lokal, atau Anda dapat menggunakan ToUniversalTime metode untuk mengonversi dari waktu lokal ke UTC. Namun, serangkaian metode konversi zona waktu lengkap tersedia di TimeZoneInfo kelas . Anda mengonversi waktu di salah satu zona waktu dunia ke waktu di zona waktu lain menggunakan metode ini.

Perhitungan dan perbandingan DateTime objek bermakna hanya jika objek mewakili waktu dalam zona waktu yang sama. Anda dapat menggunakan TimeZoneInfo objek untuk mewakili DateTime zona waktu nilai, meskipun keduanya digabungkan secara longgar. Objek DateTime tidak memiliki properti yang mengembalikan objek yang mewakili zona waktu nilai tanggal dan waktu tersebut. Properti Kind menunjukkan apakah DateTime mewakili UTC, waktu lokal, atau tidak ditentukan. Dalam aplikasi yang sadar zona waktu, Anda harus mengandalkan beberapa mekanisme eksternal untuk menentukan zona waktu tempat DateTime objek dibuat. Anda dapat menggunakan struktur yang membungkus DateTime nilai dan TimeZoneInfo objek yang mewakili DateTime zona waktu nilai. Untuk detail tentang menggunakan UTC dalam perhitungan dan perbandingan dengan DateTime nilai, lihat Melakukan Operasi Aritmatika dengan Tanggal dan Waktu.

Setiap DateTime anggota secara implisit menggunakan kalender Gregorian untuk melakukan operasinya. Pengecualian adalah metode yang secara implisit menentukan kalender. Ini termasuk konstruktor yang menentukan kalender, dan metode dengan parameter yang berasal dari IFormatProvider, seperti System.Globalization.DateTimeFormatInfo.

Operasi oleh anggota jenis DateTime mempertimbangkan detail seperti tahun kabut dan jumlah hari dalam sebulan.

Nilai dan kalender DateTime

Pustaka Kelas .NET mencakup sejumlah kelas kalender, yang semuanya berasal dari Calendar kelas . Topologi tersebut adalah:

• Kelas ChineseLunisolarCalendar.
• Kelas EastAsianLunisolarCalendar.
• Kelas GregorianCalendar.
• Kelas HebrewCalendar.
• Kelas HijriCalendar.
• Kelas JapaneseCalendar.
• Kelas JapaneseLunisolarCalendar.
• Kelas JulianCalendar.
• Kelas KoreanCalendar.
• Kelas KoreanLunisolarCalendar.
• Kelas PersianCalendar.
• Kelas TaiwanCalendar.
• Kelas TaiwanLunisolarCalendar.
• Kelas ThaiBuddhistCalendar.
• Kelas UmAlQuraCalendar.

Penting

Era di kalender Jepang didasarkan pada pemerintahan kaisar dan karenanya diharapkan berubah. Misalnya, 1 Mei 2019 menandai awal era Reiwa di JapaneseCalendar dan JapaneseLunisolarCalendar. Perubahan era seperti itu mempengaruhi semua aplikasi yang menggunakan kalender ini. Untuk informasi selengkapnya dan untuk menentukan apakah aplikasi Anda terpengaruh, lihat Menangani era baru di kalender Jepang di .NET. Untuk informasi tentang menguji aplikasi Anda pada sistem Windows untuk memastikan kesiapannya untuk perubahan era, lihat Menyiapkan aplikasi Anda untuk perubahan era Jepang. Untuk fitur di .NET yang mendukung kalender dengan beberapa era dan untuk praktik terbaik saat bekerja dengan kalender yang mendukung beberapa era, lihat Bekerja dengan era.

Setiap budaya menggunakan kalender default yang ditentukan oleh properti baca-saja CultureInfo.Calendar . Setiap budaya dapat mendukung satu atau beberapa kalender yang ditentukan oleh properti baca-saja CultureInfo.OptionalCalendars . Kalender yang saat ini digunakan oleh objek tertentu CultureInfo ditentukan oleh propertinya DateTimeFormatInfo.Calendar . Ini harus menjadi salah satu kalender yang ditemukan dalam CultureInfo.OptionalCalendars array.

Kalender budaya saat ini digunakan dalam semua operasi pemformatan untuk budaya tersebut. Misalnya, kalender default budaya Buddha Thailand adalah kalender Era Buddha Thailand, yang diwakili oleh ThaiBuddhistCalendar kelas . CultureInfo Ketika objek yang mewakili budaya Buddha Thailand digunakan dalam operasi pemformatan tanggal dan waktu, kalender Era Buddha Thailand digunakan secara default. Kalender Gregorian hanya digunakan jika properti budaya DateTimeFormatInfo.Calendar diubah, seperti yang ditunjukkan contoh berikut:

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

Kalender budaya saat ini juga digunakan dalam semua operasi penguraian untuk budaya tersebut, seperti yang ditunjukkan contoh berikut.

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

Anda membuat instans DateTime nilai menggunakan elemen tanggal dan waktu (jumlah tahun, bulan, dan hari) kalender tertentu dengan memanggil konstruktor DateTime yang menyertakan calendar parameter dan meneruskannya objek yang mewakili kalender tersebut Calendar . Contoh berikut menggunakan elemen tanggal dan waktu dari ThaiBuddhistCalendar kalender.

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 konstruktor yang tidak menyertakan calendar parameter mengasumsikan bahwa elemen tanggal dan waktu dinyatakan sebagai unit dalam kalender Gregorian.

Semua properti dan metode lainnya DateTime menggunakan kalender Gregorian. Misalnya, DateTime.Year properti mengembalikan tahun di kalender Gregorian, dan DateTime.IsLeapYear(Int32) metode mengasumsikan bahwa year parameter adalah tahun di kalender Gregorian. Setiap DateTime anggota yang menggunakan kalender Gregorian memiliki anggota Calendar kelas yang sesuai yang menggunakan kalender tertentu. Misalnya, Calendar.GetYear metode mengembalikan tahun dalam kalender tertentu, dan Calendar.IsLeapYear metode menginterpretasikan year parameter sebagai angka tahun dalam kalender tertentu. Contoh berikut menggunakan DateTime dan anggota kelas yang ThaiBuddhistCalendar sesuai.

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

Struktur DateTime mencakup DayOfWeek properti yang mengembalikan hari dalam seminggu di kalender Gregorian. Ini tidak termasuk anggota yang memungkinkan Anda untuk mengambil nomor minggu dalam setahun. Untuk mengambil minggu dalam setahun, panggil metode kalender Calendar.GetWeekOfYear individual. Contoh berikut memberikan ilustrasi.

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

Untuk informasi selengkapnya tentang tanggal dan kalender, lihat Bekerja dengan Kalender.

Pertahankan nilai DateTime

Anda bisa mempertahankan DateTime nilai dengan cara berikut:

• Konversikan menjadi string dan pertahankan string.
• Konversikan ke nilai bilangan bulat 64-bit (nilai properti ) dan pertahankan bilangan bulat.Ticks
• Membuat serialisasi nilai DateTime.

Anda harus memastikan bahwa rutinitas yang memulihkan DateTime nilai tidak kehilangan data atau memberikan pengecualian terlepas dari teknik mana yang Anda pilih. DateTime nilai harus round-trip. Artinya, nilai asli dan nilai yang dipulihkan harus sama. Dan jika nilai asli DateTime mewakili satu instans waktu, nilai tersebut harus mengidentifikasi momen waktu yang sama saat dipulihkan.

Mempertahankan nilai sebagai string

Agar berhasil memulihkan DateTime nilai yang dipertahankan sebagai string, ikuti aturan berikut:

• Buat asumsi yang sama tentang pemformatan khusus budaya saat Anda memulihkan string seperti saat Anda mempertahankannya. Untuk memastikan bahwa string dapat dipulihkan pada sistem yang budayanya saat ini berbeda dari budaya sistem tempatnya disimpan, panggil ToString kelebihan beban untuk menyimpan string dengan menggunakan konvensi budaya invarian. Parse(String, IFormatProvider, DateTimeStyles) Panggil atau TryParse(String, IFormatProvider, DateTimeStyles, DateTime) kelebihan beban untuk memulihkan string dengan menggunakan konvensi budaya invarian. Jangan pernah menggunakan ToString(), Parse(String), atau TryParse(String, DateTime) kelebihan beban, yang menggunakan konvensi budaya saat ini.

• Jika tanggal mewakili satu momen waktu, pastikan tanggal tersebut mewakili momen yang sama pada saat dipulihkan, bahkan pada zona waktu yang berbeda. Konversikan nilai menjadi DateTime Waktu Universal Terkoordinasi (UTC) sebelum menyimpannya atau menggunakan DateTimeOffset.

Kesalahan paling umum yang dibuat saat mempertahankan DateTime nilai sebagai string adalah mengandalkan konvensi pemformatan dari budaya default atau saat ini. Masalah muncul jika budaya saat ini berbeda saat menyimpan dan memulihkan string. Contoh berikut mengilustrasikan masalah ini. Ini menghemat lima tanggal menggunakan konvensi pemformatan budaya saat ini, yang dalam hal ini adalah bahasa Inggris (Amerika Serikat). Ini memulihkan tanggal menggunakan konvensi pemformatan dari budaya yang berbeda, yang dalam hal ini adalah Bahasa Inggris (Inggris). Karena konvensi pemformatan dari dua budaya berbeda, dua tanggal tidak dapat dipulihkan, dan tiga tanggal lainnya salah ditafsirkan. Selain itu, jika nilai tanggal dan waktu asli mewakili satu momen tepat waktu, waktu yang dipulihkan salah karena informasi zona waktu hilang.

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...

Agar nilai round-trip DateTime berhasil, ikuti langkah-langkah berikut:

1. Jika nilai mewakili satu momen waktu, konversikan dari waktu lokal ke UTC dengan memanggil ToUniversalTime metode .
2. Konversikan tanggal ke representasi string mereka dengan memanggil ToString(String, IFormatProvider) atau String.Format(IFormatProvider, String, Object[]) kelebihan beban. Gunakan konvensi pemformatan budaya invarian dengan menentukan CultureInfo.InvariantCulture sebagai provider argumen . Tentukan bahwa nilai harus melakukan round-trip dengan menggunakan string format standar "O" atau "R".

Untuk memulihkan nilai yang bertahan DateTime tanpa kehilangan data, ikuti langkah-langkah berikut:

1. Uraikan data dengan memanggil ParseExact atau TryParseExact kelebihan beban. Tentukan CultureInfo.InvariantCulture sebagai provider argumen, dan gunakan string format standar yang sama dengan yang Anda gunakan untuk format argumen selama konversi. Sertakan DateTimeStyles.RoundtripKind nilai dalam styles argumen .
2. DateTime Jika nilai mewakili satu momen tepat waktu, panggil ToLocalTime metode untuk mengonversi tanggal yang diurai dari UTC ke waktu lokal.

Contoh berikut menggunakan budaya invarian dan string format standar "O" untuk memastikan bahwa nilai yang DateTime disimpan dan dipulihkan mewakili momen yang sama dalam waktu terlepas dari sistem, budaya, atau zona waktu sistem sumber dan target.

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...

Mempertahankan nilai sebagai bilangan bulat

Anda dapat mempertahankan tanggal dan waktu sebagai Int64 nilai yang mewakili sejumlah tanda centang. Dalam hal ini, Anda tidak perlu mempertimbangkan budaya sistem tempat DateTime nilai dipertahankan dan dipulihkan.

Untuk mempertahankan DateTime nilai sebagai bilangan bulat:

• DateTime Jika nilai mewakili satu momen tepat waktu, konversikan ke UTC dengan memanggil ToUniversalTime metode .
• Ambil jumlah tanda centang yang diwakili oleh DateTime nilai dari propertinya Ticks .

Untuk memulihkan DateTime nilai yang telah dipertahankan sebagai bilangan bulat:

1. Buat instans objek baru DateTime dengan meneruskan Int64 nilai ke DateTime(Int64) konstruktor.
2. DateTime Jika nilai mewakili satu momen dalam waktu, konversikan dari UTC ke waktu lokal dengan memanggil ToLocalTime metode .

Contoh berikut mempertahankan array nilai sebagai bilangan DateTime bulat pada sistem di zona Waktu Pasifik A.S. Ini memulihkannya pada sistem di zona UTC. File yang berisi bilangan bulat menyertakan Int32 nilai yang menunjukkan jumlah Int64 total nilai yang segera mengikutinya.

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...

Menserialisasikan nilai DateTime

Anda dapat mempertahankan DateTime nilai melalui serialisasi ke aliran atau file, lalu memulihkannya melalui deserialisasi. DateTime data diserialisasikan dalam beberapa format objek tertentu. Objek dipulihkan ketika dideserialisasi. Formatter atau serializer, seperti JsonSerializer atau XmlSerializer, menangani proses serialisasi dan deserialisasi. Untuk informasi selengkapnya tentang serialisasi dan jenis serialisasi yang didukung oleh .NET, lihat Serialisasi.

Contoh berikut menggunakan kelas untuk menserialisasikan XmlSerializer dan mendeserialisasi DateTime nilai. Nilai-nilai mewakili semua hari tahun kampung pada abad kedua puluh pertama. Output mewakili hasil jika contoh dijalankan pada sistem yang budayanya saat ini adalah Inggris (Inggris). Karena Anda telah mendeserialisasi objek itu DateTime sendiri, kode tidak harus menangani perbedaan budaya dalam format tanggal dan waktu.

public static void PersistAsXML()
{
    // Serialize the data.
    var leapYears = new List<DateTime>();
    for (int year = 2000; year <= 2100; year += 4)
    {
        if (DateTime.IsLeapYear(year))
            leapYears.Add(new DateTime(year, 2, 29));
    }
    DateTime[] dateArray = leapYears.ToArray();

    var serializer = new XmlSerializer(dateArray.GetType());
    TextWriter sw = new StreamWriter(filenameXml);

    try
    {
        serializer.Serialize(sw, dateArray);
    }
    catch (InvalidOperationException e)
    {
        Console.WriteLine(e.InnerException?.Message);
    }
    finally
    {
        if (sw != null) sw.Close();
    }

    // Deserialize the data.
    DateTime[]? deserializedDates;
    using (var fs = new FileStream(filenameXml, FileMode.Open))
    {
        deserializedDates = (DateTime[]?)serializer.Deserialize(fs);
    }

    // Display the dates.
    Console.WriteLine($"Leap year days from 2000-2100 on an {Thread.CurrentThread.CurrentCulture.Name} system:");
    int nItems = 0;
    if (deserializedDates is not null)
    {
        foreach (var dat in deserializedDates)
        {
            Console.Write($"   {dat:d}     ");
            nItems++;
            if (nItems % 5 == 0)
                Console.WriteLine();
        }
    }
}
// The example displays the following output:
//    Leap year days from 2000-2100 on an en-GB system:
//       29/02/2000       29/02/2004       29/02/2008       29/02/2012       29/02/2016
//       29/02/2020       29/02/2024       29/02/2028       29/02/2032       29/02/2036
//       29/02/2040       29/02/2044       29/02/2048       29/02/2052       29/02/2056
//       29/02/2060       29/02/2064       29/02/2068       29/02/2072       29/02/2076
//       29/02/2080       29/02/2084       29/02/2088       29/02/2092       29/02/2096

let persistAsXML () =
    // Serialize the data.
    let leapYears =
        [| for year in 2000..4..2100 do
            if DateTime.IsLeapYear year then
                DateTime(year, 2, 29) |]

    let serializer = XmlSerializer(leapYears.GetType())
    use sw = new StreamWriter(filenameXml)

    try
        serializer.Serialize(sw, leapYears)
    with :? InvalidOperationException as e ->
        printfn $"{e.InnerException.Message}"

    // Deserialize the data.
    use fs = new FileStream(filenameXml, FileMode.Open)
        
    let deserializedDates = serializer.Deserialize fs :?> DateTime []

    // Display the dates.
    printfn $"Leap year days from 2000-2100 on an {Thread.CurrentThread.CurrentCulture.Name} system:"
    
    let mutable nItems = 0
    for dat in deserializedDates do
        printf $"   {dat:d}     "
        nItems <- nItems + 1
        if nItems % 5 = 0 then
            printfn ""

// The example displays the following output:
//    Leap year days from 2000-2100 on an en-GB system:
//       29/02/2000       29/02/2004       29/02/2008       29/02/2012       29/02/2016
//       29/02/2020       29/02/2024       29/02/2028       29/02/2032       29/02/2036
//       29/02/2040       29/02/2044       29/02/2048       29/02/2052       29/02/2056
//       29/02/2060       29/02/2064       29/02/2068       29/02/2072       29/02/2076
//       29/02/2080       29/02/2084       29/02/2088       29/02/2092       29/02/2096

Contoh sebelumnya tidak menyertakan informasi waktu. DateTime Jika nilai mewakili momen tepat waktu dan dinyatakan sebagai waktu setempat, konversikan dari waktu lokal ke UTC sebelum menserialisasikannya dengan memanggil ToUniversalTime metode . Setelah Anda mendeserialisasinya, konversikan dari UTC ke waktu lokal dengan memanggil ToLocalTime metode .

DateTime vs. TimeSpan

Jenis DateTime nilai dan TimeSpan berbeda di mana mewakili DateTime instan dalam waktu, sedangkan mewakili TimeSpan interval waktu. Anda dapat mengurangi satu instans dari DateTime instans lain untuk mendapatkan TimeSpan objek yang mewakili interval waktu di antaranya. Atau Anda dapat menambahkan positif TimeSpan ke saat ini DateTime untuk mendapatkan DateTime nilai yang mewakili tanggal mendatang.

Anda dapat menambahkan atau mengurangi interval waktu dari DateTime objek. Interval waktu bisa negatif atau positif, dan dapat diekspresikan dalam unit seperti tanda centang, detik, atau sebagai TimeSpan objek.

Bandingkan untuk kesetaraan dalam toleransi

Perbandingan kesetaraan untuk DateTime nilai tepat. Itu berarti dua nilai harus dinyatakan sebagai jumlah tick yang sama untuk dianggap sama. Presisi itu sering kali tidak perlu atau bahkan salah untuk banyak aplikasi. Seringkali, Anda ingin menguji apakah DateTime objek kira-kira sama.

Contoh berikut menunjukkan cara membandingkan nilai yang kira-kira setara DateTime . Ini menerima selisih kecil perbedaan ketika mendeklarasikannya sama.

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

Pertimbangan interop COM

DateTime Nilai yang ditransfer ke aplikasi COM, kemudian ditransfer kembali ke aplikasi terkelola, dikatakan untuk pulang-pergi. Namun, DateTime nilai yang hanya menentukan waktu tidak melakukan perjalanan pulang-pergi seperti yang mungkin Anda harapkan.

Jika Anda pulang-pergi hanya sekali waktu, seperti 3 P.M., tanggal dan waktu akhir adalah 30 Desember 1899 C.E. pada 3:00 P.M., alih-alih Januari, 1, 0001 C.E. pada 3:00 P.M. .NET Framework dan COM mengasumsikan tanggal default ketika hanya waktu yang ditentukan. Namun, sistem COM mengasumsikan tanggal dasar 30 Desember 1899 C.E., sementara .NET Framework mengasumsikan tanggal dasar Januari, 1, 0001 C.E.

Ketika hanya satu waktu yang diteruskan dari .NET Framework ke COM, pemrosesan khusus dilakukan yang mengonversi waktu ke format yang digunakan oleh COM. Ketika hanya satu waktu yang diteruskan dari COM ke .NET Framework, tidak ada pemrosesan khusus yang dilakukan karena itu akan merusak tanggal dan waktu yang sah pada atau sebelum 30 Desember 1899. Jika tanggal memulai perjalanan pulang-pergi dari COM, .NET Framework dan COM mempertahankan tanggal.

Perilaku .NET Framework dan COM berarti bahwa jika aplikasi Anda melakukan perjalanan DateTime pulang pergi yang hanya menentukan waktu, aplikasi Anda harus ingat untuk memodifikasi atau mengabaikan tanggal yang salah dari objek akhirDateTime.

Konstruktor

DateTime(DateOnly, TimeOnly)	Menginisialisasi instans DateTime baru struktur ke yang ditentukan DateOnly dan TimeOnly. Instans baru akan memiliki jenisnya Unspecified .
DateTime(DateOnly, TimeOnly, DateTimeKind)	Menginisialisasi instans DateTime baru struktur ke yang ditentukan DateOnly dan TimeOnly dan menghormati DateTimeKind.
DateTime(Int32, Int32, Int32)	Menginisialisasi instans DateTime baru struktur ke tahun, bulan, dan hari yang ditentukan.
DateTime(Int32, Int32, Int32, Calendar)	Menginisialisasi instans DateTime baru struktur ke tahun, bulan, dan hari yang ditentukan untuk kalender yang ditentukan.
DateTime(Int32, Int32, Int32, Int32, Int32, Int32)	Menginisialisasi instans DateTime baru struktur ke tahun, bulan, hari, jam, menit, dan detik yang ditentukan.
DateTime(Int32, Int32, Int32, Int32, Int32, Int32, Calendar)	Menginisialisasi instans DateTime baru struktur ke tahun, bulan, hari, jam, menit, dan detik yang ditentukan untuk kalender yang ditentukan.
DateTime(Int32, Int32, Int32, Int32, Int32, Int32, DateTimeKind)	Menginisialisasi instans DateTime baru struktur ke tahun, bulan, hari, jam, menit, detik, dan Waktu Universal Terkoordinasi (UTC) yang ditentukan atau waktu setempat.
DateTime(Int32, Int32, Int32, Int32, Int32, Int32, Int32)	Menginisialisasi instans DateTime baru struktur ke tahun, bulan, hari, jam, menit, detik, dan milidetik yang ditentukan.
DateTime(Int32, Int32, Int32, Int32, Int32, Int32, Int32, Calendar)	Menginisialisasi instans DateTime baru struktur ke tahun, bulan, hari, jam, menit, detik, dan milidetik yang ditentukan untuk kalender yang ditentukan.
DateTime(Int32, Int32, Int32, Int32, Int32, Int32, Int32, Calendar, DateTimeKind)	Menginisialisasi instans DateTime baru struktur ke tahun, bulan, hari, jam, menit, detik, milidetik, dan Waktu Universal Terkoordinasi (UTC) yang ditentukan atau waktu setempat untuk kalender yang ditentukan.
DateTime(Int32, Int32, Int32, Int32, Int32, Int32, Int32, DateTimeKind)	Menginisialisasi instans DateTime baru struktur ke tahun, bulan, hari, jam, menit, detik, milidetik, dan Waktu Universal Terkoordinasi (UTC) atau waktu setempat yang ditentukan.
DateTime(Int32, Int32, Int32, Int32, Int32, Int32, Int32, Int32)	Menginisialisasi instans DateTime baru struktur ke tahun, bulan, hari, jam, menit, detik, milidetik, dan Waktu Universal Terkoordinasi (UTC) yang ditentukan atau waktu setempat untuk kalender yang ditentukan.
DateTime(Int32, Int32, Int32, Int32, Int32, Int32, Int32, Int32, Calendar)	Menginisialisasi instans DateTime baru struktur ke tahun, bulan, hari, jam, menit, detik, milidetik, dan Waktu Universal Terkoordinasi (UTC) yang ditentukan atau waktu setempat untuk kalender yang ditentukan.
DateTime(Int32, Int32, Int32, Int32, Int32, Int32, Int32, Int32, Calendar, DateTimeKind)	Menginisialisasi instans DateTime baru struktur ke tahun, bulan, hari, jam, menit, detik, milidetik, dan Waktu Universal Terkoordinasi (UTC) yang ditentukan atau waktu setempat untuk kalender yang ditentukan.
DateTime(Int32, Int32, Int32, Int32, Int32, Int32, Int32, Int32, DateTimeKind)	Menginisialisasi instans DateTime baru struktur ke tahun, bulan, hari, jam, menit, detik, milidetik, dan Waktu Universal Terkoordinasi (UTC) yang ditentukan atau waktu setempat untuk kalender yang ditentukan.
DateTime(Int64)	Menginisialisasi instans DateTime baru struktur ke jumlah tick tertentu.
DateTime(Int64, DateTimeKind)	Menginisialisasi instans DateTime baru struktur ke jumlah tick tertentu dan ke Waktu Universal Terkoordinasi (UTC) atau waktu lokal.

Bidang

MaxValue	Mewakili nilai terbesar yang mungkin dari DateTime. Bidang ini hanya-baca.
MinValue	Mewakili nilai sekecil mungkin dari DateTime. Bidang ini hanya-baca.
UnixEpoch	Nilai konstanta ini setara dengan 00:00:00.0000000 UTC, 1 Januari 1970, di kalender Gregorian. UnixEpoch menentukan titik waktu ketika waktu Unix sama dengan 0.

Properti

Date	Mendapatkan komponen tanggal instans ini.
Day	Mendapatkan hari dalam sebulan yang diwakili oleh instans ini.
DayOfWeek	Mendapatkan hari dalam seminggu yang diwakili oleh instans ini.
DayOfYear	Mendapatkan hari dalam setahun yang diwakili oleh instans ini.
Hour	Mendapatkan komponen jam dari tanggal yang diwakili oleh instans ini.
Kind	Mendapatkan nilai yang menunjukkan apakah waktu yang diwakili oleh instans ini didasarkan pada waktu lokal, Waktu Universal Terkoordinasi (UTC), atau tidak keduanya.
Microsecond	Komponen microseconds, dinyatakan sebagai nilai antara 0 dan 999.
Millisecond	Mendapatkan komponen milidetik dari tanggal yang diwakili oleh instans ini.
Minute	Mendapatkan komponen menit dari tanggal yang diwakili oleh instans ini.
Month	Mendapatkan komponen bulan dari tanggal yang diwakili oleh instans ini.
Nanosecond	Komponen nanodetik, dinyatakan sebagai nilai antara 0 dan 900 (dengan kenaikan 100 nanodetik).
Now	DateTime Mendapatkan objek yang diatur ke tanggal dan waktu saat ini pada komputer ini, yang dinyatakan sebagai waktu setempat.
Second	Mendapatkan komponen detik dari tanggal yang diwakili oleh instans ini.
Ticks	Mendapatkan jumlah tanda centang yang mewakili tanggal dan waktu instans ini.
TimeOfDay	Mendapatkan waktu untuk instans ini.
Today	Mendapatkan tanggal saat ini.
UtcNow	DateTime Mendapatkan objek yang diatur ke tanggal dan waktu saat ini pada komputer ini, yang dinyatakan sebagai Waktu Universal Terkoordinasi (UTC).
Year	Mendapatkan komponen tahun dari tanggal yang diwakili oleh instans ini.

Metode

Add(TimeSpan)	Mengembalikan baru DateTime yang menambahkan nilai yang ditentukan TimeSpan ke nilai instans ini.
AddDays(Double)	Mengembalikan baru DateTime yang menambahkan jumlah hari yang ditentukan ke nilai instans ini.
AddHours(Double)	Mengembalikan baru DateTime yang menambahkan jumlah jam yang ditentukan ke nilai instans ini.
AddMicroseconds(Double)	Mengembalikan baru DateTime yang menambahkan jumlah mikrostik yang ditentukan ke nilai instans ini.
AddMilliseconds(Double)	Mengembalikan baru DateTime yang menambahkan jumlah milidetik yang ditentukan ke nilai instans ini.
AddMinutes(Double)	Mengembalikan baru DateTime yang menambahkan jumlah menit yang ditentukan ke nilai instans ini.
AddMonths(Int32)	Mengembalikan baru DateTime yang menambahkan jumlah bulan yang ditentukan ke nilai instans ini.
AddSeconds(Double)	Mengembalikan baru DateTime yang menambahkan jumlah detik yang ditentukan ke nilai instans ini.
AddTicks(Int64)	Mengembalikan baru DateTime yang menambahkan jumlah tanda centang yang ditentukan ke nilai instans ini.
AddYears(Int32)	Mengembalikan baru DateTime yang menambahkan jumlah tahun yang ditentukan ke nilai instans ini.
Compare(DateTime, DateTime)	Membandingkan dua instans dan mengembalikan bilangan DateTime bulat yang menunjukkan apakah instans pertama lebih awal dari, sama dengan, atau lebih baru dari instans kedua.
CompareTo(DateTime)	Membandingkan nilai instans ini dengan nilai yang ditentukan DateTime dan mengembalikan bilangan bulat yang menunjukkan apakah instans ini lebih awal dari, sama dengan, atau lebih baru dari nilai yang ditentukan DateTime .
CompareTo(Object)	Membandingkan nilai instans ini dengan objek tertentu yang berisi nilai tertentu DateTime , dan mengembalikan bilangan bulat yang menunjukkan apakah instans ini lebih awal dari, sama dengan, atau lebih baru dari nilai yang ditentukan DateTime .
DaysInMonth(Int32, Int32)	Mengembalikan jumlah hari dalam bulan dan tahun yang ditentukan.
Deconstruct(DateOnly, TimeOnly)	Mendekonstruksi instans ini DateTime dengan DateOnly dan TimeOnly.
Deconstruct(Int32, Int32, Int32)	Mendekonstruksi instans ini DateOnly dengan Year, Month, dan Day.
Equals(DateTime)	Mengembalikan nilai yang menunjukkan apakah nilai instans ini sama dengan nilai instans yang ditentukan DateTime .
Equals(DateTime, DateTime)	Mengembalikan nilai yang menunjukkan apakah dua DateTime instans memiliki nilai tanggal dan waktu yang sama.
Equals(Object)	Mengembalikan nilai yang menunjukkan apakah instans ini sama dengan objek tertentu.
FromBinary(Int64)	Mendeserialisasi nilai biner 64-bit dan membuat ulang objek serial DateTime asli.
FromFileTime(Int64)	Mengonversi waktu file Windows yang ditentukan ke waktu lokal yang setara.
FromFileTimeUtc(Int64)	Mengonversi waktu file Windows yang ditentukan ke waktu UTC yang setara.
FromOADate(Double)	Mengembalikan yang DateTime setara dengan Tanggal Otomatisasi OLE yang ditentukan.
GetDateTimeFormats()	Mengonversi nilai instans ini ke semua representasi string yang didukung oleh penentu format tanggal dan waktu standar.
GetDateTimeFormats(Char)	Mengonversi nilai instans ini ke semua representasi string yang didukung oleh penentu format tanggal dan waktu standar yang ditentukan.
GetDateTimeFormats(Char, IFormatProvider)	Mengonversi nilai instans ini ke semua representasi string yang didukung oleh penentu format tanggal dan waktu standar yang ditentukan dan informasi pemformatan khusus budaya.
GetDateTimeFormats(IFormatProvider)	Mengonversi nilai instans ini ke semua representasi string yang didukung oleh penentu format tanggal dan waktu standar dan informasi pemformatan khusus budaya yang ditentukan.
GetHashCode()	Mengembalikan kode hash untuk instans ini.
GetTypeCode()	Mengembalikan TypeCode untuk jenis DateTimenilai .
IsDaylightSavingTime()	Menunjukkan apakah instans DateTime ini berada dalam rentang waktu musim panas untuk zona waktu saat ini.
IsLeapYear(Int32)	Mengembalikan indikasi apakah tahun yang ditentukan adalah tahun kampung.
Parse(ReadOnlySpan<Char>, IFormatProvider)	Mengurai rentang karakter menjadi nilai.
Parse(ReadOnlySpan<Char>, IFormatProvider, DateTimeStyles)	Mengonversi rentang memori yang berisi representasi string tanggal dan waktu yang DateTime setara dengannya dengan menggunakan informasi format khusus budaya dan gaya pemformatan.
Parse(String)	Mengonversi representasi string tanggal dan waktu menjadi DateTime setara dengan menggunakan konvensi budaya saat ini.
Parse(String, IFormatProvider)	Mengonversi representasi string tanggal dan waktu menjadi DateTime setara dengan menggunakan informasi format khusus budaya.
Parse(String, IFormatProvider, DateTimeStyles)	Mengonversi representasi string tanggal dan waktu menjadi DateTime setara dengan menggunakan informasi format khusus budaya dan gaya pemformatan.
ParseExact(ReadOnlySpan<Char>, ReadOnlySpan<Char>, IFormatProvider, DateTimeStyles)	Mengonversi representasi rentang tanggal dan waktu yang ditentukan menjadi DateTime setara menggunakan format yang ditentukan, informasi format khusus budaya, dan gaya. Format representasi string harus cocok dengan format yang ditentukan dengan tepat atau pengecualian dilemparkan.
ParseExact(ReadOnlySpan<Char>, String[], IFormatProvider, DateTimeStyles)	Mengonversi representasi rentang tanggal dan waktu yang ditentukan menjadi DateTime setara menggunakan array format yang ditentukan, informasi format khusus budaya, dan gaya. Format representasi string harus cocok dengan setidaknya salah satu format yang ditentukan dengan tepat atau pengecualian dilemparkan.
ParseExact(String, String, IFormatProvider)	Mengonversi representasi string yang ditentukan dari tanggal dan waktu ke DateTime yang setara menggunakan format yang ditentukan dan informasi format khusus budaya. Format representasi string harus sama persis dengan format yang ditentukan.
ParseExact(String, String, IFormatProvider, DateTimeStyles)	Mengonversi representasi string yang ditentukan dari tanggal dan waktu ke DateTime yang setara menggunakan format yang ditentukan, informasi format khusus budaya, dan gaya. Format representasi string harus cocok dengan format yang ditentukan dengan tepat atau pengecualian dilemparkan.
ParseExact(String, String[], IFormatProvider, DateTimeStyles)	Mengonversi representasi string yang ditentukan dari tanggal dan waktu ke DateTime yang setara menggunakan array format yang ditentukan, informasi format khusus budaya, dan gaya. Format representasi string harus cocok dengan setidaknya salah satu format yang ditentukan dengan tepat atau pengecualian dilemparkan.
SpecifyKind(DateTime, DateTimeKind)	Membuat objek baru DateTime yang memiliki jumlah tick yang sama dengan yang ditentukan DateTime, tetapi ditetapkan sebagai waktu lokal, Waktu Universal Terkoordinasi (UTC), atau tidak keduanya, seperti yang ditunjukkan oleh nilai yang ditentukan DateTimeKind .
Subtract(DateTime)	Mengembalikan baru TimeSpan yang mengurangi tanggal dan waktu yang ditentukan dari nilai instans ini.
Subtract(TimeSpan)	Mengembalikan baru DateTime yang mengurangi durasi yang ditentukan dari nilai instans ini.
ToBinary()	Menserialisasikan objek saat ini DateTime ke nilai biner 64-bit yang kemudian dapat digunakan untuk membuat DateTime ulang objek.
ToFileTime()	Mengonversi nilai objek saat ini DateTime ke waktu file Windows.
ToFileTimeUtc()	Mengonversi nilai objek saat ini DateTime ke waktu file Windows.
ToLocalTime()	Mengonversi nilai objek saat ini DateTime ke waktu lokal.
ToLongDateString()	Mengonversi nilai objek saat ini DateTime ke representasi string tanggal panjang yang setara.
ToLongTimeString()	Mengonversi nilai objek saat ini DateTime ke representasi string waktu panjang yang setara.
ToOADate()	Mengonversi nilai instans ini ke tanggal Automasi OLE yang setara.
ToShortDateString()	Mengonversi nilai objek saat ini DateTime ke representasi string tanggal pendek yang setara.
ToShortTimeString()	Mengonversi nilai objek saat ini DateTime ke representasi string waktu pendek yang setara.
ToString()	Mengonversi nilai objek saat ini DateTime ke representasi string yang setara menggunakan konvensi pemformatan budaya saat ini.
ToString(IFormatProvider)	Mengonversi nilai objek saat ini DateTime ke representasi string yang setara menggunakan informasi format khusus budaya yang ditentukan.
ToString(String)	Mengonversi nilai objek saat ini DateTime ke representasi string yang setara menggunakan format yang ditentukan dan konvensi pemformatan budaya saat ini.
ToString(String, IFormatProvider)	Mengonversi nilai objek saat ini DateTime ke representasi string yang setara menggunakan format yang ditentukan dan informasi format khusus budaya.
ToUniversalTime()	Mengonversi nilai objek saat ini DateTime menjadi Waktu Universal Terkoordinasi (UTC).
TryFormat(Span<Byte>, Int32, ReadOnlySpan<Char>, IFormatProvider)	Mencoba memformat nilai instans saat ini sebagai UTF-8 ke dalam rentang byte yang disediakan.
TryFormat(Span<Char>, Int32, ReadOnlySpan<Char>, IFormatProvider)	Mencoba memformat nilai instans tanggalwaktu saat ini ke dalam rentang karakter yang disediakan.
TryParse(ReadOnlySpan<Char>, DateTime)	Mengonversi rentang karakter yang ditentukan dari tanggal dan waktu ke DateTime yang setara dan mengembalikan nilai yang menunjukkan apakah konversi berhasil.
TryParse(ReadOnlySpan<Char>, IFormatProvider, DateTime)	Mencoba mengurai rentang karakter menjadi nilai.
TryParse(ReadOnlySpan<Char>, IFormatProvider, DateTimeStyles, DateTime)	Mengonversi representasi rentang tanggal dan waktu ke DateTime yang setara menggunakan informasi format dan gaya pemformatan khusus budaya yang ditentukan, dan mengembalikan nilai yang menunjukkan apakah konversi berhasil.
TryParse(String, DateTime)	Mengonversi representasi string yang ditentukan dari tanggal dan waktu ke DateTime yang setara dan mengembalikan nilai yang menunjukkan apakah konversi berhasil.
TryParse(String, IFormatProvider, DateTime)	Mencoba mengurai string ke dalam nilai.
TryParse(String, IFormatProvider, DateTimeStyles, DateTime)	Mengonversi representasi string yang ditentukan dari tanggal dan waktu ke DateTime yang setara menggunakan informasi format khusus budaya dan gaya pemformatan yang ditentukan, dan mengembalikan nilai yang menunjukkan apakah konversi berhasil.
TryParseExact(ReadOnlySpan<Char>, ReadOnlySpan<Char>, IFormatProvider, DateTimeStyles, DateTime)	Mengonversi representasi rentang tanggal dan waktu yang ditentukan menjadi DateTime setara menggunakan format yang ditentukan, informasi format khusus budaya, dan gaya. Format representasi string harus sama persis dengan format yang ditentukan. Metode mengembalikan nilai yang menunjukkan apakah konversi berhasil.
TryParseExact(ReadOnlySpan<Char>, String[], IFormatProvider, DateTimeStyles, DateTime)	Mengonversi rentang karakter yang ditentukan dari tanggal dan waktu ke DateTime yang setara dan mengembalikan nilai yang menunjukkan apakah konversi berhasil.
TryParseExact(String, String, IFormatProvider, DateTimeStyles, DateTime)	Mengonversi representasi string yang ditentukan dari tanggal dan waktu ke DateTime yang setara menggunakan format yang ditentukan, informasi format khusus budaya, dan gaya. Format representasi string harus sama persis dengan format yang ditentukan. Metode mengembalikan nilai yang menunjukkan apakah konversi berhasil.
TryParseExact(String, String[], IFormatProvider, DateTimeStyles, DateTime)	Mengonversi representasi string yang ditentukan dari tanggal dan waktu ke DateTime yang setara menggunakan array format yang ditentukan, informasi format khusus budaya, dan gaya. Format representasi string harus sama persis dengan setidaknya salah satu format yang ditentukan. Metode mengembalikan nilai yang menunjukkan apakah konversi berhasil.

Operator

Addition(DateTime, TimeSpan)	Menambahkan interval waktu tertentu ke tanggal dan waktu tertentu, menghasilkan tanggal dan waktu baru.
Equality(DateTime, DateTime)	Menentukan apakah dua instans DateTime yang ditentukan sama.
GreaterThan(DateTime, DateTime)	Menentukan apakah salah satu yang ditentukan DateTime lebih baru dari yang ditentukan DateTimelainnya.
GreaterThanOrEqual(DateTime, DateTime)	Menentukan apakah salah satu yang ditentukan DateTime mewakili tanggal dan waktu yang sama dengan atau lebih baru dari yang ditentukan DateTimelainnya.
Inequality(DateTime, DateTime)	Menentukan apakah dua instans DateTime yang ditentukan tidak sama.
LessThan(DateTime, DateTime)	Menentukan apakah satu yang ditentukan DateTime lebih lama dari yang lain yang ditentukan DateTime.
LessThanOrEqual(DateTime, DateTime)	Menentukan apakah salah satu yang ditentukan DateTime mewakili tanggal dan waktu yang sama dengan atau lebih lama dari yang ditentukan DateTimelainnya.
Subtraction(DateTime, DateTime)	Mengurangi tanggal dan waktu tertentu dari tanggal dan waktu tertentu lainnya dan mengembalikan interval waktu.
Subtraction(DateTime, TimeSpan)	Mengurangi interval waktu tertentu dari tanggal dan waktu tertentu dan mengembalikan tanggal dan waktu baru.

Implementasi Antarmuka Eksplisit

IConvertible.ToBoolean(IFormatProvider)	Konversi ini tidak didukung. Mencoba menggunakan metode ini melempar InvalidCastException.
IConvertible.ToByte(IFormatProvider)	Konversi ini tidak didukung. Mencoba menggunakan metode ini melempar InvalidCastException.
IConvertible.ToChar(IFormatProvider)	Konversi ini tidak didukung. Mencoba menggunakan metode ini melempar InvalidCastException.
IConvertible.ToDateTime(IFormatProvider)	Mengembalikan objek saat ini DateTime .
IConvertible.ToDecimal(IFormatProvider)	Konversi ini tidak didukung. Mencoba menggunakan metode ini melempar InvalidCastException.
IConvertible.ToDouble(IFormatProvider)	Konversi ini tidak didukung. Mencoba menggunakan metode ini melempar InvalidCastException.
IConvertible.ToInt16(IFormatProvider)	Konversi ini tidak didukung. Mencoba menggunakan metode ini melempar InvalidCastException.
IConvertible.ToInt32(IFormatProvider)	Konversi ini tidak didukung. Mencoba menggunakan metode ini melempar InvalidCastException.
IConvertible.ToInt64(IFormatProvider)	Konversi ini tidak didukung. Mencoba menggunakan metode ini melempar InvalidCastException.
IConvertible.ToSByte(IFormatProvider)	Konversi ini tidak didukung. Mencoba menggunakan metode ini melempar InvalidCastException.
IConvertible.ToSingle(IFormatProvider)	Konversi ini tidak didukung. Mencoba menggunakan metode ini melempar InvalidCastException.
IConvertible.ToType(Type, IFormatProvider)	Mengonversi objek saat ini DateTime menjadi objek dari tipe yang ditentukan.
IConvertible.ToUInt16(IFormatProvider)	Konversi ini tidak didukung. Mencoba menggunakan metode ini melempar InvalidCastException.
IConvertible.ToUInt32(IFormatProvider)	Konversi ini tidak didukung. Mencoba menggunakan metode ini melempar InvalidCastException.
IConvertible.ToUInt64(IFormatProvider)	Konversi ini tidak didukung. Mencoba menggunakan metode ini melempar InvalidCastException.
ISerializable.GetObjectData(SerializationInfo, StreamingContext)	Mengisi objek dengan data yang SerializationInfo diperlukan untuk menserialisasikan objek saat ini DateTime .

Keamanan Thread

Semua anggota jenis ini aman untuk utas. Anggota yang tampaknya memodifikasi status instans benar-benar mengembalikan instans baru yang diinisialisasi dengan nilai baru. Seperti halnya jenis lain, membaca dan menulis ke variabel bersama yang berisi instans jenis ini harus dilindungi oleh kunci untuk menjamin keamanan utas.

Lihat juga

• DateTimeOffset
• TimeSpan
• Calendar
• GetUtcOffset(DateTime)
• TimeZoneInfo
• Memilih antara DateTime, DateTimeOffset, TimeSpan, dan TimeZoneInfo
• Bekerja dengan Kalender
• Sampel: Utilitas Pemformatan .NET Core WinForms (C#)
• Sampel: Utilitas Pemformatan .NET Core WinForms (Visual Basic)