DateTime.ParseExact Metódus

Definíció

Névtér:: System

Szerelvények:: mscorlib.dll, System.Runtime.dll

Szerelvények:: netstandard.dll, System.Runtime.dll

Szerelvény:: System.Runtime.dll

Szerelvény:: mscorlib.dll

Szerelvény:: netstandard.dll

Fontos

Egyes információk olyan, kiadás előtti termékekre vonatkoznak, amelyek a kiadásig még jelentősen módosulhatnak. A Microsoft nem vállal kifejezett vagy törvényi garanciát az itt megjelenő információért.

Egy dátum és idő megadott sztring-ábrázolását konvertálja annak megfelelőjeként DateTime . A sztring-ábrázolás formátumának pontosan meg kell egyeznie egy megadott formátummal, vagy kivételt kell eredményeznie.

Túlterhelések

Name	Description
ParseExact(String, String, IFormatProvider)	Egy dátum és idő megadott sztring-ábrázolását a megadott formátum- és kultúraspecifikus formátumadatok használatával konvertálja DateTime annak megfelelővé. A sztring-ábrázolás formátumának pontosan meg kell egyeznie a megadott formátummal.
ParseExact(ReadOnlySpan<Char>, ReadOnlySpan<Char>, IFormatProvider, DateTimeStyles)	Egy dátum és idő megadott span-ábrázolását a megadott formátum, kultúraspecifikus formátumadatok és stílus használatával konvertálja DateTime annak megfelelővé. A sztring-ábrázolás formátumának pontosan meg kell egyeznie a megadott formátummal, vagy kivételt kell eredményeznie.
ParseExact(ReadOnlySpan<Char>, String[], IFormatProvider, DateTimeStyles)	Egy dátum és idő megadott span-ábrázolását a megadott formátumok, kultúraspecifikus formátumadatok és stílus használatával konvertálja DateTime annak megfelelővé. A sztring-ábrázolás formátumának pontosan meg kell egyeznie a megadott formátumok legalább egyikével, vagy kivételt kell eredményeznie.
ParseExact(String, String, IFormatProvider, DateTimeStyles)	Egy dátum és idő megadott sztringképét a megadott formátum, kultúraspecifikus formátumadatok és stílus használatával konvertálja DateTime annak megfelelővé. A sztring-ábrázolás formátumának pontosan meg kell egyeznie a megadott formátummal, vagy kivételt kell eredményeznie.
ParseExact(String, String[], IFormatProvider, DateTimeStyles)	Egy dátum és idő megadott sztring-ábrázolását a megadott formátumok, kultúraspecifikus formátumadatok és stílus használatával konvertálja DateTime annak megfelelővé. A sztring-ábrázolás formátumának pontosan meg kell egyeznie a megadott formátumok legalább egyikével, vagy kivételt kell eredményeznie.

Megjegyzések

Important

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

ParseExact(String, String, IFormatProvider)

Forrás:: DateTime.cs

Forrás:: DateTime.cs

Forrás:: DateTime.cs

Forrás:: DateTime.cs

Forrás:: DateTime.cs

Egy dátum és idő megadott sztring-ábrázolását a megadott formátum- és kultúraspecifikus formátumadatok használatával konvertálja DateTime annak megfelelővé. A sztring-ábrázolás formátumának pontosan meg kell egyeznie a megadott formátummal.

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

Paraméterek

s: String

Egy sztring, amely dátumot és időt tartalmaz az átalakításhoz.

format: String

Egy formátumkijelölő, amely meghatározza a szükséges formátumot s. További információkért lásd a Megjegyzések szakaszt.

provider: IFormatProvider

Egy objektum, amely a kultúraspecifikus formátuminformációkat startalmazza.

Válaszok

DateTime

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

Kivételek

ArgumentNullException

s vagy format az null.

FormatException

s vagy format üres sztring.

-vagy-

s nem tartalmaz olyan dátumot és időt, amely megfelel a megadott formatmintának.

-vagy-

Az óra összetevő és az AM/PM tervező s nem ért egyet.

Példák

Az alábbi példa a metódust ParseExact mutatja be.

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.

Megjegyzések

A DateTime.ParseExact(String, String, IFormatProvider) metódus elemzi egy dátum sztringképét, amelynek a paraméter által format meghatározott formátumban kell lennie. Azt is megköveteli, hogy a <dátum és idő sztringjének dátum> - és <időelemei> a megadott formatsorrendben jelenjenek meg, és a s megadotttól eltérő formatszabad területtel rendelkezzenek. Ha format időelem nélküli dátumot határoz meg, és az elemzési művelet sikeres, az eredményként kapott DateTime érték éjféli időponttal rendelkezik (00:00:00). Ha format dátumelem nélküli időt határoz meg, és az elemzési művelet sikeres, az eredményként kapott DateTime érték dátummal rendelkezik DateTime.Now.Date.

Ha s nem egy adott időzónában lévő időpontot jelöl, és az elemzési művelet sikeres, a Kind visszaadott DateTime érték tulajdonsága .DateTimeKind.Unspecified Ha s egy adott időzónában lévő időt jelöl, és format lehetővé teszi az időzóna információinak megjelenítését (például ha format egyenlő az "o", az "r" vagy az "u" szabványos formátumjelölőkkel, vagy ha a "z", "zz" vagy "zzz" egyéni formátumjelölőket tartalmazza), Kind akkor a visszaadott DateTime érték DateTimeKind.Localtulajdonsága .

A format paraméter egy sztring, amely egyetlen szabványos formátumkijelölőt vagy egy vagy több egyéni formátumjelölőt tartalmaz, amelyek meghatározzák a szükséges formátumot s. Az érvényes formázási kódokról további információt a Standard dátum- és időformátum sztringjei , illetve az egyéni dátum- és időformátum-sztringek című témakörben talál.

Note

Ha format olyan egyéni formátumminta, amely nem tartalmaz dátum- vagy időelválasztókat (például "yyyyMMddHmm"), használja az invariáns kultúrát az provider egyes egyéni formátumjelölők paraméteréhez és legszélesebb formájához. Ha például órákat szeretne megadni a formátummintában, adja meg a "HH" szélesebb űrlapot a "H" keskenyebb űrlap helyett.

Az adott dátum- és időszimbólumokat és sztringeket (például a hét napjainak nevét egy adott nyelven) s a provider paraméter határozza meg, ahogyan az is, hogy s egy szabványos formátumjelölő sztring pontos formátuma-eformat. A provider paraméter az alábbiak bármelyike lehet:

Az CultureInfo értelmezéshez shasznált kultúrát jelképező objektum. A DateTimeFormatInfo tulajdonsága által DateTimeFormat visszaadott objektum határozza meg a szimbólumokat és a formázást a következőben s: .
A DateTimeFormatInfo dátum- és időadatok formátumát meghatározó objektum.
Egyéni IFormatProvider implementáció, amelynek GetFormat metódusa vagy az CultureInfo objektumot adja DateTimeFormatInfo vissza, amely formázási információkat biztosít.

Ha provider igen null, akkor a rendszer az CultureInfo aktuális kultúrának megfelelő objektumot használja.

Megjegyzések a hívókhoz

A .NET Framework 4-ben a ParseExact metódus FormatException ad vissza, ha az elemezni kívánt sztring tartalmaz egy óra összetevőt és egy am/pm tervezőt, amely nem egyezett meg. A .NET Framework 3.5-ös és korábbi verzióiban a rendszer figyelmen kívül hagyja az AM/PM-tervezőt.

Lásd még

A következőre érvényes:

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

Forrás:: DateTime.cs

Forrás:: DateTime.cs

Forrás:: DateTime.cs

Forrás:: DateTime.cs

Forrás:: DateTime.cs

Egy dátum és idő megadott span-ábrázolását a megadott formátum, kultúraspecifikus formátumadatok és stílus használatával konvertálja DateTime annak megfelelővé. A sztring-ábrázolás formátumának pontosan meg kell egyeznie a megadott formátummal, vagy kivételt kell eredményeznie.

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

Paraméterek

s: ReadOnlySpan<Char>

Az átalakítandó dátumot és időt ábrázoló karaktereket tartalmazó span.

format: ReadOnlySpan<Char>

A formátumjelölő karaktereit tartalmazó span, amely meghatározza a szükséges formátumot s.

provider: IFormatProvider

Egy objektum, amely a kultúraspecifikus formázási sinformációkat tartalmazza.

style: DateTimeStyles

Az enumerálási értékek bitenkénti kombinációja, amely további információt nyújt a sstíluselemekről, amelyek megjelenhetnek saz értékké sDateTime alakításkor. Egy jellemzően megadható érték a következő None: .

Válaszok

DateTime

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

A következőre érvényes:

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

Forrás:: DateTime.cs

Forrás:: DateTime.cs

Forrás:: DateTime.cs

Forrás:: DateTime.cs

Forrás:: DateTime.cs

Egy dátum és idő megadott span-ábrázolását a megadott formátumok, kultúraspecifikus formátumadatok és stílus használatával konvertálja DateTime annak megfelelővé. A sztring-ábrázolás formátumának pontosan meg kell egyeznie a megadott formátumok legalább egyikével, vagy kivételt kell eredményeznie.

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

Paraméterek

s: ReadOnlySpan<Char>

Az átalakítandó dátumot és időt ábrázoló karaktereket tartalmazó span.

formats: String[]

A engedélyezett formátumainak tömbje s.

provider: IFormatProvider

Egy objektum, amely a kultúraspecifikus formátuminformációkat startalmazza.

style: DateTimeStyles

Az enumerálási értékek bitenkénti kombinációja, amely a megengedett formátumot sjelzi. Egy jellemzően megadható érték a következő None: .

Válaszok

DateTime

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

A következőre érvényes:

ParseExact(String, String, IFormatProvider, DateTimeStyles)

Forrás:: DateTime.cs

Forrás:: DateTime.cs

Forrás:: DateTime.cs

Forrás:: DateTime.cs

Forrás:: DateTime.cs

Egy dátum és idő megadott sztringképét a megadott formátum, kultúraspecifikus formátumadatok és stílus használatával konvertálja DateTime annak megfelelővé. A sztring-ábrázolás formátumának pontosan meg kell egyeznie a megadott formátummal, vagy kivételt kell eredményeznie.

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

Paraméterek

s: String

Dátumot és időt tartalmazó sztring az átalakításhoz.

format: String

Egy formátumkijelölő, amely meghatározza a szükséges formátumot s. További információkért lásd a Megjegyzések szakaszt.

provider: IFormatProvider

Egy objektum, amely a kultúraspecifikus formázási sinformációkat tartalmazza.

style: DateTimeStyles

Válaszok

DateTime

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

Kivételek

ArgumentNullException

s vagy format az null.

FormatException

s vagy format üres sztring.

-vagy-

s nem tartalmaz olyan dátumot és időt, amely megfelel a megadott formatmintának.

-vagy-

Az óra összetevő és az AM/PM tervező s nem ért egyet.

ArgumentException

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

Példák

Az alábbi példa a metódust ParseExact(String, String, IFormatProvider) mutatja be. Vegye figyelembe, hogy a "2009.05.01. 08:30" sztring nem elemezhető sikeresen, ha a paraméter egyenlőstyles, mert a DateTimeStyles.None kezdő szóközök nem engedélyezettekformat. Ezenkívül az "5/01/2009 09:00" sztring nem elemezhető sikeresen format az "MM/dd/yyyyyhh:mm" értékkel, mert a dátumsztring nem előzi meg a hónapszámot a kezdő nullával, ahogy format szükséges.

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

Megjegyzések

A DateTime.ParseExact(String, String, IFormatProvider, DateTimeStyles) metódus elemzi egy dátum sztringképét, amelynek a format paraméter által meghatározott formátumban kell lennie. Azt is megköveteli, hogy a dátum- és időelemek s a megadott formatsorrendben jelenjenek meg. Ha s nem egyezik meg a format paraméter mintájával, a paraméter által style definiált változatokkal együtt a metódus egy FormatException. Ezzel szemben a DateTime.Parse(String, IFormatProvider, DateTimeStyles) metódus a dátum sztring-ábrázolását elemzi a formátumszolgáltató objektuma által felismert formátumok bármelyikében DateTimeFormatInfo . A DateTime.Parse(String, IFormatProvider, DateTimeStyles) metódus lehetővé teszi a dátum- és időelemek s bármilyen sorrendben való megjelenítését.

Ha a s paraméter csak időt és dátumot tartalmaz, az aktuális dátumot használja a rendszer, kivéve, ha a style paraméter tartalmazza a DateTimeStyles.NoCurrentDateDefault jelölőt, ebben az esetben az alapértelmezett dátumot (DateTime.Date.MinValue) használja a rendszer. Ha a s paraméter csak dátumot és időpontot tartalmaz, a rendszer éjfélt (00:00:00) használ. A style paraméter azt is meghatározza, hogy a s paraméter tartalmazhat-e kezdő, belső vagy záró szóköz karaktereket.

Ha s nem tartalmaz időzóna-információt, a Kind visszaadott DateTime objektum tulajdonsága .DateTimeKind.Unspecified Ez a viselkedés megváltoztatható a DateTimeStyles.AssumeLocal jelölő használatával, amely egy DateTime olyan értéket ad vissza, amelynek Kind a tulajdonsága DateTimeKind.Local, vagy az DateTimeStyles.AssumeUniversal and DateTimeStyles.AdjustToUniversal flags használatával, amely egy DateTime olyan értéket ad vissza, amelynek Kind a tulajdonsága.DateTimeKind.Utc Ha s időzónaadatokat tartalmaz, az idő helyi idővé alakul, ha szükséges, és a Kind visszaadott DateTime objektum tulajdonsága a következőre DateTimeKind.Localvan állítva: . Ez a viselkedés úgy módosítható, hogy a DateTimeStyles.RoundtripKind jelölővel nem konvertálja az egyezményes világidőt (UTC) helyi idővé, és a tulajdonságot a Kind következőre DateTimeKind.Utcállítja.

A format paraméter határozza meg a paraméter szükséges mintáját s . Az egyéni dátum- és időformátum-sztringek táblából egy vagy több egyéni formátumjelölőből, vagy egy szabványos formátumkijelölőből állhat, amely egy előre definiált mintát azonosít a Standard Dátum és időformátum sztringek táblából.

Ha nem használ dátum- vagy időelválasztókat egyéni formátummintában, használja az invariáns kultúrát a provider paraméterhez és az egyes egyéni formátumkijelölők legszélesebb formájához. Ha például órákat szeretne megadni a mintában, adja meg a "HH" szélesebb űrlapot a "H" keskenyebb űrlap helyett.

Note

Ahelyett, hogy s az elemzési művelet egyetlen formátumának felelne meg, meghívhatja a DateTime.ParseExact(String, String[], IFormatProvider, DateTimeStyles) metódust, és több engedélyezett formátumot is megadhat. Ez nagyobb valószínűséggel teszi sikeressé az elemzési műveletet.

A styles paraméter az enumerálás egy vagy több tagját DateTimeStyles tartalmazza, amelyek meghatározzák, hogy megjelenhet-e és hol nem format definiált s üres terület, és ez szabályozza az elemzési művelet pontos viselkedését. Az alábbi táblázat azt ismerteti, hogy az DateTimeStyles enumerálás egyes részei hogyan befolyásolják a ParseExact(String, String, IFormatProvider, DateTimeStyles) metódus működését.

DateTimeStyles tagja	Leírás
AdjustToUniversal	`s` Elemzi és szükség esetén UTC-vé alakítja át. Ha `s` időzóna-eltolást tartalmaz, vagy ha `s` nem tartalmaz időzóna-információt, de `styles` tartalmazza a DateTimeStyles.AssumeLocal jelölőt, akkor a metódus elemzi a sztringet, meghívja ToUniversalTime a visszaadott DateTime érték UTC értékre konvertálását, és beállítja a Kind tulajdonságot DateTimeKind.Utc. Ha `s` azt jelzi, hogy utc értéket jelöl, vagy ha `s` nem tartalmaz időzóna-információt, de `styles` tartalmazza a DateTimeStyles.AssumeUniversal jelzőt, a metódus elemzi a sztringet, nem végez időzóna-átalakítást a visszaadott DateTime értéken, és a tulajdonságot a Kind következőre DateTimeKind.Utcállítja: . Minden más esetben a zászlónak nincs hatása.
AllowInnerWhite	Azt adja meg, hogy a nem definiált `format` szabad terület jelenhet meg az egyes dátum- és időelemek között.
AllowLeadingWhite	Azt adja meg, hogy a nem definiált `format` üres terület a következő elején `s`jelenhet meg:
AllowTrailingWhite	Azt adja meg, hogy a nem definiált `format` üres terület megjelenjen a `s`végén.
AllowWhiteSpaces	Megadja, hogy mely `s` szóközök tartalmazhatnak olyan kezdő, belső és záró szóközöket, amelyeket nem definiál a `format`rendszer.
AssumeLocal	Azt adja meg, hogy ha `s` nem áll rendelkezésre időzóna-információ, akkor a rendszer azt feltételezi, hogy egy helyi időpontot jelöl. Ha nincs megadva a DateTimeStyles.AdjustToUniversal jelölő, a Kind visszaadott DateTime érték tulajdonsága a következőre DateTimeKind.Localvan állítva: .
AssumeUniversal	Azt adja meg, hogy ha `s` nem áll rendelkezésre időzóna-információ, akkor feltételezzük, hogy az UTC-t jelöli. Ha nincs megadva a DateTimeStyles.AdjustToUniversal jelölő, a metódus a visszaadott DateTime értéket UTC-ről helyi időpontra konvertálja, és a tulajdonságát a következőre KindállítjaDateTimeKind.Local: .
NoCurrentDateDefault	Ha `s` dátumadatok nélküli időt tartalmaz, a visszatérési érték dátuma a következőre `DateTime.MinValue.Date`van állítva: .
None	A `s` paraméter az alapértelmezett értékekkel van elemezve. A jelen lévőn `format` kívül más szabad terület nem engedélyezett. Ha `s` nincs dátumösszetevő, a visszaadott DateTime érték dátuma 0001.01.01. Ha `s` nem tartalmaz időzóna-információt, a Kind visszaadott DateTime objektum tulajdonsága a következőre DateTimeKind.Unspecifiedvan állítva: . Ha az időzóna információi meg vannak jelen, `s`az idő helyi időre lesz konvertálva, és a Kind visszaadott DateTime objektum tulajdonsága a következőre DateTimeKind.Localvan állítva: .
RoundtripKind	Az időzóna-adatokat tartalmazó sztringek esetében megkísérli megakadályozni az értékdátumra DateTime és időre való átalakítást, amelynek tulajdonsága Kind a következőre DateTimeKind.Localvan állítva. Ez a jelző elsősorban megakadályozza az UTC-időpontok helyi időpontra való konvertálását.

Az adott dátum- és időszimbólumokat és sztringeket (például a hét napjainak nevét egy adott nyelven) s a paraméter határozza meg, csakúgy, mint a szabványos formátumjelölő sztring pontos formátumát providers.format A provider paraméter az alábbiak bármelyike lehet:

Az CultureInfo értelmezéshez shasznált kultúrát jelképező objektum. A DateTimeFormatInfo tulajdonsága által DateTimeFormat visszaadott objektum határozza meg a szimbólumokat és a formázást a következőben s: .
A DateTimeFormatInfo dátum- és időadatok formátumát meghatározó objektum.
Egyéni IFormatProvider implementáció, amelynek GetFormat metódusa vagy az CultureInfo objektumot adja DateTimeFormatInfo vissza, amely formázási információkat biztosít.

Ha provider igen null, akkor a rendszer az CultureInfo aktuális kultúrának megfelelő objektumot használja.

Megjegyzések a hívókhoz

Lásd még

A következőre érvényes:

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

Forrás:: DateTime.cs

Forrás:: DateTime.cs

Forrás:: DateTime.cs

Forrás:: DateTime.cs

Forrás:: DateTime.cs

Egy dátum és idő megadott sztring-ábrázolását a megadott formátumok, kultúraspecifikus formátumadatok és stílus használatával konvertálja DateTime annak megfelelővé. A sztring-ábrázolás formátumának pontosan meg kell egyeznie a megadott formátumok legalább egyikével, vagy kivételt kell eredményeznie.

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

Paraméterek

s: String

Egy sztring, amely dátumot és időt tartalmaz az átalakításhoz.

formats: String[]

A engedélyezett formátumainak tömbje s. További információkért lásd a Megjegyzések szakaszt.

provider: IFormatProvider

Egy objektum, amely a kultúraspecifikus formátuminformációkat startalmazza.

style: DateTimeStyles

Az enumerálási értékek bitenkénti kombinációja, amely a megengedett formátumot sjelzi. Egy jellemzően megadható érték a következő None: .

Válaszok

DateTime

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

Kivételek

ArgumentNullException

s vagy formats az null.

FormatException

s üres sztring.

-vagy-

egy elem formats egy üres sztring.

-vagy-

s nem tartalmaz olyan dátumot és időt, amely megfelel a formats.

-vagy-

Az óra összetevő és az AM/PM tervező s nem ért egyet.

ArgumentException

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

Példák

Az alábbi példa a DateTime.ParseExact(String, String[], IFormatProvider, DateTimeStyles) metódus használatával biztosítja, hogy egy sztring több lehetséges formátumban is sikeresen elemezhető legyen.

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.

Megjegyzések

A DateTime.ParseExact(String, String[], IFormatProvider, DateTimeStyles) metódus elemzi egy dátum sztringképét, amely megfelel a paraméterhez formats rendelt minták bármelyikének. Ha a sztring s nem egyezik meg ezen minták egyikével sem a paraméter által styles meghatározott változatokkal, a metódus egy FormatException. A több formázási mintával való összehasonlításon s kívül ez a túlterhelés ugyanúgy viselkedik, mint a DateTime.ParseExact(String, String, IFormatProvider, DateTimeStyles) metódus.

A s paraméter tartalmazza az elemzés dátumát és idejét. Ha a s paraméter csak időt és dátumot tartalmaz, az aktuális dátumot használja a rendszer, kivéve, ha a style paraméter tartalmazza a DateTimeStyles.NoCurrentDateDefault jelölőt, ebben az esetben az alapértelmezett dátumot (DateTime.Date.MinValue) használja a rendszer. Ha a s paraméter csak dátumot és időpontot tartalmaz, a rendszer éjfélt (00:00:00) használ. A style paraméter azt is meghatározza, hogy a s paraméter tartalmazhat-e olyan kezdő, belső vagy záró szóköz karaktereket, amelyek nem engedélyezettek a formázási sztringek egyikében formats.

A formats paraméter egy mintatömböt tartalmaz, amelyek s közül az egyiknek pontosan meg kell egyeznie, ha az elemzési művelet sikeres lesz. A paraméter mintái formats egy vagy több egyéni formátumjelölőből állnak az Egyéni dátum és időformátum sztringek táblából, vagy egy szabványos formátumkijelölőből, amely egy előre definiált mintát azonosít a Standard Dátum és időformátum sztringek táblából.

DateTimeStyles tagja	Leírás
AdjustToUniversal	`s` Elemzi és szükség esetén UTC-vé alakítja át. Ha `s` időzóna-eltolást tartalmaz, vagy ha `s` nem tartalmaz időzóna-információt, de `styles` tartalmazza a DateTimeStyles.AssumeLocal jelölőt, akkor a metódus elemzi a sztringet, meghívja ToUniversalTime a visszaadott DateTime érték UTC értékre konvertálását, és beállítja a Kind tulajdonságot DateTimeKind.Utc. Ha `s` azt jelzi, hogy utc értéket jelöl, vagy ha `s` nem tartalmaz időzóna-információt, de `styles` tartalmazza a DateTimeStyles.AssumeUniversal jelzőt, a metódus elemzi a sztringet, nem végez időzóna-átalakítást a visszaadott DateTime értéken, és a tulajdonságot a Kind következőre DateTimeKind.Utcállítja: . Minden más esetben a zászlónak nincs hatása.
AllowInnerWhite	Azt adja meg, hogy a nem definiált `format` szabad terület jelenhet meg az egyes dátum- és időelemek között.
AllowLeadingWhite	Azt adja meg, hogy a nem definiált `format` üres terület a következő elején `s`jelenhet meg:
AllowTrailingWhite	Azt adja meg, hogy a nem definiált `format` üres terület megjelenjen a `s`végén.
AllowWhiteSpaces	Megadja, hogy mely `s` szóközök tartalmazhatnak olyan kezdő, belső és záró szóközöket, amelyeket nem definiál a `format`rendszer.
AssumeLocal	Azt adja meg, hogy ha `s` nem áll rendelkezésre időzóna-információ, akkor a rendszer azt feltételezi, hogy egy helyi időpontot jelöl. Ha nincs megadva a DateTimeStyles.AdjustToUniversal jelölő, a Kind visszaadott DateTime érték tulajdonsága a következőre DateTimeKind.Localvan állítva: .
AssumeUniversal	Azt adja meg, hogy ha `s` nem áll rendelkezésre időzóna-információ, akkor feltételezzük, hogy az UTC-t jelöli. Ha nincs megadva a DateTimeStyles.AdjustToUniversal jelölő, a metódus a visszaadott DateTime értéket UTC-ről helyi időpontra konvertálja, és a tulajdonságát a következőre KindállítjaDateTimeKind.Local: .
NoCurrentDateDefault	Ha `s` dátumadatok nélküli időt tartalmaz, a visszatérési érték dátuma a következőre `DateTime.MinValue.Date`van állítva: .
None	A `s` paraméter az alapértelmezett értékekkel van elemezve. A jelen lévőn `format` kívül más szabad terület nem engedélyezett. Ha `s` nincs dátumösszetevő, a visszaadott DateTime érték dátuma 0001.01.01. Ha `s` nem tartalmaz időzóna-információt, a Kind visszaadott DateTime objektum tulajdonsága a következőre DateTimeKind.Unspecifiedvan állítva: . Ha az időzóna információi meg vannak jelen, `s`az idő helyi időre lesz konvertálva, és a Kind visszaadott DateTime objektum tulajdonsága a következőre DateTimeKind.Localvan állítva: .
RoundtripKind	Az időzóna-adatokat tartalmazó sztringek esetében megkísérli megakadályozni a dátumra és időre való konvertálást, amelynek tulajdonsága Kind a következőre DateTimeKind.Localvan állítva. Ez a jelző elsősorban megakadályozza az UTC-időpontok helyi időpontra való konvertálását.

Az CultureInfo értelmezéshez shasznált kultúrát jelképező objektum. A DateTimeFormatInfo tulajdonsága által DateTimeFormat visszaadott objektum határozza meg a szimbólumokat és a formázást a következőben s: .
A DateTimeFormatInfo dátum- és időadatok formátumát meghatározó objektum.
Egyéni IFormatProvider implementáció, amelynek GetFormat metódusa vagy az CultureInfo objektumot adja DateTimeFormatInfo vissza, amely formázási információkat biztosít.

Ha provider igen null, akkor a rendszer az CultureInfo aktuális kultúrának megfelelő objektumot használja.

Megjegyzések a hívókhoz

Lásd még

A következőre érvényes:

Visszajelzés

Hasznosnak találta ezt az oldalt?