DateTime.ParseExact Metoda

Definice

Obor názvů:: System

Sestavení:: mscorlib.dll, System.Runtime.dll

Sestavení:: netstandard.dll, System.Runtime.dll

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 nebo je vyvolán výjimka.

Přetížení

Name	Description
ParseExact(String, String, IFormatProvider)	Převede zadanou řetězcovou reprezentaci data a času na ekvivalent DateTime pomocí zadaného formátu a informací o formátu specifickém pro jazykovou verzi. Formát řetězcové reprezentace se musí přesně shodovat se zadaným formátem.
ParseExact(ReadOnlySpan<Char>, ReadOnlySpan<Char>, IFormatProvider, DateTimeStyles)	Převede zadanou reprezentaci data a času na ekvivalent DateTime pomocí zadaného formátu, informací o formátu specifickém pro jazykovou verzi a stylu. Formát řetězcové reprezentace se musí přesně shodovat se zadaným formátem nebo je vyvolán výjimka.
ParseExact(ReadOnlySpan<Char>, String[], IFormatProvider, DateTimeStyles)	Převede zadanou reprezentaci data a času na DateTime ekvivalent pomocí zadaného pole formátů, informací o formátu specifickém pro jazykovou verzi a stylu. Formát řetězcové reprezentace se musí shodovat s alespoň jedním ze zadaných formátů přesně nebo je vyvolán výjimka.
ParseExact(String, String, IFormatProvider, DateTimeStyles)	Převede zadanou řetězcovou reprezentaci data a času na ekvivalent DateTime pomocí zadaného formátu, informací o formátu specifickém pro jazykovou verzi a stylu. Formát řetězcové reprezentace se musí přesně shodovat se zadaným formátem nebo je vyvolán výjimka.
ParseExact(String, String[], IFormatProvider, DateTimeStyles)	Převede zadanou řetězcovou reprezentaci data a času na ekvivalent DateTime pomocí zadaného pole formátů, informací o formátu specifickém pro jazyk a styl. Formát řetězcové reprezentace se musí shodovat s alespoň jedním ze zadaných formátů přesně 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 označilo začátek období Reiwa v JapaneseCalendar a JapaneseLunisolarCalendar. Taková změna éry ovlivňuje všechny aplikace, které tyto kalendáře používají. Další informace a určení, zda jsou ovlivněny vaše aplikace, naleznete v tématu Zpracování nové éry v japonském kalendáři v .NET. Informace o testování aplikací v systémech Windows za účelem zajištění připravenosti na změnu v éře najdete v tématu Příprava aplikace na změnu japonské éry. Funkce v .NET, které podporují kalendáře s více obdobími a osvědčené postupy při práci s kalendáři, které podporují více období, najdete v tématu Práce s obdobími.

ParseExact(String, String, IFormatProvider)

Zdroj:: DateTime.cs

Zdroj:: DateTime.cs

Zdroj:: DateTime.cs

Zdroj:: DateTime.cs

Zdroj:: DateTime.cs

Převede zadanou řetězcovou reprezentaci data a času na ekvivalent DateTime pomocí zadaného formátu a informací o formátu specifickém pro jazykovou verzi. Formát řetězcové reprezentace se musí přesně shodovat se zadaným formátem.

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 pro převod.

format: String

Specifikátor formátu, který definuje požadovaný 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

Návraty

DateTime

Objekt, který je ekvivalentní datu a času obsaženému v s, jak je uvedeno format v 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 odpovídající vzoru uvedenému v format.

nebo

Hodinová komponenta a návrh s AM/PM 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) analyzuje řetězcovou reprezentaci data, která musí být ve formátu definovaném parametrem format . Vyžaduje také, aby <prvky data> a času> řetězcového vyjádření data a <času byly uvedeny v pořadí určeném znakem format, a které s nemají jiné prázdné znaky, než které povoluje format. Pokud format definuje datum bez časového prvku a operace analýzy proběhne úspěšně, výsledná DateTime hodnota má čas půlnoci (00:00:00). Pokud format definuje čas bez prvku data a operace analýzy proběhne ú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 analýzy proběhne ú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řítomny (například pokud format se rovnají 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"), je DateTimeKind.Localvlastnost vrácené DateTime hodnoty .

Parametr format je řetězec, který obsahuje buď jeden standardní specifikátor formátu, nebo jeden nebo více specifikátorů vlastního formátu, které definují požadovaný formát s. Podrobnosti o platných kódech formátování najdete v tématu Standardní řetězce 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 "yyMMddHHmm"), použijte pro parametr invariantní jazykovou verzi provider a nejširší formu 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 určitém jazyce) používané s v určitém jazyce jsou definovány parametrem provider , stejně jako přesný formát řetězce specifikátoru standardního sformat formátu. Parametr provider může být některý 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í CultureInfo objekt nebo DateTimeFormatInfo objekt, který poskytuje informace o formátování.

Pokud provider je null, CultureInfo objekt, který odpovídá aktuální jazykové verzi je použit.

Poznámky pro volající

V rozhraní .NET Framework 4 vyvolá ParseExact metoda FormatException , pokud řetězec, který se má analyzovat, obsahuje hodinovou komponentu a designátor AM/PM, který není ve smlouvě. V rozhraní .NET Framework 3.5 a starších verzích se návrh AM/PM ignoruje.

Viz také

Platí pro

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

Zdroj:: DateTime.cs

Zdroj:: DateTime.cs

Zdroj:: DateTime.cs

Zdroj:: DateTime.cs

Zdroj:: DateTime.cs

Převede zadanou reprezentaci data a času na ekvivalent DateTime pomocí zadaného formátu, informací o formátu specifickém pro jazykovou verzi a stylu. Formát řetězcové reprezentace se musí přesně shodovat se zadaným formátem nebo je vyvolán výjimka.

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 pro převod.

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 sformátování specifické pro jazykovou verzi .

style: DateTimeStyles

Bitová kombinace hodnot výčtu, která poskytuje další informace o s, o style prvky, které mohou být přítomny , snebo o převodu z s hodnoty DateTime . Typická hodnota, kterou je třeba zadat, je None.

Návraty

DateTime

Objekt, který je ekvivalentní datu a času obsaženému v s, jak je určeno format, providera style.

Platí pro

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

Zdroj:: DateTime.cs

Zdroj:: DateTime.cs

Zdroj:: DateTime.cs

Zdroj:: DateTime.cs

Zdroj:: DateTime.cs

Převede zadanou reprezentaci data a času na DateTime ekvivalent pomocí zadaného pole formátů, informací o formátu specifickém pro jazykovou verzi a stylu. Formát řetězcové reprezentace se musí shodovat s alespoň jedním ze zadaných formátů přesně 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 pro převod.

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, kterou je třeba zadat, je None.

Návraty

DateTime

Objekt, který je ekvivalentní datu a času obsaženému v s, jak je určeno formats, providera style.

Platí pro

ParseExact(String, String, IFormatProvider, DateTimeStyles)

Zdroj:: DateTime.cs

Zdroj:: DateTime.cs

Zdroj:: DateTime.cs

Zdroj:: DateTime.cs

Zdroj:: DateTime.cs

Převede zadanou řetězcovou reprezentaci data a času na ekvivalent DateTime pomocí zadaného formátu, informací o formátu specifickém pro jazykovou verzi a stylu. Formát řetězcové reprezentace se musí přesně shodovat se zadaným formátem nebo je vyvolán výjimka.

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 pro převod.

format: String

Specifikátor formátu, který definuje požadovaný formát s. Další informace najdete v části Poznámky.

provider: IFormatProvider

Objekt, který poskytuje informace o sformátování specifické pro jazykovou verzi .

style: DateTimeStyles

Návraty

DateTime

Objekt, který je ekvivalentní datu a času obsaženému v s, jak je určeno 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 odpovídající vzoru uvedenému v format.

nebo

Hodinová komponenta a návrh s AM/PM nesouhlasí.

ArgumentException

style obsahuje neplatnou kombinaci DateTimeStyles hodnot. Například obojí AssumeLocal a 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 se styles parametr rovná, protože počáteční mezery DateTimeStyles.None nejsou povoleny format. Kromě toho řetězec "5/01/2009 09:00" nelze úspěšně analyzovat s format "MM/dd/yhh:mm", protože řetězec kalendářního data před číslem měsíce s ú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) analyzuje řetězcovou reprezentaci data, která musí být ve formátu definovaném parametrem format . Vyžaduje také, aby se prvky data a času zobrazovaly v s pořadí určeném parametrem format. Pokud s neodpovídá vzoru parametru format , se všemi variantami definovanými style parametrem vyvolá metoda FormatException. Naproti tomu DateTime.Parse(String, IFormatProvider, DateTimeStyles) metoda parsuje řetězcovou reprezentaci data v libovolném z formátů rozpoznaných objektem DateTimeFormatInfo zprostředkovatele formátu. Metoda DateTime.Parse(String, IFormatProvider, DateTimeStyles) také umožňuje, aby se prvky s data a času 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, zda 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 a DateTimeStyles.AdjustToUniversal příznaky, 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.Local. Toto chování lze změnit pomocí příznaku DateTimeStyles.RoundtripKind , který nepřevedá koordinovaný univerzální čas (UTC) na místní čas a nastavit Kind vlastnost na DateTimeKind.Utc.

Parametr format definuje požadovaný vzor parametru s . Může se skládat z jednoho nebo více specifikátorů vlastního formátu z tabulky Vlastní řetězce formátu data a času , nebo jednoho standardního specifikátoru formátu, který identifikuje předdefinovaný vzor z tabulky Standard Date and Time Format Strings .

Pokud nepoužíváte oddělovače data nebo času ve vlastním formátu, použijte pro parametr invariantní jazykovou verzi provider a nejširší formu specifikátoru vlastního formátu. Pokud například chcete zadat hodiny ve vzoru, zadejte širší tvar "HH" místo užšího tvaru "H".

Poznámka:

Místo toho, aby bylo nutné, aby s byla operace analýzy v souladu s jedním formátem, můžete metodu DateTime.ParseExact(String, String[], IFormatProvider, DateTimeStyles) volat a zadat více povolených formátů. Díky tomu bude operace analýzy s větší pravděpodobností úspěšná.

Parametr styles obsahuje jeden nebo více členů výčtu DateTimeStyles , které určují, zda a kde se mohou objevit prázdné znaky, které nejsou definovány format , s a které řídí přesné chování operace analýzy. Následující tabulka popisuje, jak každý člen výčtu DateTimeStyles ovlivňuje operaci ParseExact(String, String, IFormatProvider, DateTimeStyles) metody.

DateTimeStyles – člen	Description
AdjustToUniversal	Parsuje `s` a v případě potřeby ho převede na UTC. Pokud `s` zahrnuje 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řevezení 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 parsuje ř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á vliv.
AllowInnerWhite	Určuje, že prázdné znaky, které nejsou definovány, mohou být zobrazeny mezi libovolným prvkem `format` data nebo času.
AllowLeadingWhite	Určuje, že prázdné znaky, které nejsou definovány`format`, mohou být zobrazeny na začátku .`s`
AllowTrailingWhite	Určuje, že prázdné znaky, které nejsou definovány`format`, mohou být zobrazeny na konci .`s`
AllowWhiteSpaces	Určuje, že `s` může obsahovat úvodní, vnitřní a koncové prázdné znaky, které nejsou definovány `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í příznak DateTimeStyles.AdjustToUniversal přítomen, vlastnost Kind vrácené hodnoty DateTime je nastavena na DateTimeKind.Local.
AssumeUniversal	Určuje, že pokud `s` chybí informace o časovém pásmu, předpokládá se, že představuje UTC. DateTimeStyles.AdjustToUniversal Pokud není příznak přítomen, metoda převede vrácenou DateTime hodnotu z UTC na místní čas a nastaví jeho 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é prázdné znaky, které jsou přítomné.`format` Pokud `s` chybí součást data, je datum vrácené DateTime hodnoty 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.Unspecified. Pokud jsou informace o `s`časovém pásmu přítomny , č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 DateTime na datum a čas hodnoty s jeho Kind vlastností nastavenou na DateTimeKind.Local. Tento příznak primárně zabraňuje převodu časů UTC na místní časy.

Konkrétní symboly data a času a řetězce (například názvy dnů v týdnu v určitém jazyce) používané s parametrem provider jsou definovány, stejně jako přesný formát s , pokud format je standardní specifikátor formátu řetězce. Parametr provider může být některý 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í CultureInfo objekt nebo DateTimeFormatInfo objekt, který poskytuje informace o formátování.

Pokud provider je null, CultureInfo objekt, který odpovídá aktuální jazykové verzi je použit.

Poznámky pro volající

Viz také

Platí pro

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

Zdroj:: DateTime.cs

Zdroj:: DateTime.cs

Zdroj:: DateTime.cs

Zdroj:: DateTime.cs

Zdroj:: DateTime.cs

Převede zadanou řetězcovou reprezentaci data a času na ekvivalent DateTime pomocí zadaného pole formátů, informací o formátu specifickém pro jazyk a styl. Formát řetězcové reprezentace se musí shodovat s alespoň jedním ze zadaných formátů přesně nebo je vyvolán výjimka.

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 pro převod.

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, kterou je třeba zadat, je None.

Návraty

DateTime

Objekt, který je ekvivalentní datu a času obsaženému v s, jak je určeno formats, providera style.

Výjimky

ArgumentNullException

s nebo formats je null.

FormatException

s je prázdný řetězec.

nebo

prvek formats je prázdný řetězec.

nebo

s neobsahuje datum a čas, který odpovídá žádnému formatsprvku .

nebo

Hodinová komponenta a návrh s AM/PM nesouhlasí.

ArgumentException

style obsahuje neplatnou kombinaci DateTimeStyles hodnot. Například obojí AssumeLocal a 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ů lze úspěšně analyzovat .

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á libovolnému vzoru přiřazeného k parametru formats . Pokud řetězec s neodpovídá žádnému z těchto vzorů s žádnou z variant definovaných styles parametrem, metoda vyvolá FormatException. Kromě porovnání s s několika vzory formátování, nikoli 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ž ty, které jsou povoleny jedním z formátovacích řetězců v formats.

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 a DateTimeStyles.AdjustToUniversal příznaky, 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.Local. Toto chování lze změnit pomocí příznaku DateTimeStyles.RoundtripKind tak, aby nepřeveďte koordinovaný univerzální čas (UTC) na místní čas a nastavte Kind vlastnost na DateTimeKind.Utc.

Parametr formats obsahuje pole vzorů, z nichž s jedna se musí shodovat přesně v případě, že je operace analýzy úspěšná. Vzory v parametru formats se skládají z jedné nebo více specifikátorů vlastního formátu z tabulky Vlastní řetězce formátu data a času nebo jednoho standardního specifikátoru formátu, který identifikuje předdefinovaný vzor z tabulky Řetězce formátu standardního data a času .

DateTimeStyles – člen	Description
AdjustToUniversal	Parsuje `s` a v případě potřeby ho převede na UTC. Pokud `s` zahrnuje 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řevezení 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 parsuje ř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á vliv.
AllowInnerWhite	Určuje, že prázdné znaky, které nejsou definovány, mohou být zobrazeny mezi libovolným prvkem `format` data nebo času.
AllowLeadingWhite	Určuje, že prázdné znaky, které nejsou definovány`format`, mohou být zobrazeny na začátku .`s`
AllowTrailingWhite	Určuje, že prázdné znaky, které nejsou definovány`format`, mohou být zobrazeny na konci .`s`
AllowWhiteSpaces	Určuje, že `s` může obsahovat úvodní, vnitřní a koncové prázdné znaky, které nejsou definovány `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í příznak DateTimeStyles.AdjustToUniversal přítomen, vlastnost Kind vrácené hodnoty DateTime je nastavena na DateTimeKind.Local.
AssumeUniversal	Určuje, že pokud `s` chybí informace o časovém pásmu, předpokládá se, že představuje UTC. DateTimeStyles.AdjustToUniversal Pokud není příznak přítomen, metoda převede vrácenou DateTime hodnotu z UTC na místní čas a nastaví jeho 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é prázdné znaky, které jsou přítomné.`format` Pokud `s` chybí součást data, je datum vrácené DateTime hodnoty 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.Unspecified. Pokud jsou informace o `s`časovém pásmu přítomny , č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 s jeho Kind vlastností nastavenou na DateTimeKind.Local. Tento příznak primárně zabraňuje převodu časů UTC na místní časy.

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í CultureInfo objekt nebo DateTimeFormatInfo objekt, který poskytuje informace o formátování.

Pokud provider je null, CultureInfo objekt, který odpovídá aktuální jazykové verzi je použit.

Poznámky pro volající

Viz také

Platí pro

Váš názor

Byla tato stránka užitečná?

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

Váš názor