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 menjadi DateTime setara.

Overload

Parse(String)	Mengonversi representasi string tanggal dan waktu menjadi 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 menjadi DateTime setara dengan menggunakan informasi format khusus budaya.
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, IFormatProvider, DateTimeStyles)	Mengonversi representasi string tanggal dan waktu menjadi DateTime setara dengan menggunakan informasi format khusus budaya dan gaya pemformatan.

Contoh

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

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.

Anda juga dapat mengunduh serangkaian DateTime.Parse contoh 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
Elemen penguraian dan gaya
Nilai yang dikembalikan dan DateTime.Kind

Metode mana yang saya panggil?

Untuk	Call
Uraikan string tanggal dan waktu dengan menggunakan konvensi budaya saat ini.	Parse(String) overload
Mengurai string tanggal dan waktu dengan menggunakan konvensi budaya tertentu.	Parse(String, IFormatProvider) kelebihan beban (lihat Konvensi Penguraian dan Budaya)
Mengurai string tanggal dan waktu dengan elemen gaya khusus (seperti spasi kosong atau tanpa spasi kosong).	Parse(String, IFormatProvider, DateTimeStyles) overload
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 setempat.	Parse(String, IFormatProvider, DateTimeStyles) overload
Mengurai string tanggal dan waktu tanpa menangani pengecualian.	metode DateTime.TryParse
Pulihkan (pulang-pergi) nilai tanggal dan waktu yang dibuat oleh operasi pemformatan.	Teruskan string format standar "o" atau "r" ke ToString(String) metode , dan panggil Parse(String, IFormatProvider, DateTimeStyles) kelebihan beban dengan DateTimeStyles.RoundtripKind
Mengurai string tanggal dan waktu dalam format tetap di seluruh batas komputer (dan mungkin budaya).	DateTime.ParseExact atau DateTime.TryParseExact metode

String yang akan diurai

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

Penting

Jika operasi penguraian gagal karena format string yang tidak dikenali, Parse metode akan menampilkan FormatException, sedangkan TryParse metode 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 menggantikan 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 menjadi tahun berdasarkan Calendar.TwoDigitYearMax kalender budaya saat ini atau kalender budaya yang ditentukan saat ini (jika Anda menggunakan kelebihan beban dengan argumen non-null provider ).
String dengan komponen tanggal yang hanya menyertakan komponen bulan dan tahun tetapi tidak ada 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 Parse(String, IFormatProvider, DateTimeStyles) kelebihan beban dan menyertakan DateTimeStyles.NoCurrentDateDefault dalam styles argumen , 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 Parse(String, IFormatProvider, DateTimeStyles) kelebihan beban dan menyertakan DateTimeStyles.NoCurrentDateDefault dalam styles argumen , 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 menyertakan penentu 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 masing-masing 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 di kalender yang digunakan oleh metode penguraian (lihat Konvensi penguraian dan budaya), Parse metode berhasil mengurai string. Jika string input mewakili hari lompatan dalam tahun non-lompatan, metode akan melempar FormatException.

Parse Karena metode mencoba mengurai representasi string tanggal dan waktu dengan menggunakan aturan pemformatan dari 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 DateTime.ParseExact metode dan berikan penentu format.

Konvensi penguraian dan budaya

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

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.

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

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

Jika Anda mengurai string tanggal dan waktu dengan menggunakan DateTimeFormatInfo objek dengan pengaturan yang disesuaikan yang berbeda dari budaya standar, gunakan ParseExact metode alih-alih Parse metode untuk meningkatkan peluang konversi yang berhasil. String tanggal dan waktu non-standar dapat rumit dan sulit diurai. Metode ini Parse mencoba mengurai string dengan beberapa pola penguraian implisit, yang semuanya mungkin gagal. Sebaliknya, metode ini 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" dalam 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 IFormatProvider objek yang mewakili budaya selain budaya invarian secara tak terduga dapat gagal jika salah satu hal berikut ini 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 ParseExact metode 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 invarian, atau Anda dapat menserialisasikan dan mendeserialisasi DateTime nilai dalam format biner.

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

Elemen penguraian dan gaya

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

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

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

Nilai yang dikembalikan dan DateTime.Kind

Kelebihan DateTime.Parse beban mengembalikan DateTime nilai yang propertinya Kind 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, Parse metode mengembalikan DateTime objek yang propertinya Kind adalah DateTimeKind.Unspecified. Namun, metode ini Parse juga dapat melakukan konversi zona waktu dan mengatur nilai Kind properti secara berbeda, tergantung pada nilai s parameter dan styles :

Jika	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 AdjustToUniversal bendera .	Tanggal dan waktu dikonversi ke Waktu Universal Terkoordinasi (UTC).	DateTimeKind.Utc
`s` berisi penunjuk zona waktu Z atau GMT, dan `styles` menyertakan RoundtripKind bendera .	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 tanggal dan waktu Kind selama operasi pemformatan dan penguraian dengan menggunakan DateTimeStyles.RoundtripKind bendera . Contoh berikut menggambarkan bagaimana RoundtripKind bendera memengaruhi operasi penguraian pada nilai yang dikonversi DateTime menjadi 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 menjadi 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 yang akan diurai untuk informasi selengkapnya.

Mengembalikan

DateTime

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

Pengecualian

ArgumentNullException

sadalah null.

FormatException

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

Contoh

Contoh berikut mengurai 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 output contoh. Output dari contoh ini mencerminkan konvensi pemformatan budaya en-US.
Menggunakan nilai gaya default, yaitu AllowWhiteSpaces.

Ini menangani FormatException pengecualian 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 DateTime nilai yang propertinya Kind adalah DateTimeKind.Local dan mengonversi tanggal dan waktu s ke waktu lokal. Jika tidak, ia tidak melakukan konversi zona waktu dan mengembalikan DateTime nilai yang propertinya Kind adalah DateTimeKind.Unspecified.

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

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

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 yang akan 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 menjadi 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 yang akan diurai untuk informasi selengkapnya.

provider: IFormatProvider

Objek yang memasok informasi format khusus budaya tentang s. Lihat Konvensi 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

sadalah null.

FormatException

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

Contoh

Contoh berikut menguraikan 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 sDateTimeStyles.AllowWhiteSpaces dengan menggunakan gaya .

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 yang DateTime setara dengannya 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 yang akan diurai untuk informasi selengkapnya.

provider: IFormatProvider

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

styles: DateTimeStyles

Kombinasi bitwise dari nilai enumerasi yang menunjukkan elemen gaya yang dapat hadir 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 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 DateTimeStyles nilai yang tidak valid. Misalnya, dan AssumeLocal AssumeUniversal.

Berlaku untuk

Parse(String, IFormatProvider, DateTimeStyles)

Sumber:: DateTime.cs

Sumber:: DateTime.cs

Sumber:: DateTime.cs

Mengonversi representasi string tanggal dan waktu setara DateTime 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 yang akan diurai untuk informasi selengkapnya.

provider: IFormatProvider

Objek yang memasok informasi pemformatan khusus budaya tentang s. Lihat Konvensi 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

sadalah null.

FormatException

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

ArgumentException

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

Contoh

Contoh berikut menunjukkan Parse(String, IFormatProvider, DateTimeStyles) metode dan menampilkan nilai Kind properti dari nilai yang DateTime 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 kelebihan beban ini mengonversi tanggal dan waktu dalam s dan mengatur Kind properti dari nilai yang dikembalikan DateTime sebagai berikut:

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

Lihat juga

Berlaku untuk

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

Saran dan Komentar

Sumber Daya Tambahan: