DateTime.ParseExact Metoda

Reference

Definice

Obor názvů:: System

Sestavení:: System.Runtime.dll

Sestavení:: mscorlib.dll

Sestavení:: netstandard.dll

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

DateTime

Objekt, který odpovídá datu a času obsaženému v objektu , jak je uvedeno v sformat a provider.

Výjimky

ArgumentNullException

s nebo format je null.

FormatException

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 formatv pořadí určeném nástrojem formata 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í v s.
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é

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

DateTime

Objekt, který odpovídá datu a času obsaženému v objektu , jak je uvedeno v sparametrech format, providera 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

DateTime

Objekt, který odpovídá datu a času obsaženému v objektu , jak je uvedeno v sparametrech formats, providera 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

Návraty

DateTime

Objekt, který odpovídá datu a času obsaženému v objektu , jak je uvedeno v sparametrech format, providera style.

Výjimky

ArgumentNullException

s nebo format je null.

FormatException

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í.

ArgumentException

style obsahuje neplatnou kombinaci DateTimeStyles hodnot. Například a AssumeLocal AssumeUniversal.

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živatelem`format`, 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í v s.
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í

Viz také

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

DateTime

Objekt, který odpovídá datu a času obsaženému v objektu , jak je uvedeno v sparametrech formats, providera style.

Výjimky

ArgumentNullException

s nebo formats je null.

FormatException

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 formatsprvku .

-nebo-

Hodinová komponenta a označení do hodiny a odpoledne v s systému nesouhlasí.

ArgumentException

style obsahuje neplatnou kombinaci DateTimeStyles hodnot. Například a AssumeLocal AssumeUniversal.

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 formatsnástroji .

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 .

Č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živatelem`format`, 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í v s.
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í

Viz také

Platí pro

Sdílet prostřednictvím

DateTime.ParseExact Metoda

Definice

Přetížení

Poznámky

ParseExact(String, String, IFormatProvider)

Parametry

Návraty

Výjimky

Příklady

Poznámky

Poznámky pro volající

Viz také

Platí pro

ParseExact(ReadOnlySpan<Char>, ReadOnlySpan<Char>, IFormatProvider, DateTimeStyles)

Parametry

Návraty

Platí pro

ParseExact(ReadOnlySpan<Char>, String[], IFormatProvider, DateTimeStyles)

Parametry

Návraty

Platí pro

ParseExact(String, String, IFormatProvider, DateTimeStyles)

Parametry

Návraty

Výjimky

Příklady

Poznámky

Poznámky pro volající

Viz také

Platí pro

ParseExact(String, String[], IFormatProvider, DateTimeStyles)

Parametry

Návraty

Výjimky

Příklady

Poznámky

Poznámky pro volající

Viz také

Platí pro

Další materiály