DateTime.Parse Metode

Referensi

Definisi

Ruang nama:: System

Rakitan:: System.Runtime.dll

Rakitan:: mscorlib.dll

Rakitan:: netstandard.dll

Penting

Beberapa informasi terkait produk prarilis yang dapat diubah secara signifikan sebelum dirilis. Microsoft tidak memberikan jaminan, tersirat maupun tersurat, sehubungan dengan informasi yang diberikan di sini.

Mengonversi representasi string tanggal dan waktu ke DateTime setara.

Overload

Parse(String)	Mengonversi representasi string tanggal dan waktu ke DateTime setara dengan menggunakan konvensi budaya saat ini.
Parse(ReadOnlySpan<Char>, IFormatProvider)	Mengurai rentang karakter menjadi nilai.
Parse(String, IFormatProvider)	Mengonversi representasi string tanggal dan waktu ke DateTime setara dengan menggunakan informasi format khusus budaya.
Parse(ReadOnlySpan<Char>, IFormatProvider, DateTimeStyles)	Mengonversi rentang memori yang berisi representasi string tanggal dan waktu ke DateTime setara dengan menggunakan informasi format khusus budaya dan gaya pemformatan.
Parse(String, IFormatProvider, DateTimeStyles)	Mengonversi representasi string tanggal dan waktu ke DateTime setara dengan menggunakan informasi format khusus budaya dan gaya pemformatan.

Contoh

Banyak contoh yang memanggil metode diselingi di seluruh bagian Keterangan dari artikel ini dan dalam dokumentasi untuk kelebihan beban individu.

Nota

Beberapa contoh C# dalam artikel ini berjalan di runner dan playground kode sebaris Try.NET. Pilih Jalankan untuk menjalankan contoh di jendela interaktif. Setelah 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 pengkompilasi C#.

Zona waktu lokal runner kode sebaris Try.NET dan taman bermain adalah Waktu Universal Terkoordinasi, atau UTC. Ini dapat memengaruhi perilaku dan output contoh yang mengilustrasikan jenis DateTime, DateTimeOffset, dan TimeZoneInfo dan anggotanya.

Anda juga dapat mengunduh serangkaian contoh DateTime.Parse lengkap, yang disertakan dalam proyek .NET Core untuk C#.

Keterangan

Di bagian ini:

Metode mana yang saya panggil?
String yang akan diurai
Konvensi penguraian dan budaya
Penguraian dan elemen gaya
Nilai yang dikembalikan dan DateTime.Kind

Metode mana yang saya panggil?

Ke	Panggil
Uraikan string tanggal dan waktu dengan menggunakan konvensi budaya saat ini.	Parse(String) kelebihan beban
Uraikan string tanggal dan waktu dengan menggunakan konvensi budaya tertentu.	kelebihan beban (lihatPenguraian dan Budaya )
Uraikan string tanggal dan waktu dengan elemen gaya khusus (seperti spasi kosong atau tanpa spasi kosong).	Parse(String, IFormatProvider, DateTimeStyles) kelebihan beban
Mengurai string tanggal dan waktu yang harus dalam format tertentu.	DateTime.ParseExact atau DateTime.TryParseExact
Uraikan string tanggal dan waktu dan lakukan konversi ke UTC atau waktu lokal.	Parse(String, IFormatProvider, DateTimeStyles) kelebihan beban
Mengurai string tanggal dan waktu tanpa menangani pengecualian.	metode DateTime.TryParse
Memulihkan (pulang-pergi) nilai tanggal dan waktu yang dibuat oleh operasi pemformatan.	Teruskan string format standar "o" atau "r" ke metode ToString(String), dan panggil kelebihan beban Parse(String, IFormatProvider, DateTimeStyles) dengan DateTimeStyles.RoundtripKind
Uraikan string tanggal dan waktu dalam format tetap di seluruh batas komputer (dan mungkin budaya).	metode DateTime.ParseExact atau DateTime.TryParseExact

String yang akan diurai

Metode Parse mencoba mengonversi representasi string dari nilai tanggal dan waktu ke DateTime setara. Ini mencoba mengurai string input sepenuhnya tanpa melempar pengecualian FormatException.

Penting

Jika operasi penguraian gagal karena format string yang tidak dikenali, metode Parse melemparkan FormatException, sedangkan metode TryParse mengembalikan false. Karena penanganan pengecualian bisa mahal, Anda harus menggunakan Parse ketika operasi penguraian diharapkan berhasil karena sumber input tepercaya. TryParse lebih disukai ketika kegagalan penguraian kemungkinan besar, terutama karena sumber input tidak tepercaya, atau Anda memiliki nilai default yang wajar untuk mengganti string yang tidak berhasil diurai.

String yang akan diurai dapat mengambil salah satu formulir berikut:

String dengan komponen tanggal dan waktu.
String dengan komponen tanggal tetapi tidak ada waktu. Jika komponen waktu tidak ada, metode mengasumsikan 12:00 tengah malam. Jika komponen tanggal memiliki tahun dua digit, komponen tersebut dikonversi ke tahun berdasarkan Calendar.TwoDigitYearMax kalender budaya saat ini atau kalender budaya yang ditentukan saat ini (jika Anda menggunakan kelebihan beban dengan argumen provider non-null).
String dengan komponen tanggal yang hanya menyertakan bulan dan tahun tetapi tidak ada komponen hari. Metode ini mengasumsikan hari pertama dalam sebulan.
String dengan komponen tanggal yang hanya menyertakan bulan dan hari tetapi tidak ada komponen tahun. Metode ini mengasumsikan tahun ini.
String dengan komponen waktu tetapi tidak ada tanggal. Metode ini mengasumsikan tanggal saat ini kecuali Anda memanggil kelebihan Parse(String, IFormatProvider, DateTimeStyles) dan menyertakan DateTimeStyles.NoCurrentDateDefault dalam argumen styles, dalam hal ini metode mengasumsikan tanggal 1 Januari 0001.
String dengan komponen waktu yang hanya menyertakan jam dan penunjuk AM/PM, tanpa komponen tanggal. Metode ini mengasumsikan tanggal dan waktu saat ini tanpa menit dan tanpa detik. Anda dapat mengubah perilaku ini dengan memanggil kelebihan beban Parse(String, IFormatProvider, DateTimeStyles) dan menyertakan DateTimeStyles.NoCurrentDateDefault dalam argumen styles, dalam hal ini metode mengasumsikan tanggal 1 Januari 0001.
String yang menyertakan informasi zona waktu dan sesuai dengan ISO 8601. Dalam contoh berikut, string pertama menunjuk Waktu Universal Terkoordinasi (UTC), dan yang kedua menunjuk waktu dalam zona waktu yang tujuh jam lebih awal dari UTC:

"2008-11-01T19:35:00.0000000Z" "2008-11-01T19:35:00.0000000-07:00"
String yang mencakup perancang GMT dan sesuai dengan format waktu RFC 1123; misalnya:

"Sat, 01 Nov 2008 19:35:00 GMT"
String yang menyertakan tanggal dan waktu bersama dengan informasi offset zona waktu; misalnya:

"03/01/2009 05:42:00 -5:00"

Contoh berikut menguraikan string dalam setiap format ini dengan menggunakan konvensi pemformatan budaya saat ini, yang dalam hal ini adalah budaya en-US:

using System;

public class Example
{
   public static void Main()
   {
      (string dateAsString, string description)[]  dateInfo = { ("08/18/2018 07:22:16", "String with a date and time component"),
                                                                ("08/18/2018", "String with a date component only"),
                                                                ("8/2018", "String with a month and year component only"),
                                                                ("8/18", "String with a month and day component only"),
                                                                ("07:22:16", "String with a time component only"),
                                                                ("7 PM", "String with an hour and AM/PM designator only"),
                                                                ("2018-08-18T07:22:16.0000000Z", "UTC string that conforms to ISO 8601"),
                                                                ("2018-08-18T07:22:16.0000000-07:00", "Non-UTC string that conforms to ISO 8601"),
                                                                ("Sat, 18 Aug 2018 07:22:16 GMT", "String that conforms to RFC 1123"),
                                                                ("08/18/2018 07:22:16 -5:00", "String with date, time, and time zone information" ) };

      Console.WriteLine($"Today is {DateTime.Now:d}\n");

      foreach (var item in dateInfo) {
         Console.WriteLine($"{item.description + ":",-52} '{item.dateAsString}' --> {DateTime.Parse(item.dateAsString)}");
      }
   }
}
// The example displays output like the following:
//   Today is 2/22/2018
//
//   String with a date and time component:               '08/18/2018 07:22:16' --> 8/18/2018 7:22:16 AM
//   String with a date component only:                   '08/18/2018' --> 8/18/2018 12:00:00 AM
//   String with a month and year component only:         '8/2018' --> 8/1/2018 12:00:00 AM
//   String with a month and day component only:          '8/18' --> 8/18/2018 12:00:00 AM
//   String with a time component only:                   '07:22:16' --> 2/22/2018 7:22:16 AM
//   String with an hour and AM/PM designator only:       '7 PM' --> 2/22/2018 7:00:00 PM
//   UTC string that conforms to ISO 8601:                '2018-08-18T07:22:16.0000000Z' --> 8/18/2018 12:22:16 AM
//   Non-UTC string that conforms to ISO 8601:            '2018-08-18T07:22:16.0000000-07:00' --> 8/18/2018 7:22:16 AM
//   String that conforms to RFC 1123:                    'Sat, 18 Aug 2018 07:22:16 GMT' --> 8/18/2018 12:22:16 AM
//   String with date, time, and time zone information:   '08/18/2018 07:22:16 -5:00' --> 8/18/2018 5:22:16 AM

module Parse6

open System

let  dateInfo = 
    [ "08/18/2018 07:22:16", "String with a date and time component"
      "08/18/2018", "String with a date component only"
      "8/2018", "String with a month and year component only"
      "8/18", "String with a month and day component only"
      "07:22:16", "String with a time component only"
      "7 PM", "String with an hour and AM/PM designator only"
      "2018-08-18T07:22:16.0000000Z", "UTC string that conforms to ISO 8601"
      "2018-08-18T07:22:16.0000000-07:00", "Non-UTC string that conforms to ISO 8601"
      "Sat, 18 Aug 2018 07:22:16 GMT", "String that conforms to RFC 1123"
      "08/18/2018 07:22:16 -5:00", "String with date, time, and time zone information" ]

printfn $"Today is {DateTime.Now:d}\n"

for dateAsString, description in dateInfo do
    printfn $"""{description + ":",-52} '{dateAsString}' --> {DateTime.Parse(dateAsString)}"""


// The example displays output like the following:
//   Today is 2/22/2018
//
//   String with a date and time component:               '08/18/2018 07:22:16' --> 8/18/2018 7:22:16 AM
//   String with a date component only:                   '08/18/2018' --> 8/18/2018 12:00:00 AM
//   String with a month and year component only:         '8/2018' --> 8/1/2018 12:00:00 AM
//   String with a month and day component only:          '8/18' --> 8/18/2018 12:00:00 AM
//   String with a time component only:                   '07:22:16' --> 2/22/2018 7:22:16 AM
//   String with an hour and AM/PM designator only:       '7 PM' --> 2/22/2018 7:00:00 PM
//   UTC string that conforms to ISO 8601:                '2018-08-18T07:22:16.0000000Z' --> 8/18/2018 12:22:16 AM
//   Non-UTC string that conforms to ISO 8601:            '2018-08-18T07:22:16.0000000-07:00' --> 8/18/2018 7:22:16 AM
//   String that conforms to RFC 1123:                    'Sat, 18 Aug 2018 07:22:16 GMT' --> 8/18/2018 12:22:16 AM
//   String with date, time, and time zone information:   '08/18/2018 07:22:16 -5:00' --> 8/18/2018 5:22:16 AM


Public Module Strings
   Public Sub Main()
      Dim dateInfo() As (dateAsString As String, description As String) = 
                     { ("08/18/2018 07:22:16", "String with a date and time component"),
                       ("08/18/2018", "String with a date component only"),
                       ("8/2018", "String with a month and year component only"),
                       ("8/18", "String with a month and day component only"),
                       ("07:22:16", "String with a time component only"),
                       ("7 PM", "String with an hour and AM/PM designator only"),
                       ("2018-08-18T07:22:16.0000000Z", "UTC string that conforms to ISO 8601"),   
                       ("2018-08-18T07:22:16.0000000-07:00", "Non-UTC string that conforms to ISO 8601"),
                       ("Sat, 18 Aug 2018 07:22:16 GMT", "String that conforms to RFC 1123"),
                       ("08/18/2018 07:22:16 -5:00", "String with date, time, and time zone information" ) }
   
      Console.WriteLine($"Today is {Date.Now:d}{vbCrLf}")
      
      For Each item in dateInfo
         Console.WriteLine($"{item.description + ":",-52} '{item.dateAsString}' --> {DateTime.Parse(item.dateAsString)}")        
      Next
   End Sub
End Module
' The example displays output like the following:
'   Today is 2/22/2018
'   
'   String with a date and time component:               '08/18/2018 07:22:16' --> 8/18/2018 7:22:16 AM
'   String with a date component only:                   '08/18/2018' --> 8/18/2018 12:00:00 AM
'   String with a month and year component only:         '8/2018' --> 8/1/2018 12:00:00 AM
'   String with a month and day component only:          '8/18' --> 8/18/2018 12:00:00 AM
'   String with a time component only:                   '07:22:16' --> 2/22/2018 7:22:16 AM
'   String with an hour and AM/PM designator only:       '7 PM' --> 2/22/2018 7:00:00 PM
'   UTC string that conforms to ISO 8601:                '2018-08-18T07:22:16.0000000Z' --> 8/18/2018 12:22:16 AM
'   Non-UTC string that conforms to ISO 8601:            '2018-08-18T07:22:16.0000000-07:00' --> 8/18/2018 7:22:16 AM
'   String that conforms to RFC 1123:                    'Sat, 18 Aug 2018 07:22:16 GMT' --> 8/18/2018 12:22:16 AM
'   String with date, time, and time zone information:   '08/18/2018 07:22:16 -5:00' --> 8/18/2018 5:22:16 AM

Jika string input mewakili hari kabisat dalam tahun kabisat dalam kalender yang digunakan oleh metode penguraian (lihat Penguraian dan konvensi budaya), metode Parse berhasil mengurai string. Jika string input mewakili hari kabisat dalam tahun non-lompatan, metode akan melemparkan FormatException.

Karena metode Parse mencoba mengurai representasi string tanggal dan waktu dengan menggunakan aturan pemformatan budaya saat ini atau yang ditentukan, mencoba mengurai string di berbagai budaya dapat gagal. Untuk mengurai format tanggal dan waktu tertentu di berbagai lokal, gunakan salah satu kelebihan beban metode DateTime.ParseExact dan berikan penentu format.

Konvensi penguraian dan budaya

Semua kelebihan beban metode Parse peka terhadap budaya kecuali string yang akan diurai (yang diwakili oleh s dalam tabel berikut) sesuai dengan pola ISO 8601. Operasi penguraian menggunakan informasi pemformatan dalam objek DateTimeFormatInfo yang diturunkan sebagai berikut:

Penting

Era dalam kalender Jepang didasarkan pada pemerintahan kaisar dan oleh karena itu diharapkan untuk berubah. Misalnya, 1 Mei 2019 menandai awal era Reiwa di JapaneseCalendar dan JapaneseLunisolarCalendar. Perubahan era seperti itu memengaruhi 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 kesiapan mereka 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.

Jika Anda menelepon	Dan `provider` adalah	Informasi pemformatan berasal dari
Parse(String)	-	Budaya saat ini ( propertiDateTimeFormatInfo.CurrentInfo)
Parse(String, IFormatProvider) atau Parse(String, IFormatProvider, DateTimeStyles)	objek DateTimeFormatInfo	Objek DateTimeFormatInfo yang ditentukan
Parse(String, IFormatProvider) atau Parse(String, IFormatProvider, DateTimeStyles)	`null`	Budaya saat ini ( propertiDateTimeFormatInfo.CurrentInfo)
Parse(String, IFormatProvider) atau Parse(String, IFormatProvider, DateTimeStyles)	objek CultureInfo	Properti CultureInfo.DateTimeFormat
Parse(String, IFormatProvider) atau Parse(String, IFormatProvider, DateTimeStyles)	Implementasi IFormatProvider kustom	Metode IFormatProvider.GetFormat

Saat informasi pemformatan berasal dari objek DateTimeFormatInfo, properti DateTimeFormatInfo.Calendar menentukan kalender yang digunakan dalam operasi penguraian.

Jika Anda mengurai string tanggal dan waktu dengan menggunakan objek DateTimeFormatInfo dengan pengaturan yang disesuaikan yang berbeda dari budaya standar, gunakan metode ParseExact alih-alih metode Parse untuk meningkatkan peluang keberhasilan konversi. String tanggal dan waktu non-standar dapat rumit dan sulit diurai. Metode Parse mencoba mengurai string dengan beberapa pola penguraian implisit, yang semuanya mungkin gagal. Sebaliknya, metode ParseExact mengharuskan Anda untuk secara eksplisit menunjuk satu atau beberapa pola penguraian yang tepat yang kemungkinan akan berhasil. Untuk informasi selengkapnya, lihat bagian "DateTimeFormatInfo dan Data Dinamis" di topik DateTimeFormatInfo.

Penting

Perhatikan bahwa konvensi pemformatan untuk budaya tertentu bersifat dinamis dan dapat berubah. Ini berarti bahwa operasi penguraian yang bergantung pada konvensi pemformatan budaya default (saat ini) atau yang menentukan objek IFormatProvider yang mewakili budaya selain budaya invarian dapat secara tiba-tiba gagal jika salah satu hal berikut terjadi:

Data khusus budaya telah berubah antara versi utama atau minor dari .NET Framework atau sebagai hasil dari pembaruan ke versi .NET Framework yang ada.
Data khusus budaya mencerminkan preferensi pengguna, yang dapat bervariasi dari komputer ke mesin atau sesi ke sesi.
Data khusus budaya mewakili budaya pengganti yang mengambil alih pengaturan budaya standar atau budaya kustom.

Untuk mencegah kesulitan dalam mengurai data dan string waktu yang terkait dengan perubahan data budaya, Anda dapat mengurai string tanggal dan waktu dengan menggunakan budaya invarian, atau Anda dapat memanggil metode ParseExact atau TryParseExact dan menentukan format string yang tepat untuk diurai. Jika Anda menserialisasikan dan mendeserialisasi data tanggal dan waktu, Anda dapat menggunakan konvensi pemformatan budaya yang invarian, atau Anda dapat menserialisasikan dan mendeserialisasi nilai DateTime dalam format biner.

Untuk informasi selengkapnya, lihat bagian "Data budaya dinamis" di topik CultureInfo dan bagian "Nilai DateTime bertahan" di topik DateTime.

Elemen penguraian dan gaya

Semua Parse kelebihan beban mengabaikan karakter spasi putih awal, dalam, atau akhir dalam string input (yang diwakili oleh s dalam tabel berikut). Tanggal dan waktu dapat dikurung dengan sepasang karakter TANDA ANGKA di depan dan berikutnya ("#", U+0023), dan dapat dibuntuti dengan satu atau beberapa karakter NULL (U+0000).

Selain itu, kelebihan Parse(String, IFormatProvider, DateTimeStyles) memiliki parameter styles yang terdiri dari satu atau beberapa anggota enumerasi DateTimeStyles. Parameter ini menentukan bagaimana s harus ditafsirkan dan bagaimana operasi penguraian harus mengonversi s ke tanggal dan waktu. Tabel berikut ini menjelaskan efek setiap anggota DateTimeStyles pada operasi penguraian.

Anggota DateTimeStyles	Pengaruh pada konversi
AdjustToUniversal	Mengurai `s` dan, jika perlu, mengonversinya ke UTC, sebagai berikut: - Jika `s` menyertakan offset zona waktu, atau jika `s` tidak berisi informasi zona waktu tetapi `styles` menyertakan bendera AssumeLocal, metode mengurai string, memanggil ToUniversalTime untuk mengonversi nilai DateTime yang dikembalikan ke UTC, dan mengatur properti Kind ke DateTimeKind.Utc. - Jika `s` menunjukkan bahwa itu mewakili UTC, atau jika `s` tidak berisi informasi zona waktu tetapi `styles` menyertakan bendera AssumeUniversal, metode mengurai string, tidak melakukan konversi zona waktu pada nilai DateTime yang dikembalikan, dan mengatur properti Kind ke DateTimeKind.Utc. - Dalam semua kasus lain, bendera tidak berpengaruh.
AllowInnerWhite	Nilai ini diabaikan. Spasi putih dalam selalu diizinkan dalam elemen tanggal dan waktu `s`.
AllowLeadingWhite	Nilai ini diabaikan. Spasi putih di depan selalu diizinkan dalam elemen tanggal dan waktu `s`.
AllowTrailingWhite	Nilai ini diabaikan. Spasi putih berikutnya selalu diizinkan dalam elemen tanggal dan waktu `s`.
AllowWhiteSpaces	Menentukan bahwa `s` mungkin berisi spasi putih di depan, dalam, dan belakang. Ini adalah perilaku default. Ini tidak dapat ditimpa dengan menyediakan nilai enumerasi DateTimeStyles yang lebih ketat seperti None.
AssumeLocal	Menentukan bahwa jika `s` tidak memiliki informasi zona waktu, waktu lokal diasumsikan. Kecuali bendera AdjustToUniversal ada, properti Kind dari nilai DateTime yang dikembalikan diatur ke DateTimeKind.Local.
AssumeUniversal	Menentukan bahwa jika `s` tidak memiliki informasi zona waktu, UTC diasumsikan. Kecuali bendera AdjustToUniversal ada, metode mengonversi nilai DateTime yang dikembalikan dari UTC ke waktu lokal dan mengatur properti Kind ke DateTimeKind.Local.
None	Meskipun valid, nilai ini diabaikan.
RoundtripKind	Untuk string yang berisi informasi zona waktu, mencoba mencegah konversi string tanggal dan waktu ke nilai DateTime yang mewakili waktu lokal dengan properti Kind diatur ke DateTimeKind.Local. Biasanya, string seperti itu dibuat dengan memanggil metode DateTime.ToString(String) dan dengan menggunakan penentu format standar "o", "r", atau "u".

Nilai yang dikembalikan dan DateTime.Kind

Kelebihan DateTime.Parse mengembalikan nilai DateTime yang properti Kind nya menyertakan informasi zona waktu. Ini dapat menunjukkan bahwa waktunya adalah:

Waktu Universal Terkoordinasi (System.DateTimeKind.Utc).
Waktu di zona waktu lokal (System.DateTimeKind.Local).
Waktu dalam zona waktu yang tidak diketahui (System.DateTimeKind.Unspecified).

Umumnya, metode Parse mengembalikan objek DateTime yang properti Kind-nya DateTimeKind.Unspecified. Namun, metode Parse juga dapat melakukan konversi zona waktu dan menetapkan nilai properti Kind secara berbeda, tergantung pada nilai parameter s dan styles:

Kalau	Konversi zona waktu	Properti jenis
`s` berisi informasi zona waktu.	Tanggal dan waktu dikonversi ke waktu di zona waktu lokal.	DateTimeKind.Local
`s` berisi informasi zona waktu, dan `styles` menyertakan bendera AdjustToUniversal.	Tanggal dan waktu dikonversi ke Waktu Universal Terkoordinasi (UTC).	DateTimeKind.Utc
`s` berisi perancang zona waktu Z atau GMT, dan `styles` menyertakan bendera RoundtripKind.	Tanggal dan waktu ditafsirkan sebagai UTC.	DateTimeKind.Utc

Contoh berikut mengonversi string tanggal yang berisi informasi zona waktu ke waktu di zona waktu lokal:

using System;

public class Example
{
   public static void Main()
   {
      string[] dateStrings = {"2008-05-01T07:34:42-5:00",
                              "2008-05-01 7:34:42Z",
                              "Thu, 01 May 2008 07:34:42 GMT"};
      foreach (string dateString in dateStrings)
      {
         DateTime convertedDate = DateTime.Parse(dateString);
         Console.WriteLine($"Converted {dateString} to {convertedDate.Kind} time {convertedDate}");
      }
   }
}
// These calls to the DateTime.Parse method display the following output:
//  Converted 2008-05-01T07:34:42-5:00 to Local time 5/1/2008 5:34:42 AM
//  Converted 2008-05-01 7:34:42Z to Local time 5/1/2008 12:34:42 AM
//  Converted Thu, 01 May 2008 07:34:42 GMT to Local time 5/1/2008 12:34:42 AM

open System

let dateStrings = 
    [ "2008-05-01T07:34:42-5:00"
      "2008-05-01 7:34:42Z"
      "Thu, 01 May 2008 07:34:42 GMT" ]

for dateString in dateStrings do
    let convertedDate = DateTime.Parse dateString
    printfn $"Converted {dateString} to {convertedDate.Kind} time {convertedDate}"

// These calls to the DateTime.Parse method display the following output:
//  Converted 2008-05-01T07:34:42-5:00 to Local time 5/1/2008 5:34:42 AM
//  Converted 2008-05-01 7:34:42Z to Local time 5/1/2008 12:34:42 AM
//  Converted Thu, 01 May 2008 07:34:42 GMT to Local time 5/1/2008 12:34:42 AM

Module Example
   Public Sub Main()
      Dim dateStrings() As String = {"2008-05-01T07:34:42-5:00", 
                                     "2008-05-01 7:34:42Z", 
                                     "Thu, 01 May 2008 07:34:42 GMT"}
      
      For Each dateStr In dateStrings
         Dim convertedDate As Date = Date.Parse(dateStr)
         Console.WriteLine($"Converted {dateStr} to {convertedDate.Kind} time {convertedDate}")
      Next 
   End Sub
End Module
' These calls to the DateTime.Parse method display the following output:
'   Converted 2008-05-01T07:34:42-5:00 to Local time 5/1/2008 5:34:42 AM
'   Converted 2008-05-01 7:34:42Z to Local time 5/1/2008 12:34:42 AM
'   Converted Thu, 01 May 2008 07:34:42 GMT to Local time 5/1/2008 12:34:42 AM

Anda juga dapat mempertahankan nilai properti Kind tanggal dan waktu selama operasi pemformatan dan penguraian dengan menggunakan bendera DateTimeStyles.RoundtripKind. Contoh berikut menggambarkan bagaimana bendera RoundtripKind memengaruhi operasi penguraian pada nilai DateTime yang dikonversi ke string dengan menggunakan penentu format "o", "r", atau "u".

   string[] formattedDates = { "2008-09-15T09:30:41.7752486-07:00",
                               "2008-09-15T09:30:41.7752486Z",
                               "2008-09-15T09:30:41.7752486",
                               "2008-09-15T09:30:41.7752486-04:00",
                               "Mon, 15 Sep 2008 09:30:41 GMT" };
   foreach (string formattedDate in formattedDates)
   {
      Console.WriteLine(formattedDate);
      DateTime roundtripDate = DateTime.Parse(formattedDate, null,
                                              DateTimeStyles.RoundtripKind);
      Console.WriteLine($"   With RoundtripKind flag: {roundtripDate} {roundtripDate.Kind} time.");

      DateTime noRoundtripDate = DateTime.Parse(formattedDate, null,
                                                DateTimeStyles.None);
      Console.WriteLine($"   Without RoundtripKind flag: {noRoundtripDate} {noRoundtripDate.Kind} time.");
   }
// The example displays the following output:
//       2008-09-15T09:30:41.7752486-07:00
//          With RoundtripKind flag: 9/15/2008 9:30:41 AM Local time.
//          Without RoundtripKind flag: 9/15/2008 9:30:41 AM Local time.
//       2008-09-15T09:30:41.7752486Z
//          With RoundtripKind flag: 9/15/2008 9:30:41 AM Utc time.
//          Without RoundtripKind flag: 9/15/2008 2:30:41 AM Local time.
//       2008-09-15T09:30:41.7752486
//          With RoundtripKind flag: 9/15/2008 9:30:41 AM Unspecified time.
//          Without RoundtripKind flag: 9/15/2008 9:30:41 AM Unspecified time.
//       2008-09-15T09:30:41.7752486-04:00
//          With RoundtripKind flag: 9/15/2008 6:30:41 AM Local time.
//          Without RoundtripKind flag: 9/15/2008 6:30:41 AM Local time.
//       Mon, 15 Sep 2008 09:30:41 GMT
//          With RoundtripKind flag: 9/15/2008 9:30:41 AM Utc time.
//          Without RoundtripKind flag: 9/15/2008 2:30:41 AM Local time.

let formattedDates = 
    [ "2008-09-15T09:30:41.7752486-07:00"
      "2008-09-15T09:30:41.7752486Z"
      "2008-09-15T09:30:41.7752486"
      "2008-09-15T09:30:41.7752486-04:00"
      "Mon, 15 Sep 2008 09:30:41 GMT" ]

for formattedDate in formattedDates do
    printfn $"{formattedDate}"
    let roundtripDate = DateTime.Parse(formattedDate, null, DateTimeStyles.RoundtripKind)
    printfn $"   With RoundtripKind flag: {roundtripDate} {roundtripDate.Kind} time."

    let noRoundtripDate = DateTime.Parse(formattedDate, null, DateTimeStyles.None)
    printfn $"   Without RoundtripKind flag: {noRoundtripDate} {noRoundtripDate.Kind} time."

// The example displays the following output:
//       2008-09-15T09:30:41.7752486-07:00
//          With RoundtripKind flag: 9/15/2008 9:30:41 AM Local time.
//          Without RoundtripKind flag: 9/15/2008 9:30:41 AM Local time.
//       2008-09-15T09:30:41.7752486Z
//          With RoundtripKind flag: 9/15/2008 9:30:41 AM Utc time.
//          Without RoundtripKind flag: 9/15/2008 2:30:41 AM Local time.
//       2008-09-15T09:30:41.7752486
//          With RoundtripKind flag: 9/15/2008 9:30:41 AM Unspecified time.
//          Without RoundtripKind flag: 9/15/2008 9:30:41 AM Unspecified time.
//       2008-09-15T09:30:41.7752486-04:00
//          With RoundtripKind flag: 9/15/2008 6:30:41 AM Local time.
//          Without RoundtripKind flag: 9/15/2008 6:30:41 AM Local time.
//       Mon, 15 Sep 2008 09:30:41 GMT
//          With RoundtripKind flag: 9/15/2008 9:30:41 AM Utc time.
//          Without RoundtripKind flag: 9/15/2008 2:30:41 AM Local time.

Dim formattedDates() = { "2008-09-15T09:30:41.7752486-07:00", 
                           "2008-09-15T09:30:41.7752486Z",  
                           "2008-09-15T09:30:41.7752486",  
                           "2008-09-15T09:30:41.7752486-04:00", 
                           "Mon, 15 Sep 2008 09:30:41 GMT" }
For Each formattedDate In formattedDates
   Console.WriteLine(formattedDate)
   Dim roundtripDate = DateTime.Parse(formattedDate, Nothing,  
                                      DateTimeStyles.RoundtripKind)                        
   Console.WriteLine($"   With RoundtripKind flag: {roundtripDate} {roundtripDate.Kind} time.")                                          
   Dim noRoundtripDate = DateTime.Parse(formattedDate, Nothing,                                                                                                  DateTimeStyles.None)
   Console.WriteLine($"   Without RoundtripKind flag: {noRoundtripDate} {noRoundtripDate.Kind} time.")
Next         
' The example displays the following output:
'       2008-09-15T09:30:41.7752486-07:00
'          With RoundtripKind flag: 9/15/2008 9:30:41 AM Local time.
'          Without RoundtripKind flag: 9/15/2008 9:30:41 AM Local time.
'       2008-09-15T09:30:41.7752486Z
'          With RoundtripKind flag: 9/15/2008 9:30:41 AM Utc time.
'          Without RoundtripKind flag: 9/15/2008 2:30:41 AM Local time.
'       2008-09-15T09:30:41.7752486
'          With RoundtripKind flag: 9/15/2008 9:30:41 AM Unspecified time.
'          Without RoundtripKind flag: 9/15/2008 9:30:41 AM Unspecified time.
'       2008-09-15T09:30:41.7752486-04:00
'          With RoundtripKind flag: 9/15/2008 6:30:41 AM Local time.
'          Without RoundtripKind flag: 9/15/2008 6:30:41 AM Local time.
'       Mon, 15 Sep 2008 09:30:41 GMT
'          With RoundtripKind flag: 9/15/2008 9:30:41 AM Utc time.
'          Without RoundtripKind flag: 9/15/2008 2:30:41 AM Local time.

Parse(String)

Sumber:: DateTime.cs

Sumber:: DateTime.cs

Sumber:: DateTime.cs

Mengonversi representasi string tanggal dan waktu ke DateTime setara dengan menggunakan konvensi budaya saat ini.

public:
 static DateTime Parse(System::String ^ s);

public static DateTime Parse (string s);

static member Parse : string -> DateTime

Public Shared Function Parse (s As String) As DateTime

Parameter

s: String

String yang berisi tanggal dan waktu untuk dikonversi. Lihat String untuk mengurai untuk informasi selengkapnya.

Mengembalikan

DateTime

Objek yang setara dengan tanggal dan waktu yang terkandung dalam s.

Pengecualian

ArgumentNullException

s null.

FormatException

s tidak berisi representasi string yang valid dari tanggal dan waktu.

Contoh

Contoh berikut menguraikan representasi string dari beberapa nilai tanggal dan waktu dengan:

Menggunakan penyedia format default, yang menyediakan konvensi pemformatan dari budaya komputer saat ini yang digunakan untuk menghasilkan contoh output. Output dari contoh ini mencerminkan konvensi pemformatan budaya en-US.
Menggunakan nilai gaya default, yaitu AllowWhiteSpaces.

Ini menangani pengecualian FormatException yang dilemparkan ketika metode mencoba mengurai representasi string tanggal dan waktu dengan menggunakan beberapa konvensi pemformatan budaya lainnya. Ini juga menunjukkan cara berhasil mengurai nilai tanggal dan waktu yang tidak menggunakan konvensi pemformatan budaya saat ini.

using System;
using System.Globalization;

public class DateTimeParser
{
   public static void Main()
   {
      // Assume the current culture is en-US.
      // The date is February 16, 2008, 12 hours, 15 minutes and 12 seconds.

      // Use standard en-US date and time value
      DateTime dateValue;
      string dateString = "2/16/2008 12:15:12 PM";
      try {
         dateValue = DateTime.Parse(dateString);
         Console.WriteLine("'{0}' converted to {1}.", dateString, dateValue);
      }
      catch (FormatException) {
         Console.WriteLine("Unable to convert '{0}'.", dateString);
      }

      // Reverse month and day to conform to the fr-FR culture.
      // The date is February 16, 2008, 12 hours, 15 minutes and 12 seconds.
      dateString = "16/02/2008 12:15:12";
      try {
         dateValue = DateTime.Parse(dateString);
         Console.WriteLine("'{0}' converted to {1}.", dateString, dateValue);
      }
      catch (FormatException) {
         Console.WriteLine("Unable to convert '{0}'.", dateString);
      }

      // Call another overload of Parse to successfully convert string
      // formatted according to conventions of fr-FR culture.
      try {
         dateValue = DateTime.Parse(dateString, new CultureInfo("fr-FR", false));
         Console.WriteLine("'{0}' converted to {1}.", dateString, dateValue);
      }
      catch (FormatException) {
         Console.WriteLine("Unable to convert '{0}'.", dateString);
      }

      // Parse string with date but no time component.
      dateString = "2/16/2008";
      try {
         dateValue = DateTime.Parse(dateString);
         Console.WriteLine("'{0}' converted to {1}.", dateString, dateValue);
      }
      catch (FormatException) {
         Console.WriteLine("Unable to convert '{0}'.", dateString);
      }
   }
}
// The example displays the following output to the console:
//       '2/16/2008 12:15:12 PM' converted to 2/16/2008 12:15:12 PM.
//       Unable to convert '16/02/2008 12:15:12'.
//       '16/02/2008 12:15:12' converted to 2/16/2008 12:15:12 PM.
//       '2/16/2008' converted to 2/16/2008 12:00:00 AM.

open System
open System.Globalization

[<EntryPoint>]
let main _ =
    // Assume the current culture is en-US.
    // The date is February 16, 2008, 12 hours, 15 minutes and 12 seconds.

    // Use standard en-US date and time value
    let dateString = "2/16/2008 12:15:12 PM"
    try
        let dateValue = DateTime.Parse dateString
        printfn $"'{dateString}' converted to {dateValue}."
    with :? FormatException ->
        printfn $"Unable to convert '{dateString}'."

    // Reverse month and day to conform to the fr-FR culture.
    // The date is February 16, 2008, 12 hours, 15 minutes and 12 seconds.
    let dateString = "16/02/2008 12:15:12"
    try
        let dateValue = DateTime.Parse dateString
        printfn $"'{dateString}' converted to {dateValue}."
    with :? FormatException ->
        Console.WriteLine("Unable to convert '{0}'.", dateString)

    // Call another overload of Parse to successfully convert string
    // formatted according to conventions of fr-FR culture.
    try
        let dateValue = DateTime.Parse(dateString, CultureInfo("fr-FR", false))
        printfn $"'{dateString}' converted to {dateValue}."
    with :? FormatException ->
        printfn $"Unable to convert '{dateString}'."

    // Parse string with date but no time component.
    let dateString = "2/16/2008"
    try
        let dateValue = DateTime.Parse dateString
        printfn $"'{dateString}' converted to {dateValue}."
    with :? FormatException ->
        printfn $"Unable to convert '{dateString}'."

    0

// The example displays the following output to the console:
//       '2/16/2008 12:15:12 PM' converted to 2/16/2008 12:15:12 PM.
//       Unable to convert '16/02/2008 12:15:12'.
//       '16/02/2008 12:15:12' converted to 2/16/2008 12:15:12 PM.
//       '2/16/2008' converted to 2/16/2008 12:00:00 AM.

Imports System.Globalization

Class DateTimeParser
   Public Shared Sub Main()
      ' Assume the current culture is en-US. 
      ' The date is February 16, 2008, 12 hours, 15 minutes and 12 seconds.

      ' Use standard en-US date and time value
      Dim dateValue As Date
      Dim dateString As String = "2/16/2008 12:15:12 PM"
      Try
         dateValue = Date.Parse(dateString)
         Console.WriteLine("'{0}' converted to {1}.", dateString, dateValue)
      Catch e As FormatException
         Console.WriteLine("Unable to convert '{0}'.", dateString)
      End Try
            
      ' Reverse month and day to conform to the fr-FR culture.
      ' The date is February 16, 2008, 12 hours, 15 minutes and 12 seconds.
      dateString = "16/02/2008 12:15:12"
      Try
         dateValue = Date.Parse(dateString)
         Console.WriteLine("'{0}' converted to {1}.", dateString, dateValue)
      Catch e As FormatException
         Console.WriteLine("Unable to convert '{0}'.", dateString)
      End Try

      ' Call another overload of Parse to successfully convert string
      ' formatted according to conventions of fr-FR culture.      
      Try
         dateValue = Date.Parse(dateString, New CultureInfo("fr-FR", False))
         Console.WriteLine("'{0}' converted to {1}.", dateString, dateValue)
      Catch e As FormatException
         Console.WriteLine("Unable to convert '{0}'.", dateString)
      End Try
      
      ' Parse string with date but no time component.
      dateString = "2/16/2008"
      Try
         dateValue = Date.Parse(dateString)
         Console.WriteLine("'{0}' converted to {1}.", dateString, dateValue)
      Catch e As FormatException
         Console.WriteLine("Unable to convert '{0}'.", dateString)
      End Try
   End Sub 
End Class 
' The example displays the following output to the console:
'       '2/16/2008 12:15:12 PM' converted to 2/16/2008 12:15:12 PM.
'       Unable to convert '16/02/2008 12:15:12'.
'       '16/02/2008 12:15:12' converted to 2/16/2008 12:15:12 PM.
'       '2/16/2008' converted to 2/16/2008 12:00:00 AM.

Keterangan

Jika s berisi informasi zona waktu, metode ini mengembalikan nilai DateTime yang properti Kind nya DateTimeKind.Local dan mengonversi tanggal dan waktu dalam s ke waktu lokal. Jika tidak, ia tidak melakukan konversi zona waktu dan mengembalikan nilai DateTime yang properti Kind-nya DateTimeKind.Unspecified.

Kelebihan beban ini mencoba mengurai s dengan menggunakan konvensi pemformatan budaya saat ini. Budaya saat ini ditunjukkan oleh properti CurrentCulture. Untuk mengurai string menggunakan konvensi pemformatan budaya tertentu, panggil Parse(String, IFormatProvider) atau Parse(String, IFormatProvider, DateTimeStyles) kelebihan beban.

Kelebihan beban ini mencoba mengurai s dengan menggunakan gaya DateTimeStyles.AllowWhiteSpaces.

Lihat juga

Berlaku untuk

Parse(ReadOnlySpan<Char>, IFormatProvider)

Sumber:: DateTime.cs

Sumber:: DateTime.cs

Sumber:: DateTime.cs

Mengurai rentang karakter menjadi nilai.

public:
 static DateTime Parse(ReadOnlySpan<char> s, IFormatProvider ^ provider) = ISpanParsable<DateTime>::Parse;

public static DateTime Parse (ReadOnlySpan<char> s, IFormatProvider? provider);

static member Parse : ReadOnlySpan<char> * IFormatProvider -> DateTime

Public Shared Function Parse (s As ReadOnlySpan(Of Char), provider As IFormatProvider) As DateTime

Parameter

s: ReadOnlySpan<Char>

Rentang karakter untuk diurai.

provider: IFormatProvider

Objek yang menyediakan informasi pemformatan khusus budaya tentang s.

Mengembalikan

DateTime

Hasil penguraian s.

Penerapan

Parse(ReadOnlySpan<Char>, IFormatProvider)

Berlaku untuk

Parse(String, IFormatProvider)

Sumber:: DateTime.cs

Sumber:: DateTime.cs

Sumber:: DateTime.cs

Mengonversi representasi string tanggal dan waktu ke DateTime setara dengan menggunakan informasi format khusus budaya.

public:
 static DateTime Parse(System::String ^ s, IFormatProvider ^ provider);

public:
 static DateTime Parse(System::String ^ s, IFormatProvider ^ provider) = IParsable<DateTime>::Parse;

public static DateTime Parse (string s, IFormatProvider provider);

public static DateTime Parse (string s, IFormatProvider? provider);

static member Parse : string * IFormatProvider -> DateTime

Public Shared Function Parse (s As String, provider As IFormatProvider) As DateTime

Parameter

s: String

String yang berisi tanggal dan waktu untuk dikonversi. Lihat String untuk mengurai untuk informasi selengkapnya.

provider: IFormatProvider

Objek yang memasok informasi format khusus budaya tentang s. Lihat Penguraian dan budaya

Mengembalikan

DateTime

Objek yang setara dengan tanggal dan waktu yang terkandung dalam s seperti yang ditentukan oleh provider.

Penerapan

Parse(String, IFormatProvider)

Pengecualian

ArgumentNullException

s null.

FormatException

s tidak berisi representasi string yang valid dari tanggal dan waktu.

Contoh

Contoh berikut mengurai array string tanggal dengan menggunakan konvensi budaya en-US, fr-FR, dan de-DE. Ini menunjukkan bahwa representasi string dari satu tanggal dapat ditafsirkan secara berbeda di berbagai budaya.

using System;
using System.Globalization;

public class ParseDate
{
   public static void Main()
   {
      // Define cultures to be used to parse dates.
      CultureInfo[] cultures = {CultureInfo.CreateSpecificCulture("en-US"),
                                CultureInfo.CreateSpecificCulture("fr-FR"),
                                CultureInfo.CreateSpecificCulture("de-DE")};
      // Define string representations of a date to be parsed.
      string[] dateStrings = {"01/10/2009 7:34 PM",
                              "10.01.2009 19:34",
                              "10-1-2009 19:34" };
      // Parse dates using each culture.
      foreach (CultureInfo culture in cultures)
      {
         DateTime dateValue;
         Console.WriteLine("Attempted conversions using {0} culture.",
                           culture.Name);
         foreach (string dateString in dateStrings)
         {
            try {
               dateValue = DateTime.Parse(dateString, culture);
               Console.WriteLine("   Converted '{0}' to {1}.",
                                 dateString, dateValue.ToString("f", culture));
            }
            catch (FormatException) {
               Console.WriteLine("   Unable to convert '{0}' for culture {1}.",
                                 dateString, culture.Name);
            }
         }
         Console.WriteLine();
      }
   }
}
// The example displays the following output to the console:
//       Attempted conversions using en-US culture.
//          Converted '01/10/2009 7:34 PM' to Saturday, January 10, 2009 7:34 PM.
//          Converted '10.01.2009 19:34' to Thursday, October 01, 2009 7:34 PM.
//          Converted '10-1-2009 19:34' to Thursday, October 01, 2009 7:34 PM.
//
//       Attempted conversions using fr-FR culture.
//          Converted '01/10/2009 7:34 PM' to jeudi 1 octobre 2009 19:34.
//          Converted '10.01.2009 19:34' to samedi 10 janvier 2009 19:34.
//          Converted '10-1-2009 19:34' to samedi 10 janvier 2009 19:34.
//
//       Attempted conversions using de-DE culture.
//          Converted '01/10/2009 7:34 PM' to Donnerstag, 1. Oktober 2009 19:34.
//          Converted '10.01.2009 19:34' to Samstag, 10. Januar 2009 19:34.
//          Converted '10-1-2009 19:34' to Samstag, 10. Januar 2009 19:34.

open System
open System.Globalization

// Define cultures to be used to parse dates.
let cultures = 
    [ CultureInfo.CreateSpecificCulture "en-US"
      CultureInfo.CreateSpecificCulture "fr-FR"
      CultureInfo.CreateSpecificCulture "de-DE" ]

// Define string representations of a date to be parsed.
let dateStrings = 
    [ "01/10/2009 7:34 PM"
      "10.01.2009 19:34"
      "10-1-2009 19:34" ]

// Parse dates using each culture.
for culture in cultures do
    printfn $"Attempted conversions using {culture.Name} culture."
    for dateString in dateStrings do
        try
            let dateValue = DateTime.Parse(dateString, culture)
            printfn $"""   Converted '{dateString}' to {dateValue.ToString("f", culture)}."""
        with :? FormatException ->
            printfn $"   Unable to convert '{dateString}' for culture {culture.Name}." 
    printfn ""


// The example displays the following output to the console:
//       Attempted conversions using en-US culture.
//          Converted '01/10/2009 7:34 PM' to Saturday, January 10, 2009 7:34 PM.
//          Converted '10.01.2009 19:34' to Thursday, October 01, 2009 7:34 PM.
//          Converted '10-1-2009 19:34' to Thursday, October 01, 2009 7:34 PM.
//
//       Attempted conversions using fr-FR culture.
//          Converted '01/10/2009 7:34 PM' to jeudi 1 octobre 2009 19:34.
//          Converted '10.01.2009 19:34' to samedi 10 janvier 2009 19:34.
//          Converted '10-1-2009 19:34' to samedi 10 janvier 2009 19:34.
//
//       Attempted conversions using de-DE culture.
//          Converted '01/10/2009 7:34 PM' to Donnerstag, 1. Oktober 2009 19:34.
//          Converted '10.01.2009 19:34' to Samstag, 10. Januar 2009 19:34.
//          Converted '10-1-2009 19:34' to Samstag, 10. Januar 2009 19:34.

Imports System.Globalization

Module ParseDate
   Public Sub Main()
      ' Define cultures to be used to parse dates.
      Dim cultures() As CultureInfo = {CultureInfo.CreateSpecificCulture("en-US"), _
                                       CultureInfo.CreateSpecificCulture("fr-FR"), _
                                       CultureInfo.CreateSpecificCulture("de-DE")}
      ' Define string representations of a date to be parsed.
      Dim dateStrings() As String = {"01/10/2009 7:34 PM", _
                                     "10.01.2009 19:34", _
                                     "10-1-2009 19:34" }
      ' Parse dates using each culture.
      For Each culture In cultures
         Dim dateValue As Date
         Console.WriteLine("Attempted conversions using {0} culture.", culture.Name)
         For Each dateString As String In dateStrings
            Try
               dateValue = Date.Parse(dateString, culture)
               Console.WriteLine("   Converted '{0}' to {1}.", _
                                 dateString, dateValue.ToString("f", culture))
            Catch e As FormatException
               Console.WriteLine("   Unable to convert '{0}' for culture {1}.", _
                                 dateString, culture.Name)
            End Try                                                
         Next
         Console.WriteLine()
      Next                                                                                     
   End Sub
End Module
' The example displays the following output to the console:
'       Attempted conversions using en-US culture.
'          Converted '01/10/2009 7:34 PM' to Saturday, January 10, 2009 7:34 PM.
'          Converted '10.01.2009 19:34' to Thursday, October 01, 2009 7:34 PM.
'          Converted '10-1-2009 19:34' to Thursday, October 01, 2009 7:34 PM.
'       
'       Attempted conversions using fr-FR culture.
'          Converted '01/10/2009 7:34 PM' to jeudi 1 octobre 2009 19:34.
'          Converted '10.01.2009 19:34' to samedi 10 janvier 2009 19:34.
'          Converted '10-1-2009 19:34' to samedi 10 janvier 2009 19:34.
'       
'       Attempted conversions using de-DE culture.
'          Converted '01/10/2009 7:34 PM' to Donnerstag, 1. Oktober 2009 19:34.
'          Converted '10.01.2009 19:34' to Samstag, 10. Januar 2009 19:34.
'          Converted '10-1-2009 19:34' to Samstag, 10. Januar 2009 19:34.

Keterangan

Kelebihan beban ini mencoba mengurai s dengan menggunakan gaya DateTimeStyles.AllowWhiteSpaces.

Lihat juga

Berlaku untuk

Parse(ReadOnlySpan<Char>, IFormatProvider, DateTimeStyles)

Sumber:: DateTime.cs

Sumber:: DateTime.cs

Sumber:: DateTime.cs

Mengonversi rentang memori yang berisi representasi string tanggal dan waktu ke DateTime setara dengan menggunakan informasi format khusus budaya dan gaya pemformatan.

public static DateTime Parse (ReadOnlySpan<char> s, IFormatProvider? provider = default, System.Globalization.DateTimeStyles styles = System.Globalization.DateTimeStyles.None);

public static DateTime Parse (ReadOnlySpan<char> s, IFormatProvider provider = default, System.Globalization.DateTimeStyles styles = System.Globalization.DateTimeStyles.None);

static member Parse : ReadOnlySpan<char> * IFormatProvider * System.Globalization.DateTimeStyles -> DateTime

Public Shared Function Parse (s As ReadOnlySpan(Of Char), Optional provider As IFormatProvider = Nothing, Optional styles As DateTimeStyles = System.Globalization.DateTimeStyles.None) As DateTime

Parameter

s: ReadOnlySpan<Char>

Rentang memori yang berisi string yang akan diurai. Lihat String untuk mengurai untuk informasi selengkapnya.

provider: IFormatProvider

Objek yang memasok informasi format khusus budaya tentang s. Lihat Penguraian dan budaya

styles: DateTimeStyles

Kombinasi bitwise dari nilai enumerasi yang menunjukkan elemen gaya yang dapat ada dalam s agar operasi penguraian berhasil, dan yang menentukan cara menginterpretasikan tanggal yang diurai sehubungan dengan zona waktu saat ini atau tanggal saat ini. Nilai umum yang akan ditentukan adalah None.

Mengembalikan

DateTime

Objek yang setara dengan tanggal dan waktu yang terkandung dalam s, seperti yang ditentukan oleh provider dan styles.

Pengecualian

FormatException

s tidak berisi representasi string yang valid dari tanggal dan waktu.

ArgumentException

styles berisi kombinasi nilai DateTimeStyles yang tidak valid. Misalnya, baik AssumeLocal maupun AssumeUniversal.

Berlaku untuk

Parse(String, IFormatProvider, DateTimeStyles)

Sumber:: DateTime.cs

Sumber:: DateTime.cs

Sumber:: DateTime.cs

Mengonversi representasi string tanggal dan waktu ke DateTime setara dengan menggunakan informasi format khusus budaya dan gaya pemformatan.

public:
 static DateTime Parse(System::String ^ s, IFormatProvider ^ provider, System::Globalization::DateTimeStyles styles);

public static DateTime Parse (string s, IFormatProvider provider, System.Globalization.DateTimeStyles styles);

public static DateTime Parse (string s, IFormatProvider? provider, System.Globalization.DateTimeStyles styles);

static member Parse : string * IFormatProvider * System.Globalization.DateTimeStyles -> DateTime

Public Shared Function Parse (s As String, provider As IFormatProvider, styles As DateTimeStyles) As DateTime

Parameter

s: String

String yang berisi tanggal dan waktu untuk dikonversi. Lihat String untuk mengurai untuk informasi selengkapnya.

provider: IFormatProvider

Objek yang memasok informasi pemformatan khusus budaya tentang s. Lihat Penguraian dan budaya

styles: DateTimeStyles

Mengembalikan

DateTime

Objek yang setara dengan tanggal dan waktu yang terkandung dalam s, seperti yang ditentukan oleh provider dan styles.

Pengecualian

ArgumentNullException

s null.

FormatException

s tidak berisi representasi string yang valid dari tanggal dan waktu.

ArgumentException

styles berisi kombinasi nilai DateTimeStyles yang tidak valid. Misalnya, baik AssumeLocal maupun AssumeUniversal.

Contoh

Contoh berikut menunjukkan metode Parse(String, IFormatProvider, DateTimeStyles) dan menampilkan nilai properti Kind dari nilai DateTime yang dihasilkan.

using System;
using System.Globalization;

public class ParseDateExample
{
   public static void Main()
   {
      string dateString;
      CultureInfo culture ;
      DateTimeStyles styles;
      DateTime result;

      // Parse a date and time with no styles.
      dateString = "03/01/2009 10:00 AM";
      culture = CultureInfo.CreateSpecificCulture("en-US");
      styles = DateTimeStyles.None;
      try {
         result = DateTime.Parse(dateString, culture, styles);
         Console.WriteLine("{0} converted to {1} {2}.",
                           dateString, result, result.Kind.ToString());
      }
      catch (FormatException) {
         Console.WriteLine("Unable to convert {0} to a date and time.",
                           dateString);
      }

      // Parse the same date and time with the AssumeLocal style.
      styles = DateTimeStyles.AssumeLocal;
      try {
         result = DateTime.Parse(dateString, culture, styles);
         Console.WriteLine("{0} converted to {1} {2}.",
                           dateString, result, result.Kind.ToString());
      }
      catch (FormatException) {
         Console.WriteLine("Unable to convert {0} to a date and time.", dateString);
      }

      // Parse a date and time that is assumed to be local.
      // This time is five hours behind UTC. The local system's time zone is
      // eight hours behind UTC.
      dateString = "2009/03/01T10:00:00-5:00";
      styles = DateTimeStyles.AssumeLocal;
      try {
         result = DateTime.Parse(dateString, culture, styles);
         Console.WriteLine("{0} converted to {1} {2}.",
                           dateString, result, result.Kind.ToString());
      }
      catch (FormatException) {
         Console.WriteLine("Unable to convert {0} to a date and time.", dateString);
      }

      // Attempt to convert a string in improper ISO 8601 format.
      dateString = "03/01/2009T10:00:00-5:00";
      try {
         result = DateTime.Parse(dateString, culture, styles);
         Console.WriteLine("{0} converted to {1} {2}.",
                           dateString, result, result.Kind.ToString());
      }
      catch (FormatException) {
         Console.WriteLine("Unable to convert {0} to a date and time.", dateString);
      }

      // Assume a date and time string formatted for the fr-FR culture is the local
      // time and convert it to UTC.
      dateString = "2008-03-01 10:00";
      culture = CultureInfo.CreateSpecificCulture("fr-FR");
      styles = DateTimeStyles.AdjustToUniversal | DateTimeStyles.AssumeLocal;
      try {
         result = DateTime.Parse(dateString, culture, styles);
         Console.WriteLine("{0} converted to {1} {2}.",
                           dateString, result, result.Kind.ToString());
      }
      catch (FormatException) {
         Console.WriteLine("Unable to convert {0} to a date and time.", dateString);
      }
   }
}
// The example displays the following output to the console:
//       03/01/2009 10:00 AM converted to 3/1/2009 10:00:00 AM Unspecified.
//       03/01/2009 10:00 AM converted to 3/1/2009 10:00:00 AM Local.
//       2009/03/01T10:00:00-5:00 converted to 3/1/2009 7:00:00 AM Local.
//       Unable to convert 03/01/2009T10:00:00-5:00 to a date and time.
//       2008-03-01 10:00 converted to 3/1/2008 6:00:00 PM Utc.

open System
open System.Globalization

[<EntryPoint>]
let main _ =
    // Parse a date and time with no styles.
    let dateString = "03/01/2009 10:00 AM"
    let culture = CultureInfo.CreateSpecificCulture "en-US"
    let styles = DateTimeStyles.None
    try
        let result = DateTime.Parse(dateString, culture, styles)
        printfn $"{dateString} converted to {result} {result.Kind}."
    with :? FormatException ->
        printfn $"Unable to convert {dateString} to a date and time."

    // Parse the same date and time with the AssumeLocal style.
    let styles = DateTimeStyles.AssumeLocal
    try
        let result = DateTime.Parse(dateString, culture, styles)
        printfn $"{dateString} converted to {result} {result.Kind}."
    with :? FormatException ->
        printfn $"Unable to convert {dateString} to a date and time."

    // Parse a date and time that is assumed to be local.
    // This time is five hours behind UTC. The local system's time zone is
    // eight hours behind UTC.
    let dateString = "2009/03/01T10:00:00-5:00"
    let styles = DateTimeStyles.AssumeLocal
    try
        let result = DateTime.Parse(dateString, culture, styles)
        printfn $"{dateString} converted to {result} {result.Kind}."
    with :? FormatException ->
        printfn $"Unable to convert {dateString} to a date and time."

    // Attempt to convert a string in improper ISO 8601 format.
    let dateString = "03/01/2009T10:00:00-5:00"
    try
        let result = DateTime.Parse(dateString, culture, styles)
        printfn $"{dateString} converted to {result} {result.Kind}."
    with :? FormatException ->
        printfn $"Unable to convert {dateString} to a date and time."

    // Assume a date and time string formatted for the fr-FR culture is the local
    // time and convert it to UTC.
    let dateString = "2008-03-01 10:00"
    let culture = CultureInfo.CreateSpecificCulture "fr-FR"
    let styles = DateTimeStyles.AdjustToUniversal ||| DateTimeStyles.AssumeLocal
    try
        let result = DateTime.Parse(dateString, culture, styles)
        printfn $"{dateString} converted to {result} {result.Kind}."
    with :? FormatException ->
        printfn $"Unable to convert {dateString} to a date and time."

    0

// The example displays the following output to the console:
//       03/01/2009 10:00 AM converted to 3/1/2009 10:00:00 AM Unspecified.
//       03/01/2009 10:00 AM converted to 3/1/2009 10:00:00 AM Local.
//       2009/03/01T10:00:00-5:00 converted to 3/1/2009 7:00:00 AM Local.
//       Unable to convert 03/01/2009T10:00:00-5:00 to a date and time.
//       2008-03-01 10:00 converted to 3/1/2008 6:00:00 PM Utc.

Imports System.Globalization

Module ParseDateExample
   Public Sub Main()
      Dim dateString As String  
      Dim culture As CultureInfo
      Dim styles As DateTimeStyles 
      Dim result As DateTime
      
      ' Parse a date and time with no styles.
      dateString = "03/01/2009 10:00 AM"
      culture = CultureInfo.CreateSpecificCulture("en-US")
      styles = DateTimeStyles.None
      Try
         result = DateTime.Parse(dateString, culture, styles)
         Console.WriteLine("{0} converted to {1} {2}.", _
                           dateString, result, result.Kind.ToString())
      Catch e As FormatException
         Console.WriteLine("Unable to convert {0} to a date and time.", dateString)
      End Try      
      
      ' Parse the same date and time with the AssumeLocal style.
      styles = DateTimeStyles.AssumeLocal
      Try
         result = DateTime.Parse(dateString, culture, styles)
         Console.WriteLine("{0} converted to {1} {2}.", _
                           dateString, result, result.Kind.ToString())
      Catch e As FormatException
         Console.WriteLine("Unable to convert {0} to a date and time.", dateString)
      End Try      
      
      ' Parse a date and time that is assumed to be local.
      ' This time is five hours behind UTC. The local system's time zone is 
      ' eight hours behind UTC.
      dateString = "2009/03/01T10:00:00-5:00"
      styles = DateTimeStyles.AssumeLocal
      Try
         result = DateTime.Parse(dateString, culture, styles)
         Console.WriteLine("{0} converted to {1} {2}.", _
                           dateString, result, result.Kind.ToString())
      Catch e As FormatException
         Console.WriteLine("Unable to convert {0} to a date and time.", dateString)
      End Try      
      
      ' Attempt to convert a string in improper ISO 8601 format.
      dateString = "03/01/2009T10:00:00-5:00"
      Try
         result = DateTime.Parse(dateString, culture, styles)
         Console.WriteLine("{0} converted to {1} {2}.", _
                           dateString, result, result.Kind.ToString())
      Catch e As FormatException
         Console.WriteLine("Unable to convert {0} to a date and time.", dateString)
      End Try      

      ' Assume a date and time string formatted for the fr-FR culture is the local 
      ' time and convert it to UTC.
      dateString = "2008-03-01 10:00"
      culture = CultureInfo.CreateSpecificCulture("fr-FR")
      styles = DateTimeStyles.AdjustToUniversal Or DateTimeStyles.AssumeLocal
      Try
         result = DateTime.Parse(dateString, culture, styles)
         Console.WriteLine("{0} converted to {1} {2}.", _
                           dateString, result, result.Kind.ToString())
      Catch e As FormatException
         Console.WriteLine("Unable to convert {0} to a date and time.", dateString)
      End Try      
   End Sub
End Module
'
' The example displays the following output to the console:
'       03/01/2009 10:00 AM converted to 3/1/2009 10:00:00 AM Unspecified.
'       03/01/2009 10:00 AM converted to 3/1/2009 10:00:00 AM Local.
'       2009/03/01T10:00:00-5:00 converted to 3/1/2009 7:00:00 AM Local.
'       Unable to convert 03/01/2009T10:00:00-5:00 to a date and time.
'       2008-03-01 10:00 converted to 3/1/2008 6:00:00 PM Utc.

Keterangan

Metode ini kelebihan beban mengonversi tanggal dan waktu dalam s dan mengatur properti Kind dari nilai DateTime yang dikembalikan sebagai berikut:

Kalau	Konversi zona waktu	Properti jenis
`s` tidak berisi informasi zona waktu.	Tidak.	DateTimeKind.Unspecified
`s` berisi informasi zona waktu.	Ke waktu di zona waktu lokal	DateTimeKind.Local
`s` berisi informasi zona waktu, dan `styles` menyertakan bendera DateTimeStyles.AdjustToUniversal.	Ke Waktu Universal Terkoordinasi (UTC)	DateTimeKind.Utc
`s` berisi perancang zona waktu Z atau GMT, dan `styles` menyertakan DateTimeStyles.RoundtripKind.	Tidak.	DateTimeKind.Utc

Lihat juga

Berlaku untuk

Bagikan melalui

DateTime.Parse Metode

Definisi

Overload

Contoh

Keterangan

Metode mana yang saya panggil?

String yang akan diurai

Konvensi penguraian dan budaya

Elemen penguraian dan gaya

Nilai yang dikembalikan dan DateTime.Kind

Parse(String)

Parameter

Mengembalikan

Pengecualian

Contoh

Keterangan

Lihat juga

Berlaku untuk

Parse(ReadOnlySpan<Char>, IFormatProvider)

Parameter

Mengembalikan

Penerapan

Berlaku untuk

Parse(String, IFormatProvider)

Parameter

Mengembalikan

Penerapan

Pengecualian

Contoh

Keterangan

Lihat juga

Berlaku untuk

Parse(ReadOnlySpan<Char>, IFormatProvider, DateTimeStyles)

Parameter

Mengembalikan

Pengecualian

Berlaku untuk

Parse(String, IFormatProvider, DateTimeStyles)

Parameter

Mengembalikan

Pengecualian

Contoh

Keterangan

Lihat juga

Berlaku untuk

Sumber Daya Tambahan: