DateTime.Parse Metoda
Definice
Důležité
Některé informace platí pro předběžně vydaný produkt, který se může zásadně změnit, než ho výrobce nebo autor vydá. Microsoft neposkytuje žádné záruky, výslovné ani předpokládané, týkající se zde uváděných informací.
Převede řetězcovou reprezentaci data a času na jeho DateTime ekvivalent.
Přetížení
| Parse(String) |
Převede řetězcovou reprezentaci data a času na jeho DateTime ekvivalent pomocí konvencí aktuální jazykové verze. |
| Parse(ReadOnlySpan<Char>, IFormatProvider) |
Parsuje rozsah znaků na hodnotu. |
| Parse(String, IFormatProvider) |
Převede řetězcovou reprezentaci data a času na jeho DateTime ekvivalent pomocí informací o formátu specifickém pro jazykovou verzi. |
| Parse(ReadOnlySpan<Char>, IFormatProvider, DateTimeStyles) |
Převede rozsah paměti, který obsahuje řetězcovou reprezentaci data a času, na jeho DateTime ekvivalent pomocí informací o formátu specifické pro jazykovou verzi a stylu formátování. |
| Parse(String, IFormatProvider, DateTimeStyles) |
Převede řetězcovou reprezentaci data a času na jeho DateTime ekvivalent pomocí informací o formátu specifickém pro jazykovou verzi a stylu formátování. |
Příklady
Mnoho příkladů, které volají metodu DateTime.Parse , jsou proloženy v části Poznámky tohoto článku a v dokumentaci k jednotlivým DateTime.Parse přetížením.
Poznámka
Některé příklady jazyka C# v tomto článku běží na Try.NET vloženého kódu a na dětském hřišti. Výběrem tlačítka Spustit spusťte příklad v interaktivním okně. Po spuštění kódu ho můžete upravit a spustit upravený kód tak, že znovu vyberete Spustit . Upravený kód se buď spustí v interaktivním okně, nebo v případě selhání kompilace se v interaktivním okně zobrazí všechny chybové zprávy kompilátoru jazyka C#.
Místní časové pásmoTry.NET vloženého běžce kódu a hřiště je Koordinovaný univerzální čas (UTC). To může ovlivnit chování a výstup příkladů, které ilustrují DateTimetypy , DateTimeOffseta TimeZoneInfo a jejich členy.
Můžete si také stáhnout kompletní sadu DateTime.Parse příkladů, které jsou součástí projektu .NET Core pro jazyk C#.
Poznámky
V této části:
- Jakou metodu mám volat?
- Řetězec určený k analýze
- Analýzy a kulturní konvence
- Analýza a elementy stylu
- Vrácená hodnota a DateTime.Kind
Jakou metodu mám volat?
| Záměr | Call |
|---|---|
| Parsujte řetězec data a času pomocí konvencí aktuální jazykové verze. | Parse(String) Přetížení |
| Parsujte řetězec data a času pomocí konvencí konkrétní jazykové verze. | Parse(String, IFormatProvider) přetížení (viz Parsování a kulturní konvence) |
| Parsování řetězce data a času se speciálními prvky stylu (například prázdnými znaky nebo bez prázdných znaků). | Parse(String, IFormatProvider, DateTimeStyles) Přetížení |
| Parsuje řetězec data a času, který musí být v určitém formátu. | DateTime.ParseExact nebo DateTime.TryParseExact |
| Parsovat řetězec data a času a provést převod na UTC nebo místní čas. | Parse(String, IFormatProvider, DateTimeStyles) Přetížení |
| Parsuje řetězec data a času bez zpracování výjimek. | Metoda DateTime.TryParse |
| Obnovení (doby odezvy) hodnoty data a času vytvořené operací formátování | Předejte do metody řetězec ToString(String) standardního formátu "o" nebo "r" a zavolejte Parse(String, IFormatProvider, DateTimeStyles) přetížení pomocí DateTimeStyles.RoundtripKind |
| Parsuje řetězec data a času v pevném formátu napříč strojovými (a případně kulturními) hranicemi. | DateTime.ParseExact nebo DateTime.TryParseExact metoda |
Řetězec určený k analýze
Metoda Parse se pokusí převést řetězcové vyjádření hodnoty data a času na její DateTime ekvivalent. Pokusí se zcela analyzovat vstupní řetězec bez vyvolání FormatException výjimky.
Důležité
Pokud se operace analýzy nezdaří kvůli nerozpoznanému formátu řetězce, Parse metoda vyvolá FormatException, zatímco TryParse metoda vrátí false. Vzhledem k tomu, že zpracování výjimek může být nákladné, měli byste použít Parse , když se očekává, že operace analýzy bude úspěšná, protože vstupní zdroj je důvěryhodný. TryParse je vhodnější, pokud jsou pravděpodobné chyby analýzy, zejména proto, že vstupní zdroj není důvěryhodný, nebo máte přiměřené výchozí hodnoty, které můžete nahradit řetězce, které se úspěšně neanalyzují.
Řetězec, který se má analyzovat, může mít některou z následujících forem:
Řetězec s datem a časovou komponentou.
Řetězec s datem, ale bez časové komponenty. Pokud komponenta času chybí, metoda předpokládá 12:00 půlnoci. Pokud má komponenta data dvoumístný rok, převede se na rok na Calendar.TwoDigitYearMax základě aktuálního kalendáře aktuální jazykové verze nebo aktuálního kalendáře zadané jazykové verze (pokud použijete přetížení s argumentem, který není null
provider).Řetězec s komponentou data, která obsahuje pouze měsíc a rok, ale neobsahuje komponentu dne. Metoda předpokládá první den v měsíci.
Řetězec s datem, který obsahuje pouze měsíc a den, ale ne rok. Metoda předpokládá aktuální rok.
Řetězec s časovým prvkem, ale bez data. Metoda předpokládá aktuální datum, pokud nevoláte Parse(String, IFormatProvider, DateTimeStyles) přetížení a nezahrnete DateTimeStyles.NoCurrentDateDefault do argumentu
styles. V takovém případě metoda předpokládá datum 1. ledna 0001.Řetězec s časovou složkou, která obsahuje pouze hodinu a označení do hodiny a odpoledne, bez komponenty data. Metoda předpokládá aktuální datum a čas bez minut a bez sekund. Toto chování můžete změnit voláním Parse(String, IFormatProvider, DateTimeStyles) přetížení a zahrnutím DateTimeStyles.NoCurrentDateDefault do argumentu
styles. V takovém případě metoda předpokládá datum 1. ledna 0001.Řetězec, který obsahuje informace o časovém pásmu a odpovídá normě ISO 8601. V následujících příkladech první řetězec označuje koordinovaný univerzální čas (UTC) a druhý označuje čas v časovém pásmu, které je o sedm hodin starší než UTC:
"2008-11-01T19:35:00.0000000Z" "2008-11-01T19:35:00.000000-07:00"
Řetězec, který obsahuje označení GMT a odpovídá formátu RFC 1123; Příklad:
"So, 01 Nov 2008 19:35:00 GMT"
Řetězec, který obsahuje datum a čas spolu s informacemi o posunu časového pásma; Příklad:
"03/01/2009 05:42:00 -5:00"
Následující příklad analyzuje řetězce v každém z těchto formátů pomocí konvencí formátování aktuální jazykové verze, což je v tomto případě jazyková verze 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
Pokud vstupní řetězec představuje přestupný den v přestupném roce v kalendáři používaném metodou analýzy (viz Parsování a kulturní konvence), Parse metoda úspěšně analyzuje řetězec. Pokud vstupní řetězec představuje přestupný den v ne přestupném roce, metoda vyvolá FormatException.
Vzhledem k tomu, že Parse metoda se pokouší parsovat řetězcovou reprezentaci data a času pomocí pravidel formátování aktuální nebo zadané jazykové verze, pokus o analýzu řetězce v různých jazykových verzích může selhat. Chcete-li analyzovat konkrétní formát data a času v různých národních prostředích, použijte jedno z přetížení DateTime.ParseExact metody a zadejte specifikátor formátu.
Analýzy a kulturní konvence
Všechna přetížení Parse metody jsou závislá na jazykové verzi, pokud řetězec, který se má analyzovat (který je reprezentován v s následující tabulce), neodpovídá vzoru ISO 8601. Operace parsování používá informace o formátování v objektu DateTimeFormatInfo , který je odvozen následujícím způsobem:
Důležité
Éry v japonských kalendářích jsou založeny na vládě císaře, a proto se očekává, že se změní. Například 1. května 2019 bylo začátkem éry Reiwa v JapaneseCalendar a JapaneseLunisolarCalendar. Taková změna éry ovlivní všechny aplikace, které tyto kalendáře používají. Další informace a informace o tom, jestli se to týká vašich aplikací, najdete v tématu Zpracování nové éry v japonském kalendáři v .NET. Informace o testování aplikací v systémech Windows, abyste zajistili jejich připravenost na změnu éry, najdete v tématu Příprava aplikace na změnu japonské éry. Funkce v .NET, které podporují kalendáře s více érami, a osvědčené postupy při práci s kalendáři, které podporují více ér, najdete v tématu Práce s érami.
| Pokud voláte | A provider je |
Informace o formátování jsou odvozeny z |
|---|---|---|
| Parse(String) | - | Aktuální jazyková verze (DateTimeFormatInfo.CurrentInfo vlastnost) |
| Parse(String, IFormatProvider) nebo Parse(String, IFormatProvider, DateTimeStyles) | objekt DateTimeFormatInfo | Zadaný DateTimeFormatInfo objekt |
| Parse(String, IFormatProvider) nebo Parse(String, IFormatProvider, DateTimeStyles) | null |
Aktuální jazyková verze (DateTimeFormatInfo.CurrentInfo vlastnost) |
| Parse(String, IFormatProvider) nebo Parse(String, IFormatProvider, DateTimeStyles) | objekt CultureInfo | Vlastnost CultureInfo.DateTimeFormat |
| Parse(String, IFormatProvider) nebo Parse(String, IFormatProvider, DateTimeStyles) | Vlastní IFormatProvider implementace | Metoda IFormatProvider.GetFormat |
Když jsou informace o formátování odvozeny z objektu DateTimeFormatInfoDateTimeFormatInfo.Calendar , vlastnost definuje kalendář použitý v operaci analýzy.
Pokud analyzujete řetězec data a času pomocí objektu DateTimeFormatInfo s přizpůsobeným nastavením, které se liší od nastavení standardní jazykové verze, použijte metodu ParseExact místo Parse metody , aby se zlepšila šance na úspěšný převod. Nestandardní řetězec data a času může být složitý a obtížně se parsuje. Metoda Parse se pokusí parsovat řetězec s několika implicitními vzory analýzy, z nichž všechny můžou selhat. Naproti tomu metoda vyžaduje, ParseExact abyste explicitně určili jeden nebo více přesných vzorů analýzy, které budou pravděpodobně úspěšné. Další informace najdete v části DateTimeFormatInfo a dynamická data v tomto DateTimeFormatInfo tématu.
Důležité
Konvence formátování pro konkrétní jazykovou verzi jsou dynamické a můžou se měnit. To znamená, že operace analýzy, které závisí na konvencích formátování výchozí (aktuální) jazykové verze nebo které určují IFormatProvider objekt, který představuje jinou jazykovou verzi než neutrální jazykovou verzi, můžou neočekávaně selhat, pokud dojde k některé z následujících akcí:
- Data specifická pro jazykovou verzi se změnila mezi hlavními verzemi nebo podverzí rozhraní .NET Framework nebo v důsledku aktualizace stávající verze rozhraní .NET Framework.
- Data specifická pro jazykovou verzi odrážejí uživatelské předvolby, které se můžou lišit v jednotlivých počítačích nebo relacích.
- Data specifická pro jazykovou verzi představují náhradní jazykovou verzi, která přepíše nastavení standardní jazykové verze nebo vlastní jazykové verze.
Chcete-li zabránit potížím při analýze dat a časových řetězců, které jsou spojeny se změnami v kulturních datech, můžete analyzovat řetězce data a času pomocí invariantní jazykové verze, nebo můžete zavolat metodu ParseExact nebo TryParseExact a určit přesný formát řetězce, který se má analyzovat. Pokud serializujete a deserializujete data data a času, můžete buď použít konvence formátování invariantní jazykové verze, nebo můžete serializovat a deserializovat DateTime hodnotu v binárním formátu.
Další informace najdete v části Data dynamické jazykové verze v CultureInfo tématu a v části "Zachování hodnot DateTime" v DateTime tématu.
Analýza a elementy stylu
Všechna Parse přetížení ignorují počáteční, vnitřní nebo koncové prázdné znaky ve vstupním řetězci (který je reprezentován s v následující tabulce). Datum a čas může být v hranatých závorkách s dvojicí počátečních a koncových znaků ZNAMÉNKA ČÍSLA ("#", U+0023) a na konci může být jeden nebo více znaků NULL (U+0000).
Kromě toho má styles přetížení parametr, Parse(String, IFormatProvider, DateTimeStyles) který se skládá z jednoho nebo více členů výčtuDateTimeStyles. Tento parametr definuje, jak s se má interpretovat a jak se má operace analýzy převést s na datum a čas. Následující tabulka popisuje vliv jednotlivých DateTimeStyles členů na operaci analýzy.
| Člen DateTimeStyles | Vliv na převod |
|---|---|
| AdjustToUniversal | Parsuje s ho a v případě potřeby převede na UTC následujícím způsobem:- Pokud s obsahuje posun časového pásma nebo pokud s neobsahuje žádné informace o časovém pásmu, ale styles obsahuje AssumeLocal příznak, metoda analyzuje řetězec, zavolá ToUniversalTime převést vrácenou DateTime hodnotu na UTC a nastaví Kind vlastnost na DateTimeKind.Utc.- Pokud s označuje, že představuje UTC, nebo pokud s neobsahuje informace o časovém pásmu, ale styles obsahuje AssumeUniversal příznak, metoda parsuje řetězec, neprovádí žádný převod časového pásma na vrácenou DateTime hodnotu a nastaví Kind vlastnost na DateTimeKind.Utc.- Ve všech ostatních případech nemá příznak žádný účinek. |
| AllowInnerWhite | Tato hodnota je ignorována. Vnitřní prázdné znaky jsou vždy povoleny v elementech data a času v nástroji s. |
| AllowLeadingWhite | Tato hodnota je ignorována. Počáteční prázdné znaky jsou vždy povoleny v datech a časech elementu s. |
| AllowTrailingWhite | Tato hodnota je ignorována. Koncové prázdné znaky jsou vždy povoleny v date a time elementu s. |
| AllowWhiteSpaces | Určuje, že s může obsahovat počáteční, vnitřní a koncové prázdné znaky. Toto je výchozí chování. Nelze ji přepsat zadáním přísnější DateTimeStyles hodnoty výčtu, například None. |
| AssumeLocal | Určuje, že pokud s chybí informace o časovém pásmu, předpokládá se místní čas. Pokud není AdjustToUniversal příznak k dispozici, Kind vlastnost vrácené DateTime hodnoty je nastavena na DateTimeKind.Local. |
| AssumeUniversal | Určuje, že pokud s chybí informace o časovém pásmu, předpokládá se UTC. AdjustToUniversal Pokud není příznak k dispozici, metoda převede vrácenou DateTime hodnotu z UTC na místní čas a nastaví její Kind vlastnost na DateTimeKind.Local. |
| None | Přestože je tato hodnota platná, je ignorována. |
| RoundtripKind | U řetězců, které obsahují informace o časovém pásmu, se pokusí zabránit převodu řetězce data a času na hodnotu, která představuje místní čas s jeho Kind vlastností nastavenou DateTime na DateTimeKind.Local. Obvykle se takový řetězec vytvoří voláním DateTime.ToString(String) metody a pomocí specifikátoru standardního formátu "o", "r" nebo "u". |
Vrácená hodnota a DateTime.Kind
Přetížení DateTime.Parse vrátí hodnotu, DateTime jejíž Kind vlastnost zahrnuje informace o časovém pásmu. Může to znamenat, že čas je:
- Koordinovaný světový čas (System.DateTimeKind.Utc).
- Čas v místním časovém pásmu (System.DateTimeKind.Local).
- Čas v neznámém časovém pásmu (System.DateTimeKind.Unspecified).
Obecně platí, že Parse metoda vrátí DateTime objekt, jehož Kind vlastnost je DateTimeKind.Unspecified. Metoda však Parse může také provést převod časového pásma a nastavit hodnotu Kind vlastnosti odlišně v závislosti na hodnotách s parametrů a styles :
| Pokud uživatel | Převod časového pásma | Vlastnost Kind |
|---|---|---|
s obsahuje informace o časovém pásmu. |
Datum a čas se převedou na čas v místním časovém pásmu. | DateTimeKind.Local |
s obsahuje informace o časovém pásmu a styles obsahuje AdjustToUniversal příznak. |
Datum a čas se převedou na utc (Coordinated Universal Time). | DateTimeKind.Utc |
s obsahuje označení časového pásma Z nebo GMT a styles obsahuje RoundtripKind příznak. |
Datum a čas se interpretují jako UTC. | DateTimeKind.Utc |
Následující příklad převede řetězce kalendářních dat, které obsahují informace o časovém pásmu, na čas v místním časovém pásmu:
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
Pomocí příznaku můžete také zachovat hodnotu vlastnosti data a času Kind během operace DateTimeStyles.RoundtripKind formátování a analýzy. Následující příklad ukazuje, jak RoundtripKind příznak ovlivňuje operaci parsování hodnot, které jsou převedeny na DateTime řetězce pomocí specifikátoru formátu "o", "r" nebo "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)
- Source:
- DateTime.cs
- Source:
- DateTime.cs
- Source:
- DateTime.cs
Převede řetězcovou reprezentaci data a času na jeho DateTime ekvivalent pomocí konvencí aktuální jazykové verze.
public:
static DateTime Parse(System::String ^ s);public static DateTime Parse (string s);static member Parse : string -> DateTimePublic Shared Function Parse (s As String) As DateTimeParametry
- s
- String
Řetězec, který obsahuje datum a čas k převedení. Další informace najdete v tématu Řetězec k analýze .
Návraty
Objekt, který odpovídá datu a času obsaženému v objektu s.
Výjimky
s je null.
s neobsahuje platnou řetězcovou reprezentaci data a času.
Příklady
Následující příklad parsuje řetězcovou reprezentaci několika hodnot data a času podle:
Použití výchozího zprostředkovatele formátu, který poskytuje konvence formátování aktuální jazykové verze počítače použité k vytvoření ukázkového výstupu. Výstup z tohoto příkladu odráží konvence formátování jazykové verze en-US.
Použití výchozí hodnoty stylu, což je AllowWhiteSpaces.
FormatException Zpracovává výjimku, která je vyvolán, když se metoda pokusí parsovat řetězcovou reprezentaci data a času pomocí jiných konvencí formátování jazykové verze. Ukazuje také, jak úspěšně parsovat hodnotu data a času, která nepoužívá konvence formátování aktuální jazykové verze.
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.
Poznámky
Pokud s obsahuje informace o časovém pásmu, vrátí DateTime tato metoda hodnotu, jejíž Kind vlastnost je DateTimeKind.Local , a převede datum a čas na s místní čas. V opačném případě neprovádí převod časového pásma a vrátí DateTime hodnotu, jejíž Kind vlastnost je DateTimeKind.Unspecified.
Toto přetížení se pokusí analyzovat s pomocí konvencí formátování aktuální jazykové verze. Aktuální jazyková verze je označena CurrentCulture vlastností. Chcete-li analyzovat řetězec pomocí konvencí formátování konkrétní jazykové verze, zavolejte Parse(String, IFormatProvider) přetížení nebo Parse(String, IFormatProvider, DateTimeStyles) .
Toto přetížení se pokusí analyzovat s pomocí DateTimeStyles.AllowWhiteSpaces stylu.
Viz také
- TryParse
- CultureInfo
- DateTimeFormatInfo
- Analýza řetězců data a času v .NET Frameworku
- Standardní řetězce formátu data a času
- Vlastní řetězce formátu data a času
Platí pro
Parse(ReadOnlySpan<Char>, IFormatProvider)
- Source:
- DateTime.cs
- Source:
- DateTime.cs
- Source:
- DateTime.cs
Parsuje rozsah znaků na hodnotu.
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 -> DateTimePublic Shared Function Parse (s As ReadOnlySpan(Of Char), provider As IFormatProvider) As DateTimeParametry
- s
- ReadOnlySpan<Char>
Rozsah znaků, které se mají analyzovat.
- provider
- IFormatProvider
Objekt, který poskytuje informace o formátování specifické pro jazykovou verzi .s
Návraty
Výsledek analýzy s.
Implementuje
Platí pro
Parse(String, IFormatProvider)
- Source:
- DateTime.cs
- Source:
- DateTime.cs
- Source:
- DateTime.cs
Převede řetězcovou reprezentaci data a času na jeho DateTime ekvivalent pomocí informací o formátu specifickém pro jazykovou verzi.
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 -> DateTimePublic Shared Function Parse (s As String, provider As IFormatProvider) As DateTimeParametry
- s
- String
Řetězec, který obsahuje datum a čas k převedení. Další informace najdete v tématu Řetězec k analýze .
- provider
- IFormatProvider
Objekt, který poskytuje informace o formátu specifickém pro jazykovou verzi .s Viz Parsování a kulturní konvence.
Návraty
Objekt, který je ekvivalentní k datu a času obsaženému v, jak je uvedeno v sprovider.
Implementuje
Výjimky
s je null.
s neobsahuje platnou řetězcovou reprezentaci data a času.
Příklady
Následující příklad parsuje pole datových řetězců pomocí konvencí jazykových verzí en-US, fr-FR a de-DE. Ukazuje, že řetězcové reprezentace jednoho data mohou být interpretovány odlišně v různých jazykových verzích.
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.
Poznámky
Pokud s obsahuje informace o časovém pásmu, vrátí DateTime tato metoda hodnotu, jejíž Kind vlastnost je DateTimeKind.Local , a převede datum a čas na s místní čas. V opačném případě neprovádí převod časového pásma a vrátí DateTime hodnotu, jejíž Kind vlastnost je DateTimeKind.Unspecified.
Toto přetížení se pokusí analyzovat s pomocí DateTimeStyles.AllowWhiteSpaces stylu.
Viz také
- TryParse
- CultureInfo
- DateTimeFormatInfo
- Analýza řetězců data a času v .NET Frameworku
- Standardní řetězce formátu data a času
- Vlastní řetězce formátu data a času
Platí pro
Parse(ReadOnlySpan<Char>, IFormatProvider, DateTimeStyles)
- Source:
- DateTime.cs
- Source:
- DateTime.cs
- Source:
- DateTime.cs
Převede rozsah paměti, který obsahuje řetězcovou reprezentaci data a času, na jeho DateTime ekvivalent pomocí informací o formátu specifické pro jazykovou verzi a stylu formátování.
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 -> DateTimePublic Shared Function Parse (s As ReadOnlySpan(Of Char), Optional provider As IFormatProvider = Nothing, Optional styles As DateTimeStyles = System.Globalization.DateTimeStyles.None) As DateTimeParametry
- s
- ReadOnlySpan<Char>
Rozsah paměti, který obsahuje řetězec, který se má analyzovat. Další informace najdete v tématu Řetězec k analýze .
- provider
- IFormatProvider
Objekt, který poskytuje informace o formátu specifickém pro jazykovou verzi .s Viz Parsování a kulturní konvence.
- styles
- DateTimeStyles
Bitové kombinace hodnot výčtu, která označuje prvky stylu, které mohou být přítomny pro s úspěšnou operaci parse, a definuje, jak interpretovat analyzované datum ve vztahu k aktuálnímu časovému pásmu nebo aktuálnímu datu. Typická hodnota, která se má zadat, je None.
Návraty
Objekt, který odpovídá datu a času obsaženému v objektu , jak je uvedeno v sprovider a styles.
Výjimky
s neobsahuje platnou řetězcovou reprezentaci data a času.
styles obsahuje neplatnou kombinaci DateTimeStyles hodnot. Například a AssumeLocalAssumeUniversal.
Platí pro
Parse(String, IFormatProvider, DateTimeStyles)
- Source:
- DateTime.cs
- Source:
- DateTime.cs
- Source:
- DateTime.cs
Převede řetězcovou reprezentaci data a času na jeho DateTime ekvivalent pomocí informací o formátu specifické pro jazykovou verzi a stylu formátování.
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 -> DateTimePublic Shared Function Parse (s As String, provider As IFormatProvider, styles As DateTimeStyles) As DateTimeParametry
- s
- String
Řetězec, který obsahuje datum a čas k převedení. Další informace najdete v tématu Řetězec k analýze .
- provider
- IFormatProvider
Objekt, který poskytuje informace o formátování specifické pro jazykovou verzi .s Viz Parsování a kulturní konvence.
- styles
- DateTimeStyles
Bitové kombinace hodnot výčtu, která označuje prvky stylu, které mohou být přítomny pro s úspěšnou operaci parse, a definuje, jak interpretovat analyzované datum ve vztahu k aktuálnímu časovému pásmu nebo aktuálnímu datu. Typická hodnota, která se má zadat, je None.
Návraty
Objekt, který odpovídá datu a času obsaženému v objektu , jak je uvedeno v sprovider a styles.
Výjimky
s je null.
s neobsahuje platnou řetězcovou reprezentaci data a času.
styles obsahuje neplatnou kombinaci DateTimeStyles hodnot. Například a AssumeLocalAssumeUniversal.
Příklady
Následující příklad ukazuje metodu Parse(String, IFormatProvider, DateTimeStyles) a zobrazuje hodnotu Kind vlastnosti výsledných DateTime hodnot.
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.
Poznámky
Přetížení této metody převede datum a čas v s a nastaví Kind vlastnost vrácené DateTime hodnoty následujícím způsobem:
| Pokud uživatel | Převod časového pásma | Vlastnost Kind |
|---|---|---|
s neobsahuje žádné informace o časovém pásmu. |
Žádné | DateTimeKind.Unspecified |
s obsahuje informace o časovém pásmu. |
K času v místním časovém pásmu | DateTimeKind.Local |
s obsahuje informace o časovém pásmu a styles obsahuje DateTimeStyles.AdjustToUniversal příznak. |
Do koordinovaného univerzálního času (UTC) | DateTimeKind.Utc |
sobsahuje označení časového pásma Z nebo GMT a styles obsahuje .DateTimeStyles.RoundtripKind |
Žádné | DateTimeKind.Utc |
Viz také
- TryParse
- CultureInfo
- DateTimeFormatInfo
- Analýza řetězců data a času v .NET Frameworku
- Standardní řetězce formátu data a času
- Vlastní řetězce formátu data a času
- Postupy: Hodnoty data a doby odezvy
Platí pro
Váš názor
Připravujeme: V průběhu roku 2024 budeme postupně vyřazovat problémy z GitHub coby mechanismus zpětné vazby pro obsah a nahrazovat ho novým systémem zpětné vazby. Další informace naleznete v tématu: https://aka.ms/ContentUserFeedback.
Odeslat a zobrazit názory pro