DateTime.ParseExact 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 zadanou řetězcovou reprezentaci data a času na jeho DateTime ekvivalent. Formát řetězcové reprezentace se musí přesně shodovat se zadaným formátem, jinak dojde k výjimce.
Přetížení
ParseExact(String, String, IFormatProvider) |
Převede zadanou řetězcovou reprezentaci data a času na jeho DateTime ekvivalent pomocí zadaného formátu a informací o formátu specifickém pro jazykovou verzi. Formát řetězcového vyjádření musí přesně odpovídat určenému formátu. |
ParseExact(ReadOnlySpan<Char>, ReadOnlySpan<Char>, IFormatProvider, DateTimeStyles) |
Převede zadanou reprezentaci rozsahu data a času na jeho DateTime ekvivalent pomocí zadaného formátu, informací o formátu specifickém pro jazykovou verzi a stylu. Formát řetězcové reprezentace musí přesně odpovídat zadanému formátu, jinak dojde k výjimce. |
ParseExact(ReadOnlySpan<Char>, String[], IFormatProvider, DateTimeStyles) |
Převede zadanou reprezentaci rozsahu data a času na jeho DateTime ekvivalent pomocí zadané pole formátů, informací o formátu specifické pro jazykovou verzi a stylu. Formát řetězcové reprezentace musí přesně odpovídat alespoň jednomu ze zadaných formátů nebo je vyvolán výjimka. |
ParseExact(String, String, IFormatProvider, DateTimeStyles) |
Převede zadanou řetězcovou reprezentaci data a času na jeho DateTime ekvivalent pomocí zadaného formátu, informací o formátu specifickém pro jazykovou verzi a stylu. Formát řetězcové reprezentace musí přesně odpovídat zadanému formátu, jinak dojde k výjimce. |
ParseExact(String, String[], IFormatProvider, DateTimeStyles) |
Převede zadanou řetězcovou reprezentaci data a času na jeho DateTime ekvivalent pomocí zadané pole formátů, informací o formátu specifické pro jazykovou verzi a stylu. Formát řetězcové reprezentace musí přesně odpovídat alespoň jednomu ze zadaných formátů nebo je vyvolán výjimka. |
Poznámky
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 byl začátek é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 pro zajištění jejich připravenosti 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.
ParseExact(String, String, IFormatProvider)
- Zdroj:
- DateTime.cs
- Zdroj:
- DateTime.cs
- Zdroj:
- DateTime.cs
Převede zadanou řetězcovou reprezentaci data a času na jeho DateTime ekvivalent pomocí zadaného formátu a informací o formátu specifickém pro jazykovou verzi. Formát řetězcového vyjádření musí přesně odpovídat určenému formátu.
public:
static DateTime ParseExact(System::String ^ s, System::String ^ format, IFormatProvider ^ provider);
public static DateTime ParseExact (string s, string format, IFormatProvider provider);
public static DateTime ParseExact (string s, string format, IFormatProvider? provider);
static member ParseExact : string * string * IFormatProvider -> DateTime
Public Shared Function ParseExact (s As String, format As String, provider As IFormatProvider) As DateTime
Parametry
- s
- String
Řetězec, který obsahuje datum a čas k převedení.
- format
- String
Specifikátor formátu, který definuje požadovaný formát souboru s
. Další informace najdete v části Poznámky.
- provider
- IFormatProvider
Objekt, který poskytuje informace o formátu specifickém pro jazykovou verzi .s
Návraty
Objekt, který odpovídá datu a času obsaženému v objektu , jak je uvedeno v s
format
a provider
.
Výjimky
s
nebo format
je null
.
s
nebo format
je prázdný řetězec.
-nebo-
s
neobsahuje datum a čas, které odpovídají vzoru zadanému v nástroji format
.
-nebo-
Hodinová komponenta a označení do hodiny a odpoledne v s
systému nesouhlasí.
Příklady
Následující příklad ukazuje metodu ParseExact .
using System;
using System.Globalization;
public class Example
{
public static void Main()
{
string dateString, format;
DateTime result;
CultureInfo provider = CultureInfo.InvariantCulture;
// Parse date-only value with invariant culture.
dateString = "06/15/2008";
format = "d";
try {
result = DateTime.ParseExact(dateString, format, provider);
Console.WriteLine("{0} converts to {1}.", dateString, result.ToString());
}
catch (FormatException) {
Console.WriteLine("{0} is not in the correct format.", dateString);
}
// Parse date-only value without leading zero in month using "d" format.
// Should throw a FormatException because standard short date pattern of
// invariant culture requires two-digit month.
dateString = "6/15/2008";
try {
result = DateTime.ParseExact(dateString, format, provider);
Console.WriteLine("{0} converts to {1}.", dateString, result.ToString());
}
catch (FormatException) {
Console.WriteLine("{0} is not in the correct format.", dateString);
}
// Parse date and time with custom specifier.
dateString = "Sun 15 Jun 2008 8:30 AM -06:00";
format = "ddd dd MMM yyyy h:mm tt zzz";
try {
result = DateTime.ParseExact(dateString, format, provider);
Console.WriteLine("{0} converts to {1}.", dateString, result.ToString());
}
catch (FormatException) {
Console.WriteLine("{0} is not in the correct format.", dateString);
}
// Parse date and time with offset but without offset's minutes.
// Should throw a FormatException because "zzz" specifier requires leading
// zero in hours.
dateString = "Sun 15 Jun 2008 8:30 AM -06";
try {
result = DateTime.ParseExact(dateString, format, provider);
Console.WriteLine("{0} converts to {1}.", dateString, result.ToString());
}
catch (FormatException) {
Console.WriteLine("{0} is not in the correct format.", dateString);
}
dateString = "15/06/2008 08:30";
format = "g";
provider = new CultureInfo("fr-FR");
try {
result = DateTime.ParseExact(dateString, format, provider);
Console.WriteLine("{0} converts to {1}.", dateString, result.ToString());
}
catch (FormatException) {
Console.WriteLine("{0} is not in the correct format.", dateString);
}
// Parse a date that includes seconds and milliseconds
// by using the French (France) and invariant cultures.
dateString = "18/08/2015 06:30:15.006542";
format = "dd/MM/yyyy HH:mm:ss.ffffff";
try {
result = DateTime.ParseExact(dateString, format, provider);
Console.WriteLine("{0} converts to {1}.", dateString, result.ToString());
}
catch (FormatException) {
Console.WriteLine("{0} is not in the correct format.", dateString);
}
}
}
// The example displays the following output:
// 06/15/2008 converts to 6/15/2008 12:00:00 AM.
// 6/15/2008 is not in the correct format.
// Sun 15 Jun 2008 8:30 AM -06:00 converts to 6/15/2008 7:30:00 AM.
// Sun 15 Jun 2008 8:30 AM -06 is not in the correct format.
// 15/06/2008 08:30 converts to 6/15/2008 8:30:00 AM.
// 18/08/2015 06:30:15.006542 converts to 8/18/2015 6:30:15 AM.
open System
open System.Globalization
[<EntryPoint>]
let main _ =
let provider = CultureInfo.InvariantCulture
// Parse date-only value with invariant culture.
let dateString = "06/15/2008"
let format = "d"
try
let result = DateTime.ParseExact(dateString, format, provider)
printfn $"{dateString} converts to {result}."
with :? FormatException ->
printfn $"{dateString} is not in the correct format."
// Parse date-only value without leading zero in month using "d" format.
// Should throw a FormatException because standard short date pattern of
// invariant culture requires two-digit month.
let dateString = "6/15/2008"
try
let result = DateTime.ParseExact(dateString, format, provider)
printfn $"{dateString} converts to {result}."
with :? FormatException ->
printfn $"{dateString} is not in the correct format."
// Parse date and time with custom specifier.
let dateString = "Sun 15 Jun 2008 8:30 AM -06:00"
let format = "ddd dd MMM yyyy h:mm tt zzz"
try
let result = DateTime.ParseExact(dateString, format, provider)
printfn $"{dateString} converts to {result}."
with :? FormatException ->
printfn $"{dateString} is not in the correct format."
// Parse date and time with offset but without offset's minutes.
// Should throw a FormatException because "zzz" specifier requires leading
// zero in hours.
let dateString = "Sun 15 Jun 2008 8:30 AM -06"
try
let result = DateTime.ParseExact(dateString, format, provider)
printfn $"{dateString} converts to {result}."
with :? FormatException ->
printfn $"{dateString} is not in the correct format."
let dateString = "15/06/2008 08:30"
let format = "g"
let provider = CultureInfo "fr-FR"
try
let result = DateTime.ParseExact(dateString, format, provider)
printfn $"{dateString} converts to {result}."
with :? FormatException ->
printfn $"{dateString} is not in the correct format."
// Parse a date that includes seconds and milliseconds
// by using the French (France) and invariant cultures.
let dateString = "18/08/2015 06:30:15.006542"
let format = "dd/MM/yyyy HH:mm:ss.ffffff"
try
let result = DateTime.ParseExact(dateString, format, provider)
printfn $"{dateString} converts to {result}."
with :? FormatException ->
printfn $"{dateString} is not in the correct format."
0
// The example displays the following output:
// 06/15/2008 converts to 6/15/2008 12:00:00 AM.
// 6/15/2008 is not in the correct format.
// Sun 15 Jun 2008 8:30 AM -06:00 converts to 6/15/2008 7:30:00 AM.
// Sun 15 Jun 2008 8:30 AM -06 is not in the correct format.
// 15/06/2008 08:30 converts to 6/15/2008 8:30:00 AM.
// 18/08/2015 06:30:15.006542 converts to 8/18/2015 6:30:15 AM.
Imports System.Globalization
Module Example
Public Sub Main()
Dim dateString, format As String
Dim result As Date
Dim provider As CultureInfo = CultureInfo.InvariantCulture
' Parse date-only value with invariant culture.
dateString = "06/15/2008"
format = "d"
Try
result = Date.ParseExact(dateString, format, provider)
Console.WriteLine("{0} converts to {1}.", dateString, result.ToString())
Catch e As FormatException
Console.WriteLine("{0} is not in the correct format.", dateString)
End Try
' Parse date-only value without leading zero in month using "d" format.
' Should throw a FormatException because standard short date pattern of
' invariant culture requires two-digit month.
dateString = "6/15/2008"
Try
result = Date.ParseExact(dateString, format, provider)
Console.WriteLine("{0} converts to {1}.", dateString, result.ToString())
Catch e As FormatException
Console.WriteLine("{0} is not in the correct format.", dateString)
End Try
' Parse date and time with custom specifier.
dateString = "Sun 15 Jun 2008 8:30 AM -06:00"
format = "ddd dd MMM yyyy h:mm tt zzz"
Try
result = Date.ParseExact(dateString, format, provider)
Console.WriteLine("{0} converts to {1}.", dateString, result.ToString())
Catch e As FormatException
Console.WriteLine("{0} is not in the correct format.", dateString)
End Try
' Parse date and time with offset but without offset's minutes.
' Should throw a FormatException because "zzz" specifier requires leading
' zero in hours.
dateString = "Sun 15 Jun 2008 8:30 AM -06"
Try
result = Date.ParseExact(dateString, format, provider)
Console.WriteLine("{0} converts to {1}.", dateString, result.ToString())
Catch e As FormatException
Console.WriteLine("{0} is not in the correct format.", dateString)
End Try
' Parse a date string using the French (France) culture.
dateString = "15/06/2008 08:30"
format = "g"
provider = New CultureInfo("fr-FR")
Try
result = Date.ParseExact(dateString, format, provider)
Console.WriteLine("{0} converts to {1}.", dateString, result.ToString())
Catch e As FormatException
Console.WriteLine("{0} is not in the correct format.", dateString)
End Try
' Parse a date that includes seconds and milliseconds
' by using the French (France) and invariant cultures.
dateString = "18/08/2015 06:30:15.006542"
format = "dd/MM/yyyy HH:mm:ss.ffffff"
Try
result = Date.ParseExact(dateString, format, provider)
Console.WriteLine("{0} converts to {1}.", dateString, result.ToString())
Catch e As FormatException
Console.WriteLine("{0} is not in the correct format.", dateString)
End Try
End Sub
End Module
' The example displays the following output:
' 06/15/2008 converts to 6/15/2008 12:00:00 AM.
' 6/15/2008 is not in the correct format.
' Sun 15 Jun 2008 8:30 AM -06:00 converts to 6/15/2008 7:30:00 AM.
' Sun 15 Jun 2008 8:30 AM -06 is not in the correct format.
' 15/06/2008 08:30 converts to 6/15/2008 8:30:00 AM.
' 18/08/2015 06:30:15.006542 converts to 8/18/2015 6:30:15 AM.
Poznámky
Metoda DateTime.ParseExact(String, String, IFormatProvider) parsuje řetězcovou reprezentaci data, která musí být ve formátu definovaném parametrem format
. Vyžaduje také, aby <se prvky Data> a <Času> řetězcové reprezentace data a času zobrazovaly format
v pořadí určeném nástrojem format
a které s
nemají žádné jiné prázdné znaky, než které povoluje . Pokud format
definuje datum bez časového prvku a operace parse bude úspěšná, výsledná DateTime hodnota má čas půlnoci (00:00:00). Pokud format
definuje čas bez prvku date a operace parse bude úspěšná, výsledná DateTime hodnota má datum DateTime.Now.Date
.
Pokud s
nepředstavuje čas v určitém časovém pásmu a operace parse bude úspěšná, Kind vlastnost vrácené DateTime hodnoty je DateTimeKind.Unspecified. Pokud s
představuje čas v určitém časovém pásmu a format
umožňuje, aby informace o časovém pásmu byly přítomné (například pokud format
se rovná specifikátorům standardního formátu "o", "r" nebo "u" nebo pokud obsahuje specifikátory Kind vlastního formátu "z", "zz" nebo "zzz"), vlastnost vrácené DateTime hodnoty je DateTimeKind.Local.
Parametr format
je řetězec, který obsahuje buď jeden specifikátor standardního formátu, nebo jeden nebo více specifikátorů vlastního formátu, které definují požadovaný formát .s
Podrobnosti o platných formátovacích kódech najdete v tématech Řetězce standardního formátu data a času nebo Vlastní řetězce formátu data a času.
Poznámka
Pokud format
je vzor vlastního formátu, který neobsahuje oddělovače data nebo času (například "yyMMmddHHmm"), použijte pro provider
parametr invariantní jazykovou verzi a nejširší formu každého specifikátoru vlastního formátu. Pokud například chcete zadat hodiny ve vzoru formátu, zadejte širší tvar "HH" místo užšího tvaru "H".
Konkrétní symboly a řetězce data a času (například názvy dnů v týdnu v konkrétním jazyce) použité v s
parametru provider
jsou definovány parametrem, stejně jako přesný formát s
řetězce, pokud format
je standardní formát specifikátoru řetězce. Parametr provider
může být některý z následujících parametrů:
Objekt CultureInfo , který představuje jazykovou verzi použitou k interpretaci
s
. Objekt DateTimeFormatInfo vrácený jeho DateTimeFormat vlastností definuje symboly a formátování vs
.Objekt DateTimeFormatInfo , který definuje formát dat data a času.
Vlastní IFormatProvider implementace, jejíž GetFormat metoda vrací buď CultureInfo objekt, nebo DateTimeFormatInfo objekt, který poskytuje informace o formátování.
Pokud provider
je null
, použije se CultureInfo objekt, který odpovídá aktuální jazykové verzi.
Poznámky pro volající
V rozhraní .NET Framework 4 ParseExact metoda vyvolá FormatException , pokud řetězec, který se má analyzovat, obsahuje komponentu hodiny a označení do hodiny a odpoledne, které nejsou ve shodě. V rozhraní .NET Framework 3.5 a starších verzích je návrh do hodiny do večera ignorován.
Viz také
- TryParseExact
- 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
ParseExact(ReadOnlySpan<Char>, ReadOnlySpan<Char>, IFormatProvider, DateTimeStyles)
- Zdroj:
- DateTime.cs
- Zdroj:
- DateTime.cs
- Zdroj:
- DateTime.cs
Převede zadanou reprezentaci rozsahu data a času na jeho DateTime ekvivalent pomocí zadaného formátu, informací o formátu specifickém pro jazykovou verzi a stylu. Formát řetězcové reprezentace musí přesně odpovídat zadanému formátu, jinak dojde k výjimce.
public static DateTime ParseExact (ReadOnlySpan<char> s, ReadOnlySpan<char> format, IFormatProvider? provider, System.Globalization.DateTimeStyles style = System.Globalization.DateTimeStyles.None);
public static DateTime ParseExact (ReadOnlySpan<char> s, ReadOnlySpan<char> format, IFormatProvider provider, System.Globalization.DateTimeStyles style = System.Globalization.DateTimeStyles.None);
static member ParseExact : ReadOnlySpan<char> * ReadOnlySpan<char> * IFormatProvider * System.Globalization.DateTimeStyles -> DateTime
Public Shared Function ParseExact (s As ReadOnlySpan(Of Char), format As ReadOnlySpan(Of Char), provider As IFormatProvider, Optional style As DateTimeStyles = System.Globalization.DateTimeStyles.None) As DateTime
Parametry
- s
- ReadOnlySpan<Char>
Rozsah obsahující znaky, které představují datum a čas, které se mají převést.
- format
- ReadOnlySpan<Char>
Rozsah obsahující znaky, které představují specifikátor formátu, který definuje požadovaný formát .s
- provider
- IFormatProvider
Objekt, který poskytuje informace o formátování specifické pro jazykovou verzi .s
- style
- DateTimeStyles
Bitové kombinace hodnot výčtu, která poskytuje další informace o s
, o elementech stylu, které mohou být přítomny v s
, nebo o převodu z s
na DateTime hodnotu. 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 s
parametrech format
, provider
a style
.
Platí pro
ParseExact(ReadOnlySpan<Char>, String[], IFormatProvider, DateTimeStyles)
- Zdroj:
- DateTime.cs
- Zdroj:
- DateTime.cs
- Zdroj:
- DateTime.cs
Převede zadanou reprezentaci rozsahu data a času na jeho DateTime ekvivalent pomocí zadané pole formátů, informací o formátu specifické pro jazykovou verzi a stylu. Formát řetězcové reprezentace musí přesně odpovídat alespoň jednomu ze zadaných formátů nebo je vyvolán výjimka.
public static DateTime ParseExact (ReadOnlySpan<char> s, string[] formats, IFormatProvider? provider, System.Globalization.DateTimeStyles style = System.Globalization.DateTimeStyles.None);
public static DateTime ParseExact (ReadOnlySpan<char> s, string[] formats, IFormatProvider provider, System.Globalization.DateTimeStyles style = System.Globalization.DateTimeStyles.None);
static member ParseExact : ReadOnlySpan<char> * string[] * IFormatProvider * System.Globalization.DateTimeStyles -> DateTime
Public Shared Function ParseExact (s As ReadOnlySpan(Of Char), formats As String(), provider As IFormatProvider, Optional style As DateTimeStyles = System.Globalization.DateTimeStyles.None) As DateTime
Parametry
- s
- ReadOnlySpan<Char>
Rozsah obsahující znaky, které představují datum a čas, které se mají převést.
- formats
- String[]
Pole povolených formátů .s
- provider
- IFormatProvider
Objekt, který poskytuje informace o formátu specifickém pro jazykovou verzi .s
- style
- DateTimeStyles
Bitové kombinace hodnot výčtu, která označuje povolený formát .s
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 s
parametrech formats
, provider
a style
.
Platí pro
ParseExact(String, String, IFormatProvider, DateTimeStyles)
- Zdroj:
- DateTime.cs
- Zdroj:
- DateTime.cs
- Zdroj:
- DateTime.cs
Převede zadanou řetězcovou reprezentaci data a času na jeho DateTime ekvivalent pomocí zadaného formátu, informací o formátu specifickém pro jazykovou verzi a stylu. Formát řetězcové reprezentace musí přesně odpovídat zadanému formátu, jinak dojde k výjimce.
public:
static DateTime ParseExact(System::String ^ s, System::String ^ format, IFormatProvider ^ provider, System::Globalization::DateTimeStyles style);
public static DateTime ParseExact (string s, string format, IFormatProvider provider, System.Globalization.DateTimeStyles style);
public static DateTime ParseExact (string s, string format, IFormatProvider? provider, System.Globalization.DateTimeStyles style);
static member ParseExact : string * string * IFormatProvider * System.Globalization.DateTimeStyles -> DateTime
Public Shared Function ParseExact (s As String, format As String, provider As IFormatProvider, style As DateTimeStyles) As DateTime
Parametry
- s
- String
Řetězec obsahující datum a čas, který chcete převést.
- format
- String
Specifikátor formátu, který definuje požadovaný formát souboru s
. Další informace najdete v části Poznámky.
- provider
- IFormatProvider
Objekt, který poskytuje informace o formátování specifické pro jazykovou verzi .s
- style
- DateTimeStyles
Bitové kombinace hodnot výčtu, která poskytuje další informace o s
, o elementech stylu, které mohou být přítomny v s
, nebo o převodu z s
na DateTime hodnotu. 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 s
parametrech format
, provider
a style
.
Výjimky
s
nebo format
je null
.
s
nebo format
je prázdný řetězec.
-nebo-
s
neobsahuje datum a čas, které odpovídají vzoru zadanému v nástroji format
.
-nebo-
Hodinová komponenta a označení do hodiny a odpoledne v s
systému nesouhlasí.
style
obsahuje neplatnou kombinaci DateTimeStyles hodnot. Například a AssumeLocalAssumeUniversal.
Příklady
Následující příklad ukazuje metodu ParseExact(String, String, IFormatProvider) . Všimněte si, že řetězec "5/01/2009 8:30 AM" nelze úspěšně analyzovat, pokud styles
se parametr rovná, protože počáteční mezery DateTimeStyles.None nejsou povoleny .format
Řetězec "5/01/2009 09:00" navíc nelze úspěšně analyzovat s format
hodnotou "MM/dd/yyyyhh:mm", protože řetězec kalendářního data nepředvádí číslo měsíce úvodní nulou, jak format
vyžaduje.
using System;
using System.Globalization;
public class Example
{
public static void Main()
{
CultureInfo enUS = new CultureInfo("en-US");
string dateString;
DateTime dateValue;
// Parse date with no style flags.
dateString = " 5/01/2009 8:30 AM";
try {
dateValue = DateTime.ParseExact(dateString, "g", enUS, DateTimeStyles.None);
Console.WriteLine("Converted '{0}' to {1} ({2}).", dateString, dateValue,
dateValue.Kind);
}
catch (FormatException) {
Console.WriteLine("'{0}' is not in an acceptable format.", dateString);
}
// Allow a leading space in the date string.
try {
dateValue = DateTime.ParseExact(dateString, "g", enUS, DateTimeStyles.AllowLeadingWhite);
Console.WriteLine("Converted '{0}' to {1} ({2}).", dateString, dateValue,
dateValue.Kind);
}
catch (FormatException) {
Console.WriteLine("'{0}' is not in an acceptable format.", dateString);
}
// Use custom formats with M and MM.
dateString = "5/01/2009 09:00";
try {
dateValue = DateTime.ParseExact(dateString, "M/dd/yyyy hh:mm", enUS, DateTimeStyles.None);
Console.WriteLine("Converted '{0}' to {1} ({2}).", dateString, dateValue,
dateValue.Kind);
}
catch (FormatException) {
Console.WriteLine("'{0}' is not in an acceptable format.", dateString);
}
// Allow a leading space in the date string.
try {
dateValue = DateTime.ParseExact(dateString, "MM/dd/yyyy hh:mm", enUS, DateTimeStyles.None);
Console.WriteLine("Converted '{0}' to {1} ({2}).", dateString, dateValue,
dateValue.Kind);
}
catch (FormatException) {
Console.WriteLine("'{0}' is not in an acceptable format.", dateString);
}
// Parse a string with time zone information.
dateString = "05/01/2009 01:30:42 PM -05:00";
try {
dateValue = DateTime.ParseExact(dateString, "MM/dd/yyyy hh:mm:ss tt zzz", enUS, DateTimeStyles.None);
Console.WriteLine("Converted '{0}' to {1} ({2}).", dateString, dateValue,
dateValue.Kind);
}
catch (FormatException) {
Console.WriteLine("'{0}' is not in an acceptable format.", dateString);
}
// Allow a leading space in the date string.
try {
dateValue = DateTime.ParseExact(dateString, "MM/dd/yyyy hh:mm:ss tt zzz", enUS,
DateTimeStyles.AdjustToUniversal);
Console.WriteLine("Converted '{0}' to {1} ({2}).", dateString, dateValue,
dateValue.Kind);
}
catch (FormatException) {
Console.WriteLine("'{0}' is not in an acceptable format.", dateString);
}
// Parse a string representing UTC.
dateString = "2008-06-11T16:11:20.0904778Z";
try {
dateValue = DateTime.ParseExact(dateString, "o", CultureInfo.InvariantCulture,
DateTimeStyles.None);
Console.WriteLine("Converted '{0}' to {1} ({2}).", dateString, dateValue,
dateValue.Kind);
}
catch (FormatException) {
Console.WriteLine("'{0}' is not in an acceptable format.", dateString);
}
try {
dateValue = DateTime.ParseExact(dateString, "o", CultureInfo.InvariantCulture,
DateTimeStyles.RoundtripKind);
Console.WriteLine("Converted '{0}' to {1} ({2}).", dateString, dateValue,
dateValue.Kind);
}
catch (FormatException) {
Console.WriteLine("'{0}' is not in an acceptable format.", dateString);
}
}
}
// The example displays the following output:
// ' 5/01/2009 8:30 AM' is not in an acceptable format.
// Converted ' 5/01/2009 8:30 AM' to 5/1/2009 8:30:00 AM (Unspecified).
// Converted '5/01/2009 09:00' to 5/1/2009 9:00:00 AM (Unspecified).
// '5/01/2009 09:00' is not in an acceptable format.
// Converted '05/01/2009 01:30:42 PM -05:00' to 5/1/2009 11:30:42 AM (Local).
// Converted '05/01/2009 01:30:42 PM -05:00' to 5/1/2009 6:30:42 PM (Utc).
// Converted '2008-06-11T16:11:20.0904778Z' to 6/11/2008 9:11:20 AM (Local).
// Converted '2008-06-11T16:11:20.0904778Z' to 6/11/2008 4:11:20 PM (Utc).
open System
open System.Globalization
[<EntryPoint>]
let main _ =
let enUS = CultureInfo "en-US"
// Parse date with no style flags.
let dateString = " 5/01/2009 8:30 AM"
try
let dateValue = DateTime.ParseExact(dateString, "g", enUS, DateTimeStyles.None)
printfn $"Converted '{dateString}' to {dateValue} ({dateValue.Kind})."
with :? FormatException ->
printfn $"'{dateString}' is not in an acceptable format."
// Allow a leading space in the date string.
try
let dateValue = DateTime.ParseExact(dateString, "g", enUS, DateTimeStyles.AllowLeadingWhite)
printfn $"Converted '{dateString}' to {dateValue} ({dateValue.Kind})."
with :? FormatException ->
printfn $"'{dateString}' is not in an acceptable format."
// Use custom formats with M and MM.
let dateString = "5/01/2009 09:00"
try
let dateValue = DateTime.ParseExact(dateString, "M/dd/yyyy hh:mm", enUS, DateTimeStyles.None)
printfn $"Converted '{dateString}' to {dateValue} ({dateValue.Kind})."
with :? FormatException ->
printfn $"'{dateString}' is not in an acceptable format."
// Allow a leading space in the date string.
try
let dateValue = DateTime.ParseExact(dateString, "MM/dd/yyyy hh:mm", enUS, DateTimeStyles.None)
printfn $"Converted '{dateString}' to {dateValue} ({dateValue.Kind})."
with :? FormatException ->
printfn $"'{dateString}' is not in an acceptable format."
// Parse a string with time zone information.
let dateString = "05/01/2009 01:30:42 PM -05:00"
try
let dateValue = DateTime.ParseExact(dateString, "MM/dd/yyyy hh:mm:ss tt zzz", enUS, DateTimeStyles.None)
printfn $"Converted '{dateString}' to {dateValue} ({dateValue.Kind})."
with :? FormatException ->
printfn $"'{dateString}' is not in an acceptable format."
// Allow a leading space in the date string.
try
let dateValue = DateTime.ParseExact(dateString, "MM/dd/yyyy hh:mm:ss tt zzz", enUS, DateTimeStyles.AdjustToUniversal)
printfn $"Converted '{dateString}' to {dateValue} ({dateValue.Kind})."
with :? FormatException ->
printfn $"'{dateString}' is not in an acceptable format."
// Parse a string representing UTC.
let dateString = "2008-06-11T16:11:20.0904778Z"
try
let dateValue = DateTime.ParseExact(dateString, "o", CultureInfo.InvariantCulture, DateTimeStyles.None)
printfn $"Converted '{dateString}' to {dateValue} ({dateValue.Kind})."
with :? FormatException ->
printfn $"'{dateString}' is not in an acceptable format."
try
let dateValue = DateTime.ParseExact(dateString, "o", CultureInfo.InvariantCulture, DateTimeStyles.RoundtripKind)
printfn $"Converted '{dateString}' to {dateValue} ({dateValue.Kind})."
with :? FormatException ->
printfn $"'{dateString}' is not in an acceptable format."
// The example displays the following output:
// ' 5/01/2009 8:30 AM' is not in an acceptable format.
// Converted ' 5/01/2009 8:30 AM' to 5/1/2009 8:30:00 AM (Unspecified).
// Converted '5/01/2009 09:00' to 5/1/2009 9:00:00 AM (Unspecified).
// '5/01/2009 09:00' is not in an acceptable format.
// Converted '05/01/2009 01:30:42 PM -05:00' to 5/1/2009 11:30:42 AM (Local).
// Converted '05/01/2009 01:30:42 PM -05:00' to 5/1/2009 6:30:42 PM (Utc).
// Converted '2008-06-11T16:11:20.0904778Z' to 6/11/2008 9:11:20 AM (Local).
// Converted '2008-06-11T16:11:20.0904778Z' to 6/11/2008 4:11:20 PM (Utc).
Imports System.Globalization
Module Example
Public Sub Main()
Dim enUS As New CultureInfo("en-US")
Dim dateString As String
Dim dateValue As Date
' Parse date with no style flags.
dateString = " 5/01/2009 8:30 AM"
Try
dateValue = Date.ParseExact(dateString, "g", enUS, DateTimeStyles.None)
Console.WriteLine("Converted '{0}' to {1} ({2}).", dateString, dateValue, _
dateValue.Kind)
Catch e As FormatException
Console.WriteLine("'{0}' is not in an acceptable format.", dateString)
End Try
' Allow a leading space in the date string.
Try
dateValue = Date.ParseExact(dateString, "g", enUS, DateTimeStyles.AllowLeadingWhite)
Console.WriteLine("Converted '{0}' to {1} ({2}).", dateString, dateValue, _
dateValue.Kind)
Catch e As FormatException
Console.WriteLine("'{0}' is not in an acceptable format.", dateString)
End Try
' Use custom formats with M and MM.
dateString = "5/01/2009 09:00"
Try
dateValue = Date.ParseExact(dateString, "M/dd/yyyy hh:mm", enUS, DateTimeStyles.None)
Console.WriteLine("Converted '{0}' to {1} ({2}).", dateString, dateValue, _
dateValue.Kind)
Catch e As FormatException
Console.WriteLine("'{0}' is not in an acceptable format.", dateString)
End Try
' Allow a leading space in the date string.
Try
dateValue = Date.ParseExact(dateString, "MM/dd/yyyy hh:mm", enUS, DateTimeStyles.None)
Console.WriteLine("Converted '{0}' to {1} ({2}).", dateString, dateValue, _
dateValue.Kind)
Catch e As FormatException
Console.WriteLine("'{0}' is not in an acceptable format.", dateString)
End Try
' Parse a string with time zone information.
dateString = "05/01/2009 01:30:42 PM -05:00"
Try
dateValue = Date.ParseExact(dateString, "MM/dd/yyyy hh:mm:ss tt zzz", enUS, DateTimeStyles.None)
Console.WriteLine("Converted '{0}' to {1} ({2}).", dateString, dateValue, _
dateValue.Kind)
Catch e As FormatException
Console.WriteLine("'{0}' is not in an acceptable format.", dateString)
End Try
' Allow a leading space in the date string.
Try
dateValue = Date.ParseExact(dateString, "MM/dd/yyyy hh:mm:ss tt zzz", enUS, _
DateTimeStyles.AdjustToUniversal)
Console.WriteLine("Converted '{0}' to {1} ({2}).", dateString, dateValue, _
dateValue.Kind)
Catch e As FormatException
Console.WriteLine("'{0}' is not in an acceptable format.", dateString)
End Try
' Parse a string representing UTC.
dateString = "2008-06-11T16:11:20.0904778Z"
Try
dateValue = Date.ParseExact(dateString, "o", CultureInfo.InvariantCulture, _
DateTimeStyles.None)
Console.WriteLine("Converted '{0}' to {1} ({2}).", dateString, dateValue, _
dateValue.Kind)
Catch e As FormatException
Console.WriteLine("'{0}' is not in an acceptable format.", dateString)
End Try
Try
dateValue = Date.ParseExact(dateString, "o", CultureInfo.InvariantCulture, _
DateTimeStyles.RoundtripKind)
Console.WriteLine("Converted '{0}' to {1} ({2}).", dateString, dateValue, _
dateValue.Kind)
Catch e As FormatException
Console.WriteLine("'{0}' is not in an acceptable format.", dateString)
End Try
End Sub
End Module
' The example displays the following output:
' ' 5/01/2009 8:30 AM' is not in an acceptable format.
' Converted ' 5/01/2009 8:30 AM' to 5/1/2009 8:30:00 AM (Unspecified).
' Converted '5/01/2009 09:00' to 5/1/2009 9:00:00 AM (Unspecified).
' '5/01/2009 09:00' is not in an acceptable format.
' Converted '05/01/2009 01:30:42 PM -05:00' to 5/1/2009 11:30:42 AM (Local).
' Converted '05/01/2009 01:30:42 PM -05:00' to 5/1/2009 6:30:42 PM (Utc).
' Converted '2008-06-11T16:11:20.0904778Z' to 6/11/2008 9:11:20 AM (Local).
' Converted '2008-06-11T16:11:20.0904778Z' to 6/11/2008 4:11:20 PM (Utc).
Poznámky
Metoda DateTime.ParseExact(String, String, IFormatProvider, DateTimeStyles) parsuje řetězcovou reprezentaci data, která musí být ve formátu definovaném parametrem format
. Vyžaduje také, aby se prvky data a času v s
souboru zobrazovaly v pořadí určeném nástrojem format
. Pokud s
neodpovídá vzoru parametru format
a všechny varianty definované parametrem style
, metoda vyvolá FormatException. Naproti tomu DateTime.Parse(String, IFormatProvider, DateTimeStyles) metoda analyzuje řetězcovou reprezentaci data v libovolném z formátů rozpoznaných objektem zprostředkovatele DateTimeFormatInfo formátu. Metoda DateTime.Parse(String, IFormatProvider, DateTimeStyles) také umožňuje, aby se prvky data a času v s
souboru zobrazovaly v libovolném pořadí.
s
Pokud parametr obsahuje pouze čas a žádné datum, použije se aktuální datum, pokud style
parametr neobsahuje DateTimeStyles.NoCurrentDateDefault příznak. V takovém případě se použije výchozí datum (DateTime.Date.MinValue
).
s
Pokud parametr obsahuje pouze datum a žádný čas, použije se půlnoc (00:00:00). Parametr style
také určuje, jestli s
parametr může obsahovat počáteční, vnitřní nebo koncové prázdné znaky.
Pokud s
neobsahuje žádné informace o časovém pásmu Kind , vlastnost vráceného DateTime objektu je DateTimeKind.Unspecified. Toto chování lze změnit pomocí příznaku DateTimeStyles.AssumeLocal , který vrací DateTime hodnotu, jejíž Kind vlastnost je DateTimeKind.Local, nebo pomocí DateTimeStyles.AssumeUniversal příznaků a DateTimeStyles.AdjustToUniversal , které vrací DateTime hodnotu, jejíž Kind vlastnost je DateTimeKind.Utc. Pokud s
obsahuje informace o časovém pásmu, čas se v případě potřeby převede na místní čas a Kind vlastnost vráceného DateTime objektu je nastavena na DateTimeKind.Localhodnotu . Toto chování lze změnit pomocí příznaku DateTimeStyles.RoundtripKind , který nepřevedá koordinovaný univerzální čas (UTC) na místní čas a nastaví Kind vlastnost na DateTimeKind.Utchodnotu .
Parametr format
definuje požadovaný vzor parametru s
. Může se skládat buď z jednoho nebo více specifikátorů vlastního formátu z tabulky Vlastní řetězce formátu data a času , nebo z jednoho specifikátoru standardního formátu, který identifikuje předdefinovaný vzor, z tabulky Standardní formátovací řetězce data a času .
Pokud ve vzoru vlastního formátu nepoužíváte oddělovače data nebo času, použijte pro provider
parametr invariantní jazykovou verzi a nejširší formu každého specifikátoru vlastního formátu. Pokud například chcete zadat hodiny ve vzorku, určete širší tvar "HH" místo užšího formátu "H".
Poznámka
Místo toho, aby s
operace analýzy odpovídala jednomu formátu, můžete metodu DateTime.ParseExact(String, String[], IFormatProvider, DateTimeStyles) volat a zadat více povolených formátů. Díky tomu je operace analýzy pravděpodobnější, že bude úspěšná.
Parametr styles
obsahuje jeden nebo více členů výčtuDateTimeStyles, které určují, zda a kde se mohou zobrazit s
prázdné znaky, které nejsou definovány, format
a které řídí přesné chování operace parsování. Následující tabulka popisuje, jak každý člen výčtu DateTimeStyles ovlivňuje operaci ParseExact(String, String, IFormatProvider, DateTimeStyles) metody.
Člen DateTimeStyles | Description |
---|---|
AdjustToUniversal | Provede analýzu s a v případě potřeby převede na UTC. Pokud s obsahuje posun časového pásma nebo pokud s neobsahuje žádné informace o časovém pásmu, ale styles obsahuje DateTimeStyles.AssumeLocal příznak, metoda analyzuje řetězec, zavolá ToUniversalTime k převodu vrácené DateTime hodnoty 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 DateTimeStyles.AssumeUniversal příznak, metoda analyzuje řetězec, neprovádí 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ý vliv. |
AllowInnerWhite | Určuje, že se mezi libovolným prvkem data nebo času může zobrazit prázdné místo, které není definováno format . |
AllowLeadingWhite | Určuje, že prázdné znaky, které nejsou definovány uživatelemformat , se mohou zobrazit na začátku .s |
AllowTrailingWhite | Určuje, že se na konci objektu může zobrazit prázdné znaky, které format nejsou definovány nástrojem s . |
AllowWhiteSpaces | Určuje, že s může obsahovat počáteční, vnitřní a koncové prázdné znaky, které nejsou definovány nástrojem format . |
AssumeLocal | Určuje, že pokud s chybí informace o časovém pásmu, předpokládá se, že představuje místní čas. Pokud není DateTimeStyles.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, že představují UTC.
DateTimeStyles.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. |
NoCurrentDateDefault | Pokud s obsahuje čas bez informací o datu, je datum návratové hodnoty nastaveno na DateTime.MinValue.Date hodnotu . |
None | Parametr s se analyzuje pomocí výchozích hodnot. Nejsou povoleny žádné jiné prázdné znaky než ty, které jsou v format souboru. Pokud s chybí komponenta data, datum vrácené DateTime hodnoty je nastaveno na 1.1.0001. Pokud s neobsahuje žádné informace o časovém pásmu Kind , vlastnost vráceného DateTime objektu je nastavena na DateTimeKind.Unspecifiedhodnotu . Pokud jsou informace o časovém pásmu v s systému , čas se převede na místní čas a Kind vlastnost vráceného DateTime objektu je nastavena na DateTimeKind.Local. |
RoundtripKind | U řetězců obsahujících informace o časovém pásmu se pokusí zabránit převodu na datum a čas hodnoty s vlastností Kind nastavenou DateTime na DateTimeKind.Localhodnotu . Tento příznak zabraňuje především převodu času UTC na místní čas. |
Konkrétní symboly a řetězce data a času (například názvy dnů v týdnu v konkrétním jazyce) použité v s
parametru provider
jsou definovány parametrem, stejně jako přesný formát s
pokud format
je standardní formát specifikátoru řetězce. Parametr provider
může být některý z následujících parametrů:
Objekt CultureInfo , který představuje jazykovou verzi použitou k interpretaci
s
. Objekt DateTimeFormatInfo vrácený jeho DateTimeFormat vlastností definuje symboly a formátování vs
.Objekt DateTimeFormatInfo , který definuje formát dat data a času.
Vlastní IFormatProvider implementace, jejíž GetFormat metoda vrací buď CultureInfo objekt, nebo DateTimeFormatInfo objekt, který poskytuje informace o formátování.
Pokud provider
je null
, použije se CultureInfo objekt, který odpovídá aktuální jazykové verzi.
Poznámky pro volající
V rozhraní .NET Framework 4 ParseExact metoda vyvolá FormatException , pokud řetězec, který se má analyzovat, obsahuje komponentu hodiny a označení do hodiny a odpoledne, které nejsou ve shodě. V rozhraní .NET Framework 3.5 a starších verzích je návrh do hodiny do večera ignorován.
Viz také
- TryParseExact
- 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
ParseExact(String, String[], IFormatProvider, DateTimeStyles)
- Zdroj:
- DateTime.cs
- Zdroj:
- DateTime.cs
- Zdroj:
- DateTime.cs
Převede zadanou řetězcovou reprezentaci data a času na jeho DateTime ekvivalent pomocí zadaného pole formátů, informací o formátu specifickém pro jazykovou verzi a stylu. Formát řetězcové reprezentace musí přesně odpovídat alespoň jednomu ze zadaných formátů, jinak dojde k výjimce.
public:
static DateTime ParseExact(System::String ^ s, cli::array <System::String ^> ^ formats, IFormatProvider ^ provider, System::Globalization::DateTimeStyles style);
public static DateTime ParseExact (string s, string[] formats, IFormatProvider provider, System.Globalization.DateTimeStyles style);
public static DateTime ParseExact (string s, string[] formats, IFormatProvider? provider, System.Globalization.DateTimeStyles style);
static member ParseExact : string * string[] * IFormatProvider * System.Globalization.DateTimeStyles -> DateTime
Public Shared Function ParseExact (s As String, formats As String(), provider As IFormatProvider, style As DateTimeStyles) As DateTime
Parametry
- s
- String
Řetězec, který obsahuje datum a čas k převedení.
- formats
- String[]
Pole povolených formátů .s
Další informace najdete v části Poznámky.
- provider
- IFormatProvider
Objekt, který poskytuje informace o formátu specifickém pro jazykovou verzi .s
- style
- DateTimeStyles
Bitové kombinace hodnot výčtu, která označuje povolený formát .s
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 s
parametrech formats
, provider
a style
.
Výjimky
s
nebo formats
je null
.
s
je prázdný řetězec.
-nebo-
element je formats
prázdný řetězec.
-nebo-
s
neobsahuje datum a čas, které odpovídají žádnému formats
prvku .
-nebo-
Hodinová komponenta a označení do hodiny a odpoledne v s
systému nesouhlasí.
style
obsahuje neplatnou kombinaci DateTimeStyles hodnot. Například a AssumeLocalAssumeUniversal.
Příklady
Následující příklad používá metodu DateTime.ParseExact(String, String[], IFormatProvider, DateTimeStyles) k zajištění, že řetězec v řadě možných formátů může být úspěšně parsován .
using System;
using System.Globalization;
public class Example
{
public static void Main()
{
string[] formats= {"M/d/yyyy h:mm:ss tt", "M/d/yyyy h:mm tt",
"MM/dd/yyyy hh:mm:ss", "M/d/yyyy h:mm:ss",
"M/d/yyyy hh:mm tt", "M/d/yyyy hh tt",
"M/d/yyyy h:mm", "M/d/yyyy h:mm",
"MM/dd/yyyy hh:mm", "M/dd/yyyy hh:mm",
"MM/d/yyyy HH:mm:ss.ffffff" };
string[] dateStrings = {"5/1/2009 6:32 PM", "05/01/2009 6:32:05 PM",
"5/1/2009 6:32:00", "05/01/2009 06:32",
"05/01/2009 06:32:00 PM", "05/01/2009 06:32:00",
"08/28/2015 16:17:39.125", "08/28/2015 16:17:39.125000" };
DateTime dateValue;
foreach (string dateString in dateStrings)
{
try {
dateValue = DateTime.ParseExact(dateString, formats,
new CultureInfo("en-US"),
DateTimeStyles.None);
Console.WriteLine("Converted '{0}' to {1}.", dateString, dateValue);
}
catch (FormatException) {
Console.WriteLine("Unable to convert '{0}' to a date.", dateString);
}
}
}
}
// The example displays the following output:
// Converted '5/1/2009 6:32 PM' to 5/1/2009 6:32:00 PM.
// Converted '05/01/2009 6:32:05 PM' to 5/1/2009 6:32:05 PM.
// Converted '5/1/2009 6:32:00' to 5/1/2009 6:32:00 AM.
// Converted '05/01/2009 06:32' to 5/1/2009 6:32:00 AM.
// Converted '05/01/2009 06:32:00 PM' to 5/1/2009 6:32:00 PM.
// Converted '05/01/2009 06:32:00' to 5/1/2009 6:32:00 AM.
// Unable to convert '08/28/2015 16:17:39.125' to a date.
// Converted '08/28/2015 16:17:39.125000' to 8/28/2015 4:17:39 PM.
open System
open System.Globalization
let formats =
[| "M/d/yyyy h:mm:ss tt"; "M/d/yyyy h:mm tt"
"MM/dd/yyyy hh:mm:ss"; "M/d/yyyy h:mm:ss"
"M/d/yyyy hh:mm tt"; "M/d/yyyy hh tt"
"M/d/yyyy h:mm"; "M/d/yyyy h:mm"
"MM/dd/yyyy hh:mm"; "M/dd/yyyy hh:mm"
"MM/d/yyyy HH:mm:ss.ffffff" |]
let dateStrings =
[ "5/1/2009 6:32 PM"; "05/01/2009 6:32:05 PM"
"5/1/2009 6:32:00"; "05/01/2009 06:32"
"05/01/2009 06:32:00 PM"; "05/01/2009 06:32:00"
"08/28/2015 16:17:39.125"; "08/28/2015 16:17:39.125000" ]
for dateString in dateStrings do
try
let dateValue = DateTime.ParseExact(dateString, formats, CultureInfo "en-US", DateTimeStyles.None)
printfn $"Converted '{dateString}' to {dateValue}."
with :? FormatException ->
printfn $"Unable to convert '{dateString}' to a date."
// The example displays the following output:
// Converted '5/1/2009 6:32 PM' to 5/1/2009 6:32:00 PM.
// Converted '05/01/2009 6:32:05 PM' to 5/1/2009 6:32:05 PM.
// Converted '5/1/2009 6:32:00' to 5/1/2009 6:32:00 AM.
// Converted '05/01/2009 06:32' to 5/1/2009 6:32:00 AM.
// Converted '05/01/2009 06:32:00 PM' to 5/1/2009 6:32:00 PM.
// Converted '05/01/2009 06:32:00' to 5/1/2009 6:32:00 AM.
// Unable to convert '08/28/2015 16:17:39.125' to a date.
// Converted '08/28/2015 16:17:39.125000' to 8/28/2015 4:17:39 PM.
Imports System.Globalization
Module Example
Public Sub Main()
Dim formats() As String = {"M/d/yyyy h:mm:ss tt", "M/d/yyyy h:mm tt", _
"MM/dd/yyyy hh:mm:ss", "M/d/yyyy h:mm:ss", _
"M/d/yyyy hh:mm tt", "M/d/yyyy hh tt", _
"M/d/yyyy h:mm", "M/d/yyyy h:mm", _
"MM/dd/yyyy hh:mm", "M/dd/yyyy hh:mm",
"MM/d/yyyy HH:mm:ss.ffffff" }
Dim dateStrings() As String = {"5/1/2009 6:32 PM", "05/01/2009 6:32:05 PM", _
"5/1/2009 6:32:00", "05/01/2009 06:32", _
"05/01/2009 06:32:00 PM", "05/01/2009 06:32:00",
"08/28/2015 16:17:39.125", "08/28/2015 16:17:39.125000" }
Dim dateValue As DateTime
For Each dateString As String In dateStrings
Try
dateValue = DateTime.ParseExact(dateString, formats, _
New CultureInfo("en-US"), _
DateTimeStyles.None)
Console.WriteLine("Converted '{0}' to {1}.", dateString, dateValue)
Catch e As FormatException
Console.WriteLine("Unable to convert '{0}' to a date.", dateString)
End Try
Next
End Sub
End Module
' The example displays the following output:
' Converted '5/1/2009 6:32 PM' to 5/1/2009 6:32:00 PM.
' Converted '05/01/2009 6:32:05 PM' to 5/1/2009 6:32:05 PM.
' Converted '5/1/2009 6:32:00' to 5/1/2009 6:32:00 AM.
' Converted '05/01/2009 06:32' to 5/1/2009 6:32:00 AM.
' Converted '05/01/2009 06:32:00 PM' to 5/1/2009 6:32:00 PM.
' Converted '05/01/2009 06:32:00' to 5/1/2009 6:32:00 AM.
' Unable to convert '08/28/2015 16:17:39.125' to a date.
' Converted '08/28/2015 16:17:39.125000' to 8/28/2015 4:17:39 PM.
Poznámky
Metoda DateTime.ParseExact(String, String[], IFormatProvider, DateTimeStyles) parsuje řetězcovou reprezentaci data, které odpovídá některému ze vzorů přiřazených k parametru formats
. Pokud řetězec s
neodpovídá žádnému z těchto vzorů s žádnou z variant definovaných parametrem styles
, metoda vyvolá FormatException. Kromě porovnání s
s více vzory formátování, spíše než s jedním vzorem formátování, se toto přetížení chová stejně jako DateTime.ParseExact(String, String, IFormatProvider, DateTimeStyles) metoda.
Parametr s
obsahuje datum a čas, které se mají analyzovat.
s
Pokud parametr obsahuje pouze čas a žádné datum, použije se aktuální datum, pokud style
parametr neobsahuje DateTimeStyles.NoCurrentDateDefault příznak. V takovém případě se použije výchozí datum (DateTime.Date.MinValue
).
s
Pokud parametr obsahuje pouze datum a žádný čas, použije se půlnoc (00:00:00). Parametr style
také určuje, zda s
parametr může obsahovat počáteční, vnitřní nebo koncové prázdné znaky jiné než povolené jedním z formátovacích řetězců v formats
nástroji .
Pokud s
neobsahuje žádné informace o časovém pásmu Kind , vlastnost vráceného DateTime objektu je DateTimeKind.Unspecified. Toto chování lze změnit pomocí příznaku DateTimeStyles.AssumeLocal , který vrací DateTime hodnotu, jejíž Kind vlastnost je DateTimeKind.Local, nebo pomocí DateTimeStyles.AssumeUniversal příznaků a DateTimeStyles.AdjustToUniversal , které vrací DateTime hodnotu, jejíž Kind vlastnost je DateTimeKind.Utc. Pokud s
obsahuje informace o časovém pásmu, čas se v případě potřeby převede na místní čas a Kind vlastnost vráceného DateTime objektu je nastavena na DateTimeKind.Localhodnotu . Toto chování lze změnit pomocí příznaku DateTimeStyles.RoundtripKind , který nepřevedá koordinovaný univerzální čas (UTC) na místní čas a nastaví Kind vlastnost na DateTimeKind.Utc.
Parametr formats
obsahuje pole vzorů, z nichž s
jeden se musí přesně shodovat, pokud má být operace parse úspěšná. Vzory v parametru formats
se skládají z jednoho nebo více specifikátorů vlastního formátu z tabulky Řetězce formátu vlastního data a času nebo z jednoho specifikátoru standardního formátu, který identifikuje předdefinovaný vzor, z tabulky Standardní formátovací řetězce data a času .
Pokud ve vzoru vlastního formátu nepoužíváte oddělovače data nebo času, použijte pro provider
parametr invariantní jazykovou verzi a nejširší formu každého specifikátoru vlastního formátu. Pokud například chcete zadat hodiny ve vzorku, určete širší tvar "HH" místo užšího formátu "H".
Parametr styles
obsahuje jeden nebo více členů výčtuDateTimeStyles, které určují, zda a kde se mohou zobrazit s
prázdné znaky, které nejsou definovány, format
a které řídí přesné chování operace parsování. Následující tabulka popisuje, jak každý člen výčtu DateTimeStyles ovlivňuje operaci ParseExact(String, String, IFormatProvider, DateTimeStyles) metody.
Člen DateTimeStyles | Description |
---|---|
AdjustToUniversal | Provede analýzu s a v případě potřeby převede na UTC. Pokud s obsahuje posun časového pásma nebo pokud s neobsahuje žádné informace o časovém pásmu, ale styles obsahuje DateTimeStyles.AssumeLocal příznak, metoda analyzuje řetězec, zavolá ToUniversalTime k převodu vrácené DateTime hodnoty 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 DateTimeStyles.AssumeUniversal příznak, metoda analyzuje řetězec, neprovádí 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ý vliv. |
AllowInnerWhite | Určuje, že se mezi libovolným prvkem data nebo času může zobrazit prázdné místo, které není definováno format . |
AllowLeadingWhite | Určuje, že prázdné znaky, které nejsou definovány uživatelemformat , se mohou zobrazit na začátku .s |
AllowTrailingWhite | Určuje, že se na konci objektu může zobrazit prázdné znaky, které format nejsou definovány nástrojem s . |
AllowWhiteSpaces | Určuje, že s může obsahovat počáteční, vnitřní a koncové prázdné znaky, které nejsou definovány nástrojem format . |
AssumeLocal | Určuje, že pokud s chybí informace o časovém pásmu, předpokládá se, že představuje místní čas. Pokud není DateTimeStyles.AdjustToUniversal příznak přítomen, Kind vlastnost vrácené DateTime hodnoty je nastavena na DateTimeKind.Localhodnotu . |
AssumeUniversal | Určuje, že pokud s chybí informace o časovém pásmu, předpokládá se, že představují UTC.
DateTimeStyles.AdjustToUniversal Pokud není příznak přítomen, metoda převede vrácenou DateTime hodnotu z UTC na místní čas a nastaví její Kind vlastnost na DateTimeKind.Local. |
NoCurrentDateDefault | Pokud s obsahuje čas bez informací o datu, nastaví se datum návratové hodnoty na DateTime.MinValue.Date hodnotu . |
None | Parametr s se parsuje pomocí výchozích hodnot. Nejsou povoleny žádné jiné prázdné znaky než ty, které jsou v format souboru. Pokud s chybí komponenta data, datum vrácené DateTime hodnoty se nastaví na 1.1.0001. Pokud s neobsahuje žádné informace o časovém pásmu Kind , je vlastnost vráceného DateTime objektu nastavená na DateTimeKind.Unspecifiedhodnotu . Pokud se informace o časovém pásmu nacházejí v s souboru , čas se převede na místní čas a Kind vlastnost vráceného DateTime objektu je nastavena na DateTimeKind.Local. |
RoundtripKind | U řetězců, které obsahují informace o časovém pásmu, se pokusí zabránit převodu na datum a čas s jeho Kind vlastností nastavenou na DateTimeKind.Localhodnotu . Tento příznak zabraňuje především převodu času UTC na místní čas. |
Konkrétní symboly data a času a řetězce (například názvy dnů v týdnu v konkrétním jazyce) použité v s
nástroji jsou definovány parametrem provider
, stejně jako přesný formát s
řetězce if format
je standardní řetězec specifikátoru formátu. Parametr provider
může být libovolný z následujících:
Objekt CultureInfo , který představuje jazykovou verzi použitou k interpretaci
s
. Objekt DateTimeFormatInfo vrácený jeho DateTimeFormat vlastností definuje symboly a formátování vs
.Objekt DateTimeFormatInfo , který definuje formát dat data a času.
Vlastní IFormatProvider implementace, jejíž GetFormat metoda vrací buď CultureInfo objekt, nebo DateTimeFormatInfo objekt, který poskytuje informace o formátování.
Pokud provider
je null
, použije se CultureInfo objekt, který odpovídá aktuální jazykové verzi.
Poznámky pro volající
V rozhraní .NET Framework 4 ParseExact metoda vyvolá FormatException , pokud řetězec, který se má analyzovat, obsahuje komponentu hodiny a označení do hodiny a odpoledne, které nejsou ve shodě. V rozhraní .NET Framework 3.5 a starších verzích je návrh do hodiny do večera ignorován.
Viz také
- TryParseExact
- 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