Nyelv

DateTime.Parse Metódus

Definíció

Névtér:
System
Szerelvények:
mscorlib.dll, System.Runtime.dll
Szerelvények:
netstandard.dll, System.Runtime.dll
Szerelvény:
System.Runtime.dll
Szerelvény:
mscorlib.dll
Szerelvény:
netstandard.dll

Egy dátum és idő sztringképét az azzal DateTime egyenértékűvé alakítja.

Túlterhelések

Név Description
Parse(String)

Egy dátum és idő DateTime sztringképét az aktuális kultúra konvencióinak használatával konvertálja annak megfelelővé.
Parse(ReadOnlySpan<Char>, IFormatProvider)

Több karakterből álló elemet elemez egy értékben.
Parse(String, IFormatProvider)

Egy dátum és idő sztring-ábrázolását átalakítja annak DateTime megfelelővé kultúraspecifikus formátuminformációk használatával.
Parse(ReadOnlySpan<Char>, IFormatProvider, DateTimeStyles)

Olyan memóriatartományt alakít át, amely egy dátum és idő sztring-ábrázolását tartalmazza a DateTime megfelelőre a kultúraspecifikus formázási információk és formázási stílusok használatával.
Parse(String, IFormatProvider, DateTimeStyles)

Egy dátum és idő sztringképét átalakítja annak DateTime megfelelőjeként a kultúraspecifikus formátuminformációk és formázási stílusok használatával.

Példák

A metódust meghívó DateTime.Parse számos példa a jelen cikk Megjegyzések szakaszában és az egyes DateTime.Parse túlterhelések dokumentációjában található.

A C# .NET Core-projektben szereplő példák teljes készletét is letöltheti.

Megjegyzések

Ebben a szakaszban:

Melyik metódust hívhatom meg?

Címzett Call
Elemezheti a dátum- és idősztringet az aktuális kultúra konvenciók használatával. Parse(String) túlterhel
Dátum- és idősztring elemzése egy adott kultúra konvencióinak használatával. Parse(String, IFormatProvider) túlterhelés (lásd elemzési és kulturális egyezmények)
Dátum- és idősztring elemzése speciális stíluselemekkel (például szóköz vagy szóköz nélkül). Parse(String, IFormatProvider, DateTimeStyles) túlterhel
Elemezhet egy dátum- és idősztringet, amelyeknek egy adott formátumban kell lenniük. DateTime.ParseExact vagy DateTime.TryParseExact
Elemezhet egy dátum- és idősztringet, és utc vagy helyi idő szerinti konvertálást hajthat végre. Parse(String, IFormatProvider, DateTimeStyles) túlterhel
Dátum- és idősztring elemzése kivételek kezelése nélkül. DateTime.TryParse módszer
Visszaállítás (oda-vissza) egy formázási művelet által létrehozott dátum- és időérték. Adja át az "o" vagy az "r" standard formátumú sztringet a ToString(String) metódusnak, és hívja meg a túlterhelést Parse(String, IFormatProvider, DateTimeStyles)DateTimeStyles.RoundtripKind
Egy dátum- és idősztringet rögzített formátumban elemezhet a gép (és esetleg kulturális) határain. DateTime.ParseExact vagy DateTime.TryParseExact metódus

Az elemezni kívánt sztring

A Parse metódus megpróbálja átalakítani egy dátum- és időérték sztringképét annak megfelelőjeként DateTime . Megpróbálja teljesen elemezni a bemeneti sztringet FormatException kivétel nélkül. Objektumot elfogadó IFormatProvider túlterhelések használatakor a rendszer elemzi az objektumot StringToParse. Ha nem ad meg ilyen objektumot, CurrentCulture akkor a rendszer ehelyett használja.

Important

Ha az elemzési művelet ismeretlen sztringformátum miatt meghiúsul, a Parse metódus egy FormatException, míg a TryParse metódus eredménye false. Mivel a kivételkezelés költséges lehet, akkor érdemes használni Parse , ha az elemzési művelet várhatóan sikeres lesz, mert a bemeneti forrás megbízható. TryParse előnyösebb, ha a hibák elemzése valószínűsíthető, különösen azért, mert egy bemeneti forrás nem megbízható, vagy ésszerű alapértelmezett értékekkel helyettesítheti azokat a sztringeket, amelyek nem elemeznek sikeresen.

Az elemezni kívánt sztring az alábbi űrlapok bármelyikét használhatja:

  • Dátum- és időösszetevővel rendelkező sztring.

  • Dátum- és időösszetevő nélküli sztring. Ha az időösszetevő hiányzik, a metódus 12:00 éjfélt feltételez. Ha a dátumösszetevő kétjegyű évszámmal rendelkezik, akkor a rendszer az aktuális kultúra aktuális naptára vagy a megadott kultúra aktuális naptára alapján Calendar.TwoDigitYearMax konvertálja azt egy évre (ha túlterhelést használ nem null provider argumentummal).

  • Egy olyan dátumösszetevővel rendelkező sztring, amely csak a hónapot és az évet tartalmazza, de nincs napi összetevő. A metódus a hónap első napját feltételezi.

  • Olyan dátumösszetevővel rendelkező sztring, amely csak a hónapot és a napot tartalmazza, év összetevő nélkül. A metódus az aktuális évet feltételezi.

  • Idő- és dátumösszetevő nélküli sztring. A metódus az aktuális dátumot feltételezi, hacsak nem hívja meg a Parse(String, IFormatProvider, DateTimeStyles) túlterhelést, és bele nem foglalja DateTimeStyles.NoCurrentDateDefault az styles argumentumba. Ebben az esetben a metódus 0001. január 1-jei dátumot feltételez.

  • Egy olyan időösszetevővel rendelkező sztring, amely csak az órát tartalmazza, valamint egy AM/PM tervezőt, dátumösszetevő nélkül. A metódus az aktuális dátumot és időt feltételezi percek és másodpercek nélkül. Ezt a Parse(String, IFormatProvider, DateTimeStyles) viselkedést a túlterhelés meghívásával módosíthatja, és belefoglalhatja DateTimeStyles.NoCurrentDateDefault az styles argumentumba. Ebben az esetben a metódus 0001. január 1-jei dátumot feltételez.

  • Egy időzóna-információkat tartalmazó sztring, amely megfelel az ISO 8601 szabványnak. Az alábbi példákban az első sztring az egyezményes világidőt (UTC) jelöli, a második pedig az időpontot egy időzónában, amely hét órával korábbi az UTC-nél:

    "2008-11-01T19:35:00.0000000Z" "2008-11-01T19:35:00.0000000-07:00"

  • A GMT-tervezőt tartalmazó sztring, amely megfelel az RFC 1123 időformátumának; például:

    "Szo, 01 Nov 2008 19:35:00 GMT"

  • Egy sztring, amely tartalmazza a dátumot és az időt, valamint az időzóna eltolásának adatait; például:

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

Az alábbi példa az egyes formátumokban lévő sztringeket az aktuális kultúra formázási konvencióinak használatával elemzi, amely ebben az esetben a en-US kultúra:

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

Ha a bemeneti sztring szökőévben szökőnapot jelöl az elemzési módszer által használt naptárban (lásd elemzési és kulturális konvenciók), a Parse metódus sikeresen elemzi a sztringet. Ha a bemeneti sztring szökőnapot jelöl egy szökőévben, a metódus egy FormatException.

Mivel a metódus az Parse aktuális vagy egy adott kultúra formázási szabályaival próbálja elemezni egy dátum és idő sztringképét, a különböző kultúrák közötti sztring elemzése sikertelen lehet. Ha egy adott dátum- és időformátumot szeretne elemezni különböző területi beállítások között, használja a metódus egyik túlterhelését DateTime.ParseExact , és adjon meg egy formátumjelölőt.

Elemzési és kulturális konvenciók

A metódus minden túlterhelése Parse kulturális szempontból érzékeny, kivéve, ha az elemezni kívánt sztring (amelyet az alábbi táblázat jelöl s ) megfelel az ISO 8601-mintának. Az elemzési művelet az alábbi módon származtatott objektum formázási adatait DateTimeFormatInfo használja:

Important

A japán naptárak korszakai a császár uralkodásán alapulnak, ezért várhatóan megváltoznak. 2019. május 1-jén például a Reiwa-korszak kezdetét jelentette JapaneseCalendar és JapaneseLunisolarCalendar. Az ilyen korszakváltás minden olyan alkalmazást érint, amely ezeket a naptárakat használja. További információkért és annak megállapításához, hogy az alkalmazások érintettek-e, olvassa el az Új korszak kezelése a japán naptárban a .NET-ben című témakört. Az alkalmazások windowsos rendszereken való tesztelésével kapcsolatos információkért, amelyek biztosítják, hogy felkészültek legyenek a korszakváltásra, olvassa el az alkalmazás előkészítése a japán korszakváltásra című témakört. A több korszakot támogató naptárakat támogató .NET-funkciókért és a több korszakot támogató naptárak használatakor ajánlott eljárásokért lásd: Korszakok használata.

Ha a hívás És provider van A formázási információk a következőből származnak:
Parse(String) - A jelenlegi kultúra (DateTimeFormatInfo.CurrentInfo tulajdonság)
Parse(String, IFormatProvider) vagy Parse(String, IFormatProvider, DateTimeStyles) objektum DateTimeFormatInfo A megadott DateTimeFormatInfo objektum
Parse(String, IFormatProvider) vagy Parse(String, IFormatProvider, DateTimeStyles) null A jelenlegi kultúra (DateTimeFormatInfo.CurrentInfo tulajdonság)
Parse(String, IFormatProvider) vagy Parse(String, IFormatProvider, DateTimeStyles) objektum CultureInfo A CultureInfo.DateTimeFormat tulajdonság
Parse(String, IFormatProvider) vagy Parse(String, IFormatProvider, DateTimeStyles) Egyéni IFormatProvider megvalósítás A IFormatProvider.GetFormat metódus

Ha a formázási információk egy DateTimeFormatInfo objektumból származnak, a DateTimeFormatInfo.Calendar tulajdonság határozza meg az elemzési műveletben használt naptárt.

Ha egy dátum- és idősztringet egy DateTimeFormatInfo olyan objektummal elemez, amely a szokásos kultúrától eltérő egyéni beállításokkal rendelkezik, a metódus helyett a ParseExactParse metódussal javíthatja a sikeres átalakítás esélyét. A nem szabványos dátum- és idősztringek bonyolultak és nehezen elemezhetők. A Parse metódus több implicit elemzési mintával rendelkező sztringet próbál elemezni, amelyek mindegyike sikertelen lehet. Ezzel szemben a ParseExact módszer megköveteli, hogy explicit módon jelöljön ki egy vagy több olyan pontos elemzési mintát, amely valószínűleg sikeres lesz. További információt a témakör "DateTimeFormatInfo and Dynamic Data" című szakaszában DateTimeFormatInfo talál.

Important

Vegye figyelembe, hogy egy adott kultúra formázási konvenciói dinamikusak, és változhatnak. Ez azt jelenti, hogy az alapértelmezett (aktuális) kultúra formázási konvencióitól függő vagy az invariáns kultúrától eltérő kultúrát képviselő objektumot meghatározó IFormatProvider elemzési műveletek váratlanul meghiúsulhatnak, ha az alábbiak bármelyike előfordul:

  • A kultúraspecifikus adatok a .NET-keretrendszer fő- vagy alverziói, illetve a .NET-keretrendszer meglévő verziójának frissítése miatt megváltoztak.
  • A kultúraspecifikus adatok a felhasználói beállításokat tükrözik, amelyek gépről gépre vagy munkamenetre változhatnak.
  • A kultúraspecifikus adatok olyan helyettesítő kultúrát jelölnek, amely felülbírálja egy szabványos vagy egyéni kultúra beállításait.

A kulturális adatok változásaihoz kapcsolódó adat- és idősztringek elemzésének nehézségeinek elkerülése érdekében elemezheti a dátum- és idősztringeket az invariáns kultúra használatával, vagy meghívhatja a ParseExact metódust, TryParseExact és megadhatja az elemezni kívánt sztring pontos formátumát. Ha dátum- és időadatokat szerializál és deszerializál, használhatja az invariáns kultúra formázási konvencióit, vagy szerializálhatja és deszerializálhatja az DateTime értéket bináris formátumban.

További információkért lásd a témakör "Dinamikus kulturális adatok" szakaszát CultureInfo és a témakör "DateTime-értékek megőrzése" című szakaszát DateTime .

Elemzési és stíluselemek

Minden Parse túlterhelés figyelmen kívül hagyja a bemeneti sztring kezdő, belső vagy záró szóköz karaktereit (amelyet az alábbi táblázat jelöl s ). A dátum és az idő zárójelbe állítható egy sornyi bevezető és záró SZÁMJEL karakterrel ("#", U+0023), és egy vagy több NULL karakterrel (U+0000) is lenyomható.

Emellett a Parse(String, IFormatProvider, DateTimeStyles) túlterhelésnek van egy styles paramétere, amely az DateTimeStyles enumerálás egy vagy több tagját tartalmazza. Ez a paraméter határozza meg, hogyan s kell értelmezni, és hogyan kell az elemzési műveletet dátummá és idővé alakítani s . Az alábbi táblázat az egyes DateTimeStyles tagok elemzési műveletre gyakorolt hatását ismerteti.

DateTimeStyles tagja Átalakítási hatás
AdjustToUniversal s Elemzi és szükség esetén UTC-vé alakítja át az alábbiak szerint:

- Ha s időzóna-eltolást tartalmaz, vagy ha s nem tartalmaz időzóna-információt, de styles tartalmazza a AssumeLocal jelölőt, a metódus elemzi a sztringet, meghívja ToUniversalTime a visszaadott DateTime értéket UTC-vé, és beállítja a Kind tulajdonságot DateTimeKind.Utc.
- Ha s azt jelzi, hogy az UTC-t jelöli, vagy ha s nem tartalmaz időzóna-információt, de styles tartalmazza a AssumeUniversal jelzőt, a metódus elemzi a sztringet, nem végez időzóna-átalakítást a visszaadott DateTime értéken, és a tulajdonságot a Kind következőre DateTimeKind.Utcállítja: .
- Minden más esetben a jelzőnek nincs hatása.
AllowInnerWhite Ezt az értéket a rendszer figyelmen kívül hagyja. A belső fehér tér mindig megengedett a dátum- és időelemekben s.
AllowLeadingWhite Ezt az értéket a rendszer figyelmen kívül hagyja. A kezdő szóköz mindig megengedett a dátum- és időelemekben s.
AllowTrailingWhite Ezt az értéket a rendszer figyelmen kívül hagyja. A záró szóköz mindig engedélyezett a dátum- és időelemekben s.
AllowWhiteSpaces Megadja, hogy a s tartalmazhat kezdő, belső és záró szóközöket. Ez az alapértelmezett viselkedés. Nem írható felül szigorúbb DateTimeStyles enumerálási értékkel, mint például a None.
AssumeLocal Azt adja meg, hogy ha s nem áll rendelkezésre időzóna-információ, akkor a helyi idő lesz feltételezve. Ha nincs megadva a AdjustToUniversal jelölő, a Kind visszaadott DateTime érték tulajdonsága a következőre DateTimeKind.Localvan állítva: .
AssumeUniversal Azt adja meg, hogy ha s nem áll rendelkezésre időzóna-információ, akkor az UTC-t kell feltételezni. Ha nincs megadva a AdjustToUniversal jelölő, a metódus a visszaadott DateTime értéket UTC-ről helyi időpontra konvertálja, és a tulajdonságát a következőre KindállítjaDateTimeKind.Local: .
None Bár érvényes, a rendszer figyelmen kívül hagyja ezt az értéket.
RoundtripKind Az időzóna-adatokat tartalmazó sztringek esetében megkísérli megakadályozni a dátum- és idősztringek olyan értékre DateTime való konvertálását, amely egy helyi időt jelöl, amelynek tulajdonsága Kind a következő DateTimeKind.Local. Az ilyen sztringek általában a DateTime.ToString(String) metódus meghívásával és az "o", "r" vagy "u" szabványos formátumkijelölő használatával jönnek létre.

A visszatérési érték és a DateTime.Kind

A DateTime.Parse túlterhelések olyan DateTime értéket adnak vissza, amelynek Kind tulajdonsága tartalmazza az időzóna adatait. Ez azt jelezheti, hogy az idő a következő:

A metódus általában egy Parse olyan objektumot ad vissza, DateTime amelynek Kind a tulajdonsága .DateTimeKind.Unspecified A módszer azonban időzóna-átalakítást is végrehajthat, Parse és a Kind tulajdonság értékét a paraméterek és s a paraméterek értékeitől styles függően eltérően állíthatja be:

Ha Időzóna-átalakítás Kind tulajdonság
s időzóna-információkat tartalmaz. A rendszer a dátumot és az időt a helyi időzónában lévő időpontra konvertálja. DateTimeKind.Local
s időzóna-információkat tartalmaz, és styles tartalmazza a jelölőt AdjustToUniversal . A dátum és az idő koordinált egyetemes idő (UTC) lesz. DateTimeKind.Utc
s A Z vagy GMT időzóna-tervezőt tartalmazza, és styles tartalmazza a jelölőt RoundtripKind . A dátumot és az időpontot a rendszer UTC-ként értelmezi. DateTimeKind.Utc

Az alábbi példa az időzóna adatait tartalmazó dátumsztringeket a helyi időzónában lévő időpontra alakítja át:

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

A formázási és elemzési művelet során a dátum- és időtulajdonság Kind értékét a jelölő használatával DateTimeStyles.RoundtripKind is megőrizheti. Az alábbi példa bemutatja, hogy a RoundtripKind jelölő hogyan befolyásolja az elemzési műveletet a sztringgé konvertált értékeken DateTime az "o", az "r" vagy az "u" formátumkijelölő használatával.

   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)

Forrás:
DateTime.cs
Forrás:
DateTime.cs
Forrás:
DateTime.cs
Forrás:
DateTime.cs
Forrás:
DateTime.cs

Egy dátum és idő DateTime sztringképét az aktuális kultúra konvencióinak használatával konvertálja annak megfelelővé.

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

Paraméterek

s
String

Egy sztring, amely dátumot és időt tartalmaz az átalakításhoz. További információt a elemezni kívánt sztringben talál.

Válaszok

DateTime

Olyan objektum, amely megegyezik a megadott dátummal és idővel s.

Kivételek

ArgumentNullException

s az null.

FormatException

s nem tartalmaz dátum és idő érvényes sztring-ábrázolását.

Példák

Az alábbi példa több dátum- és időérték sztringképét elemzi a következőképpen:

  • Az alapértelmezett formátumszolgáltató használata, amely a példakimenet létrehozásához használt számítógép jelenlegi kultúrájának formázási konvencióit biztosítja. A példában szereplő kimenet a en-US kultúra formázási konvencióit tükrözi.

  • Az alapértelmezett stílusértéket használja, amely a következő AllowWhiteSpaces: .

Kezeli azt a FormatException kivételt, amely akkor fordul elő, amikor a metódus más kulturális környezet formázási konvenciók használatával próbálja elemezni egy dátum és idő sztringképét. Azt is bemutatja, hogyan elemezhet sikeresen olyan dátum- és időértéket, amely nem használja az aktuális kultúra formázási konvencióit.

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.

Megjegyzések

Ha s időzónaadatokat tartalmaz, ez a metódus egy DateTime értéket ad vissza, amelynek Kind a tulajdonsága, DateTimeKind.Local és a dátumot és az időt s helyi idővé alakítja. Ellenkező esetben nem végez időzóna-átalakítást, és visszaad egy DateTime értéket, amelynek Kind a tulajdonsága .DateTimeKind.Unspecified

Ez a túlterhelés a jelenlegi kultúra formázási konvencióit használva próbál elemezni s . A jelenlegi kultúrát a CurrentCulture tulajdonság jelzi. Ha egy sztringet egy adott kultúra formázási konvencióit használva szeretne elemezni, hívja meg a Parse(String, IFormatProvider) túlterheléseket.Parse(String, IFormatProvider, DateTimeStyles)

Ez a túlterhelés stílussal s próbál elemezniDateTimeStyles.AllowWhiteSpaces.

Lásd még

A következőre érvényes:

Parse(ReadOnlySpan<Char>, IFormatProvider)

Forrás:
DateTime.cs
Forrás:
DateTime.cs
Forrás:
DateTime.cs
Forrás:
DateTime.cs
Forrás:
DateTime.cs

Több karakterből álló elemet elemez egy értékben.

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

Paraméterek

s
ReadOnlySpan<Char>

Az elemezni kívánt karakterek száma.

provider
IFormatProvider

Egy objektum, amely kultúraspecifikus formázási információkat tartalmaz a fájlról s.

Válaszok

DateTime

Az elemzés seredménye.

Megvalósítás

Parse(ReadOnlySpan<Char>, IFormatProvider)

A következőre érvényes:

Parse(String, IFormatProvider)

Forrás:
DateTime.cs
Forrás:
DateTime.cs
Forrás:
DateTime.cs
Forrás:
DateTime.cs
Forrás:
DateTime.cs

Egy dátum és idő sztring-ábrázolását átalakítja annak DateTime megfelelővé kultúraspecifikus formátuminformációk használatával.

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

Paraméterek

s
String

Egy sztring, amely dátumot és időt tartalmaz az átalakításhoz. További információt a elemezni kívánt sztringben talál.

provider
IFormatProvider

Egy objektum, amely a kultúraspecifikus formátuminformációkat startalmazza. Lásd: Elemzési és kulturális konvenciók

Válaszok

DateTime

Olyan objektum, amely megegyezik a megadott sdátummal és idővelprovider.

Megvalósítás

Parse(String, IFormatProvider)

Kivételek

ArgumentNullException

s az null.

FormatException

s nem tartalmaz dátum és idő érvényes sztring-ábrázolását.

Példák

Az alábbi példa a en-US, fr-FRés de-DE kultúrák konvencióinak használatával elemzi a dátumsztringek tömbét. Bemutatja, hogy egy dátum sztringreprezentációi eltérően értelmezhetők különböző kultúrákban.

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.

Megjegyzések

Ha s időzónaadatokat tartalmaz, ez a metódus egy DateTime értéket ad vissza, amelynek Kind a tulajdonsága, DateTimeKind.Local és a dátumot és az időt s helyi idővé alakítja. Ellenkező esetben nem végez időzóna-átalakítást, és visszaad egy DateTime értéket, amelynek Kind a tulajdonsága .DateTimeKind.Unspecified

Ez a túlterhelés a stílus használatával s próbál elemezniDateTimeStyles.AllowWhiteSpaces.

Lásd még

A következőre érvényes:

Parse(ReadOnlySpan<Char>, IFormatProvider, DateTimeStyles)

Forrás:
DateTime.cs
Forrás:
DateTime.cs
Forrás:
DateTime.cs
Forrás:
DateTime.cs
Forrás:
DateTime.cs

Olyan memóriatartományt alakít át, amely egy dátum és idő sztring-ábrázolását tartalmazza a DateTime megfelelőre a kultúraspecifikus formázási információk és formázási stílusok használatával.

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

Paraméterek

s
ReadOnlySpan<Char>

Az elemezni kívánt sztringet tartalmazó memóriatartomány. További információt a elemezni kívánt sztringben talál.

provider
IFormatProvider

Egy objektum, amely a kultúraspecifikus formátuminformációkat startalmazza. Lásd: Elemzési és kulturális konvenciók

styles
DateTimeStyles

Az enumerálási értékek bitenkénti kombinációja, amely jelzi az elemzési művelet sikeréhez használható s stíluselemeket, és meghatározza, hogyan értelmezhető az elemzési dátum az aktuális időzónához vagy az aktuális dátumhoz képest. Egy jellemzően megadható érték a következő None: .

Válaszok

DateTime

Olyan objektum, amely megegyezik a dátummal és az időponttals, amelyet az és providera .styles

Kivételek

FormatException

s nem tartalmaz dátum és idő érvényes sztring-ábrázolását.

ArgumentException

styles érvénytelen értékkombinációt DateTimeStyles tartalmaz. Például mindkettő AssumeLocal és AssumeUniversal.

A következőre érvényes:

Parse(String, IFormatProvider, DateTimeStyles)

Forrás:
DateTime.cs
Forrás:
DateTime.cs
Forrás:
DateTime.cs
Forrás:
DateTime.cs
Forrás:
DateTime.cs

Egy dátum és idő sztringképét átalakítja annak DateTime megfelelőjeként a kultúraspecifikus formátuminformációk és formázási stílusok használatával.

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

Paraméterek

s
String

Egy sztring, amely dátumot és időt tartalmaz az átalakításhoz. További információt a elemezni kívánt sztringben talál.

provider
IFormatProvider

Egy objektum, amely a kultúraspecifikus formázási sinformációkat tartalmazza. Lásd: Elemzési és kulturális konvenciók

styles
DateTimeStyles

Az enumerálási értékek bitenkénti kombinációja, amely jelzi az elemzési művelet sikeréhez használható s stíluselemeket, és meghatározza, hogyan értelmezhető az elemzési dátum az aktuális időzónához vagy az aktuális dátumhoz képest. Egy jellemzően megadható érték a következő None: .

Válaszok

DateTime

Olyan objektum, amely megegyezik a dátummal és az időponttals, amelyet az és providera .styles

Kivételek

ArgumentNullException

s az null.

FormatException

s nem tartalmaz dátum és idő érvényes sztring-ábrázolását.

ArgumentException

styles érvénytelen értékkombinációt DateTimeStyles tartalmaz. Például mindkettő AssumeLocal és AssumeUniversal.

Példák

Az alábbi példa bemutatja a Parse(String, IFormatProvider, DateTimeStyles) metódust, és megjeleníti az Kind eredményként kapott DateTime értékek tulajdonságának értékét.

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.

Megjegyzések

Ez a metódus túlterhelés átalakítja a dátumot és az időt, s és a Kind visszaadott DateTime érték tulajdonságát az alábbiak szerint állítja be:

Ha Időzóna-átalakítás Kind tulajdonság
s nem tartalmaz időzóna-információt. Nincs. DateTimeKind.Unspecified
s időzóna-információkat tartalmaz. A helyi időzónában megadott időpontra DateTimeKind.Local
s időzóna-információkat tartalmaz, és styles tartalmazza a jelölőt DateTimeStyles.AdjustToUniversal . Koordinált egyetemes idő (UTC) DateTimeKind.Utc
s tartalmazza a Z vagy GMT időzóna-tervezőt, és styles tartalmazza a DateTimeStyles.RoundtripKind. Nincs. DateTimeKind.Utc

Lásd még

A következőre érvényes: