DateTime.ParseExact Metoda

Odwołanie

Definicja

Przestrzeń nazw:: System

Zestaw:: System.Runtime.dll

Zestaw:: mscorlib.dll

Zestaw:: netstandard.dll

Ważne

Niektóre informacje odnoszą się do produktu w wersji wstępnej, który może zostać znacząco zmodyfikowany przed wydaniem. Firma Microsoft nie udziela żadnych gwarancji, jawnych lub domniemanych, w odniesieniu do informacji podanych w tym miejscu.

Konwertuje określoną reprezentację ciągu daty i godziny na odpowiednik DateTime . Format reprezentacji ciągu musi być zgodny z określonym formatem dokładnie lub zgłaszany jest wyjątek.

Przeciążenia

ParseExact(String, String, IFormatProvider)	Konwertuje określoną reprezentację ciągu daty i godziny na odpowiednik DateTime przy użyciu informacji o określonym formacie i formacie specyficznym dla kultury. Format ciągu reprezentującego musi dokładnie pasować do wskazanego formatu.
ParseExact(ReadOnlySpan<Char>, ReadOnlySpan<Char>, IFormatProvider, DateTimeStyles)	Konwertuje określoną reprezentację zakresu daty i godziny na jej DateTime odpowiednik przy użyciu określonego formatu, informacji o formacie specyficznym dla kultury i stylu. Format reprezentacji ciągu musi być zgodny z określonym formatem dokładnie lub zgłaszany jest wyjątek.
ParseExact(ReadOnlySpan<Char>, String[], IFormatProvider, DateTimeStyles)	Konwertuje określoną reprezentację zakresu daty i godziny na jej DateTime odpowiednik przy użyciu określonej tablicy formatów, informacji o formacie specyficznym dla kultury i stylu. Format reprezentacji ciągu musi być zgodny z co najmniej jednym z określonych formatów lub zgłaszanym wyjątkiem.
ParseExact(String, String, IFormatProvider, DateTimeStyles)	Konwertuje określoną reprezentację ciągu daty i godziny na jej DateTime odpowiednik przy użyciu określonego formatu, informacji o formacie specyficznym dla kultury i stylu. Format reprezentacji ciągu musi być zgodny z określonym formatem dokładnie lub zgłaszany jest wyjątek.
ParseExact(String, String[], IFormatProvider, DateTimeStyles)	Konwertuje określoną reprezentację ciągu daty i godziny na równoważną, DateTime używając określonej tablicy formatów, informacji o formacie specyficznym dla kultury i stylu. Format reprezentacji ciągu musi być zgodny z co najmniej jednym z określonych formatów lub zgłaszanym wyjątkiem.

Uwagi

Ważne

Ery w kalendarzach japońskich są oparte na suchem rzeszy i w związku z tym oczekuje się, że zmienią się. Na przykład 1 maja 2019 r. oznaczał początek ery Reiwa w i JapaneseCalendar JapaneseLunisolarCalendar . Taka zmiana ery ma wpływ na wszystkie aplikacje, które używają tych kalendarzy. Aby uzyskać więcej informacji i określić, czy dotyczy to aplikacji, zobacz Obsługa nowej ery w kalendarzu japońskim na platformie .NET. Aby uzyskać informacje na temat testowania aplikacji w Windows w celu zapewnienia ich gotowości na zmianę ery, zobacz Przygotowanie aplikacji na zmianę ery japońskiej. Aby uzyskać informacje o funkcjach na platformie .NET, które obsługują kalendarze z wieloma erami, oraz o najlepszych rozwiązaniach podczas pracy z kalendarzami, które obsługują wiele er, zobacz Praca z erami.

ParseExact(String, String, IFormatProvider)

Konwertuje określoną reprezentację ciągu daty i godziny na odpowiednik DateTime przy użyciu informacji o określonym formacie i formacie specyficznym dla kultury. Format ciągu reprezentującego musi dokładnie pasować do wskazanego formatu.

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

Ciąg zawierający datę i godzinę, które należy przekształcić.

format: String

Specyfikator formatu, który definiuje wymagany format s. Aby uzyskać więcej informacji, zobacz sekcję: Uwagi.

provider: IFormatProvider

Obiekt, który dostarcza informacje o formacie specyficznym dla kultury.s

Zwraca

DateTime

Obiekt, który jest odpowiednikiem daty i godziny zawartej w elemencie s, zgodnie z instrukcjami format i provider.

Wyjątki

ArgumentNullException

s lub format to null.

FormatException

s lub format jest pustym ciągiem.

-lub-

s nie zawiera daty i godziny odpowiadającej wzorzec określony w elemecie format.

-lub-

Składnik godziny i projektator AM/PM w elemencie s nie zgadzają się.

Przykłady

W poniższym przykładzie pokazano metodę 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.

Uwagi

Metoda DateTime.ParseExact(String, String, IFormatProvider) analizuje reprezentację ciągu daty, która musi być w formacie zdefiniowanym format przez parametr . Wymaga również, aby <Date> elementy i <Time> ciągu reprezentacja daty i godziny pojawiały się w kolejności określonej przez formatelement , i które s nie mają odstępu innego niż dozwolone przez format. Jeśli format definiuje datę bez elementu godziny, a operacja analizy powiedzie się, wynikowa DateTime wartość ma godzinę północy (00:00:00). Jeśli format definiuje godzinę bez elementu daty, a operacja analizy powiedzie się, wynikowa DateTime wartość ma datę DateTime.Now.Date.

Jeśli s nie reprezentuje czasu w określonej strefie czasowej, a operacja analizy powiedzie się, Kind właściwość zwracanej DateTime wartości to DateTimeKind.Unspecified. Jeśli s reprezentuje czas w określonej strefie czasowej i format umożliwia prezentowanie informacji o strefie czasowej (na przykład jeśli format jest równe specyfikatorom formatu niestandardowego "o", "r" lub "u" albo jeśli zawiera on specyfikatory formatu niestandardowego "z", "zz" lub "zzz"), Kind właściwość zwracanej DateTime wartości to DateTimeKind.Local.

Parametr format jest ciągiem zawierającym jeden specyfikator formatu standardowego lub co najmniej jeden specyfikator formatu niestandardowego sdefiniujący wymagany format . Aby uzyskać szczegółowe informacje na temat prawidłowych kodów formatowania, zobacz Ciągi formatu daty i godziny w warstwie Standardowa lub Niestandardowe ciągi formatu daty i godziny.

Uwaga

Jeśli format jest niestandardowym wzorcem formatu, który nie zawiera separatorów daty lub godziny (takich jak "yyyMMddHHHmm"), użyj niezmiennej kultury parametru provider i najszerszej formy każdego specyfikatora formatu niestandardowego. Jeśli na przykład chcesz określić godziny we wzorcu formatu, określ szerszy formularz "HH", zamiast węższego formularza "H".

Określone symbole i ciągi daty i godziny (takie jak nazwy dni tygodnia w określonym języku) są s definiowane przez provider parametr, podobnie jak dokładny format s , jeśli format jest standardowym ciągiem specyfikatora formatu. Parametr provider może być dowolny z następujących:

CultureInfo Obiekt reprezentujący kulturę używaną do interpretowania selementu . DateTimeFormatInfo Obiekt zwrócony przez jego DateTimeFormat właściwość definiuje symbole i formatowanie w pliku s.
DateTimeFormatInfo Obiekt, który definiuje format danych daty i godziny.
Implementacja niestandardowa IFormatProvider , której GetFormat metoda zwraca CultureInfo obiekt lub DateTimeFormatInfo obiekt, który udostępnia informacje o formatowaniu.

Jeśli provider jest to null, CultureInfo używany jest obiekt odpowiadający bieżącej kulturze.

Uwagi dotyczące wywoływania

W .NET Framework 4 metoda zgłasza FormatException wartość , jeśli ciąg do ParseExact przeanalizowania zawiera składnik godziny i projektator AM/PM, które nie są zgodne. W .NET Framework wersji 3.5 i starszych projektator am/PM jest ignorowany.

Zobacz też

Dotyczy

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

Konwertuje określoną reprezentację zakresu daty i godziny na jej DateTime odpowiednik przy użyciu określonego formatu, informacji o formacie specyficznym dla kultury i stylu. Format reprezentacji ciągu musi być zgodny z określonym formatem dokładnie lub zgłaszany jest wyjątek.

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>

Zakres zawierający znaki reprezentujące datę i godzinę konwersji.

format: ReadOnlySpan<Char>

Zakres zawierający znaki reprezentujące specyfikator formatu, który definiuje wymagany format s.

provider: IFormatProvider

Obiekt, który dostarcza informacje o formatowaniu specyficznym dla kultury.s

style: DateTimeStyles

Bitowa kombinacja wartości wyliczenia, która udostępnia dodatkowe informacje o selementach stylu, które mogą znajdować się w sobiekcie , lub o konwersji z s na DateTime wartość. Typową wartością do określenia jest None.

Zwraca

DateTime

Obiekt, który jest odpowiednikiem daty i godziny zawartej w selemencie , zgodnie z wartościami format, provideri style.

Dotyczy

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

Konwertuje określoną reprezentację zakresu daty i godziny na jej DateTime odpowiednik przy użyciu określonej tablicy formatów, informacji o formacie specyficznym dla kultury i stylu. Format reprezentacji ciągu musi być zgodny z co najmniej jednym z określonych formatów lub zgłaszanym wyjątkiem.

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>

Zakres zawierający znaki reprezentujące datę i godzinę konwersji.

formats: String[]

Tablica dozwolonych formatów .s

provider: IFormatProvider

Obiekt, który dostarcza informacje o formacie specyficznym dla kultury.s

style: DateTimeStyles

Bitowa kombinacja wartości wyliczenia wskazująca dozwolony format .s Typową wartością do określenia jest None.

Zwraca

DateTime

Obiekt, który jest odpowiednikiem daty i godziny zawartej w selemencie , zgodnie z wartościami formats, provideri style.

Dotyczy

ParseExact(String, String, IFormatProvider, DateTimeStyles)

Konwertuje określoną reprezentację ciągu daty i godziny na jej DateTime odpowiednik przy użyciu określonego formatu, informacji o formacie specyficznym dla kultury i stylu. Format reprezentacji ciągu musi być zgodny z określonym formatem dokładnie lub zgłaszany jest wyjątek.

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

Ciąg zawierający datę i godzinę konwersji.

format: String

Specyfikator formatu, który definiuje wymagany format s. Aby uzyskać więcej informacji, zobacz sekcję: Uwagi.

provider: IFormatProvider

Obiekt, który dostarcza informacje o formatowaniu specyficznym dla kultury.s

style: DateTimeStyles

Zwraca

DateTime

Obiekt, który jest odpowiednikiem daty i godziny zawartej w selemencie , zgodnie z wartościami format, provideri style.

Wyjątki

ArgumentNullException

s lub format ma wartość null.

FormatException

s lub format jest pustym ciągiem.

-lub-

s nie zawiera daty i godziny odpowiadającej wzorzec określony w formatelemecie .

-lub-

Składnik godziny i konfirator AM/PM w elemencie s nie zgadzają się.

ArgumentException

style zawiera nieprawidłową kombinację DateTimeStyles wartości. Na przykład zarówno , jak AssumeLocal i AssumeUniversal.

Przykłady

W poniższym przykładzie pokazano metodę ParseExact(String, String, IFormatProvider) . Należy pamiętać, że ciąg "5/01/2009 8:30 AM" nie może zostać pomyślnie przeanalizowany, gdy styles parametr jest równy, ponieważ spacje DateTimeStyles.None wiodące nie są dozwolone przez format. Ponadto nie można pomyślnie przeanalizować ciągu "5/01/2009 09:00" z wartością "MM/dd/yyyyhh:mm", ponieważ ciąg daty nie poprzedza numeru miesiąca z wiodącym zerem, zgodnie format z format wymaganiami.

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

Uwagi

Metoda DateTime.ParseExact(String, String, IFormatProvider, DateTimeStyles) analizuje reprezentację ciągu daty, która musi być w formacie zdefiniowanym format przez parametr . Wymaga również, aby elementy daty i godziny wyświetlane s w kolejności określonej przez format. Jeśli s wzorzec parametru nie jest zgodny ze wzorcem parametru format , z żadnymi odmianami zdefiniowanymi przez style parametr metoda zgłasza wyjątek FormatException. DateTime.Parse(String, IFormatProvider, DateTimeStyles) Natomiast metoda analizuje reprezentację ciągu daty w dowolnym formacie rozpoznawanym przez obiekt dostawcy DateTimeFormatInfo formatu. Metoda DateTime.Parse(String, IFormatProvider, DateTimeStyles) umożliwia również pojawienie się elementów s daty i godziny w dowolnej kolejności.

s Jeśli parametr zawiera tylko godzinę i nie datę, bieżąca data jest używana, chyba że style parametr zawiera flagęDateTimeStyles.NoCurrentDateDefault, w którym przypadku jest używana domyślna data (DateTime.Date.MinValue). s Jeśli parametr zawiera tylko datę i godzinę, zostanie użyta północ (00:00:00). Parametr style określa również, czy s parametr może zawierać znaki wiodące, wewnętrzne lub końcowe odstępy.

Jeśli s nie zawiera informacji o strefie czasowej, Kind właściwość zwróconego DateTime obiektu to DateTimeKind.Unspecified. To zachowanie można zmienić przy użyciu DateTimeStyles.AssumeLocal flagi , która zwraca DateTime wartość, której Kind właściwość to DateTimeKind.Local, lub za pomocą DateTimeStyles.AssumeUniversal flag i DateTimeStyles.AdjustToUniversal , która zwraca DateTime wartość, której Kind właściwość to DateTimeKind.Utc. Jeśli s zawiera informacje o strefie czasowej, czas jest konwertowany na czas lokalny, w razie potrzeby, a Kind właściwość zwróconego DateTime obiektu jest ustawiona na DateTimeKind.Localwartość . To zachowanie można zmienić przy użyciu DateTimeStyles.RoundtripKind flagi , aby nie konwertować uniwersalnego czasu koordynowanego (UTC) na czas lokalny i ustawić Kind właściwość na DateTimeKind.Utc.

Parametr format definiuje wymagany wzorzec parametru s . Może składać się z co najmniej jednego specyfikatora formatu niestandardowego z tabeli Ciągi formatu daty i godziny lub jednego standardowego specyfikatora formatu, który identyfikuje wstępnie zdefiniowany wzorzec z tabeli Ciągi formatu daty i godziny standardowej .

Jeśli nie używasz separatorów daty lub godziny we wzorcu formatu niestandardowego, użyj niezmiennej kultury dla parametru provider i najszerszej formy każdego specyfikatora formatu niestandardowego. Jeśli chcesz określić na przykład godziny we wzorcu, użyj szerszej formy „GG” zamiast węższej „G”.

Uwaga

Zamiast wymagać s , aby operacja analizy zakończyła się pomyślnie, można wywołać metodę DateTime.ParseExact(String, String[], IFormatProvider, DateTimeStyles) i określić wiele dozwolonych formatów. Dzięki temu operacja analizy będzie bardziej prawdopodobna.

Parametr styles zawiera jeden lub więcej elementów członkowskich DateTimeStyles wyliczenia, które określają, czy i gdzie nie zdefiniowano odstępu przez format program , mogą pojawiać się w s i które sterują dokładnym zachowaniem operacji analizy. W poniższej tabeli opisano, jak każdy element członkowski DateTimeStyles wyliczenia wpływa na działanie ParseExact(String, String, IFormatProvider, DateTimeStyles) metody.

Element członkowski DateTimeStyles	Opis
AdjustToUniversal	`s` Analizuje i w razie potrzeby konwertuje go na czas UTC. Jeśli `s` zawiera przesunięcie strefy czasowej lub jeśli `s` nie zawiera informacji o strefie czasowej, ale `styles` zawiera flagę DateTimeStyles.AssumeLocal , metoda analizuje ciąg, wywołuje ToUniversalTime metodę , aby przekonwertować zwróconą DateTime wartość na UTC i ustawia Kind właściwość na DateTimeKind.Utc. Jeśli `s` wskazuje, że reprezentuje utc lub jeśli `s` nie zawiera informacji o strefie czasowej, ale `styles` zawiera flagę DateTimeStyles.AssumeUniversal , metoda analizuje ciąg, nie wykonuje konwersji strefy czasowej na zwróconą DateTime wartość i ustawia Kind właściwość na DateTimeKind.Utcwartość . We wszystkich innych przypadkach flaga nie wywiera żadnego wpływu.
AllowInnerWhite	Określa, że odstęp niezdefiniowany przez `format` program może występować między dowolnym pojedynczym elementem daty lub godziny.
AllowLeadingWhite	Określa, że białe znaki niezdefiniowane przez `format` program mogą pojawić się na początku .`s`
AllowTrailingWhite	Określa, że biały znak niezdefiniowany przez `format` może być wyświetlany na końcu .`s`
AllowWhiteSpaces	Określa, że `s` może zawierać wiodące, wewnętrzne i końcowe białe spacje niezdefiniowane przez `format`.
AssumeLocal	Określa, że jeśli `s` brakuje informacji o strefie czasowej, przyjmuje się, że reprezentuje czas lokalny. Jeśli flaga DateTimeStyles.AdjustToUniversal nie jest obecna, Kind właściwość zwróconej DateTime wartości jest ustawiona na DateTimeKind.Localwartość .
AssumeUniversal	Określa, że jeśli `s` brakuje informacji o strefie czasowej, przyjmuje się, że reprezentuje UTC. Jeśli flaga DateTimeStyles.AdjustToUniversal nie jest obecna, metoda konwertuje zwracaną DateTime wartość z czasu UTC na czas lokalny i ustawia jej Kind właściwość na DateTimeKind.Local.
NoCurrentDateDefault	Jeśli `s` zawiera godzinę bez informacji o dacie, data zwracanej wartości jest ustawiona na wartość `DateTime.MinValue.Date`.
None	Parametr `s` jest analizowany przy użyciu wartości domyślnych. Nie jest dozwolone żadne białe znaki inne niż obecne w `format` elem. Jeśli `s` brakuje składnika daty, data zwracanej DateTime wartości jest ustawiona na 1/1/0001. Jeśli `s` nie zawiera informacji o strefie czasowej, Kind właściwość zwróconego DateTime obiektu jest ustawiona na wartość DateTimeKind.Unspecified. Jeśli informacje o strefie czasowej są obecne w `s`programie , czas jest konwertowany na czas lokalny, a Kind właściwość zwróconego DateTime obiektu jest ustawiona na DateTimeKind.Localwartość .
RoundtripKind	W przypadku ciągów zawierających informacje o strefie czasowej próbuje zapobiec konwersji na datę i godzinę wartości z jej Kind właściwością ustawioną DateTime na DateTimeKind.Localwartość . Ta flaga zapobiega przede wszystkim konwersji czasu UTC na czas lokalny.

Określone symbole i ciągi daty i godziny (takie jak nazwy dni tygodnia w określonym języku) są s definiowane przez provider parametr , podobnie jak dokładny format s , jeśli format jest standardowym ciągiem specyfikatora formatu. Parametr provider może być dowolnym z następujących:

CultureInfo Obiekt reprezentujący kulturę używaną do interpretowania selementu . Obiekt DateTimeFormatInfo zwracany przez jego DateTimeFormat właściwość definiuje symbole i formatowanie w pliku s.
DateTimeFormatInfo Obiekt, który definiuje format danych daty i godziny.
Implementacja niestandardowa IFormatProvider , której GetFormat metoda zwraca CultureInfo obiekt lub DateTimeFormatInfo obiekt, który dostarcza informacje o formatowaniu.

Jeśli provider parametr ma nullwartość , CultureInfo używany jest obiekt odpowiadający bieżącej kulturze.

Uwagi dotyczące wywoływania

W .NET Framework 4 metoda zgłasza FormatException wyjątek ParseExact , jeśli ciąg do przeanalizowania zawiera składnik godziny i projektowania AM/PM, które nie są zgodne. W .NET Framework 3.5 i starszych wersjach projektowania AM/PM jest ignorowany.

Zobacz też

Dotyczy

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

Konwertuje określoną reprezentację ciągu daty i godziny na równoważną, DateTime używając określonej tablicy formatów, informacji o formacie specyficznym dla kultury i stylu. Format reprezentacji ciągu musi być zgodny z co najmniej jednym z określonych formatów lub zgłaszanym wyjątkiem.

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

Ciąg zawierający datę i godzinę, które należy przekształcić.

formats: String[]

Tablica dozwolonych formatów .s Aby uzyskać więcej informacji, zobacz sekcję: Uwagi.

provider: IFormatProvider

Obiekt, który dostarcza informacje o formacie specyficznym dla kultury.s

style: DateTimeStyles

Bitowa kombinacja wartości wyliczenia wskazująca dozwolony format .s Typową wartością do określenia jest None.

Zwraca

DateTime

Obiekt, który jest odpowiednikiem daty i godziny zawartej w selemencie , zgodnie z wartościami formats, provideri style.

Wyjątki

ArgumentNullException

s lub formats ma wartość null.

FormatException

s jest pustym ciągiem.

-lub-

element elementu formats jest pustym ciągiem.

-lub-

snie zawiera daty i godziny odpowiadającej żadnemu elementowi .formats

-lub-

Składnik godziny i konfirator AM/PM w elemencie s nie zgadzają się.

ArgumentException

style zawiera nieprawidłową kombinację DateTimeStyles wartości. Na przykład zarówno , jak AssumeLocal i AssumeUniversal.

Przykłady

W poniższym przykładzie użyto DateTime.ParseExact(String, String[], IFormatProvider, DateTimeStyles) metody , aby upewnić się, że ciąg w wielu możliwych formatach można pomyślnie przeanalizować .

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.

Uwagi

Metoda DateTime.ParseExact(String, String[], IFormatProvider, DateTimeStyles) analizuje reprezentację ciągu daty zgodnej z dowolnym wzorcem przypisanym do parametru formats . Jeśli ciąg s nie pasuje do żadnego z tych wzorców z żadnymi odmianami zdefiniowanymi przez styles parametr , metoda zgłasza wyjątek FormatException. Oprócz porównywania s z wieloma wzorcami formatowania, a nie z pojedynczym wzorcem formatowania, to przeciążenie zachowuje się identycznie z DateTime.ParseExact(String, String, IFormatProvider, DateTimeStyles) metodą .

Parametr s zawiera datę i godzinę analizy. s Jeśli parametr zawiera tylko godzinę i nie datę, bieżąca data jest używana, chyba że style parametr zawiera flagęDateTimeStyles.NoCurrentDateDefault, w którym przypadku jest używana domyślna data (DateTime.Date.MinValue). s Jeśli parametr zawiera tylko datę i godzinę, zostanie użyta północ (00:00:00). Parametr style określa również, czy s parametr może zawierać znaki wiodące, wewnętrzne lub końcowe odstępy inne niż dozwolone przez jeden z ciągów formatu w pliku formats.

Parametr formats zawiera tablicę wzorców, z których s jedna musi być dokładnie zgodna, jeśli operacja analizy zakończy się pomyślnie. Wzorce w parametrze formats składają się z co najmniej jednego specyfikatora formatu niestandardowego z tabeli Ciągi formatu daty i godziny niestandardowej lub jednego standardowego specyfikatora formatu, który identyfikuje wstępnie zdefiniowany wzorzec z tabeli Ciągi formatu daty i godziny standardowej.

Element członkowski DateTimeStyles	Opis
AdjustToUniversal	`s` Analizuje i w razie potrzeby konwertuje go na czas UTC. Jeśli `s` zawiera przesunięcie strefy czasowej lub jeśli `s` nie zawiera informacji o strefie czasowej, ale `styles` zawiera flagę DateTimeStyles.AssumeLocal , metoda analizuje ciąg, wywołuje ToUniversalTime metodę , aby przekonwertować zwróconą DateTime wartość na UTC i ustawia Kind właściwość na DateTimeKind.Utc. Jeśli `s` wskazuje, że reprezentuje utc lub jeśli `s` nie zawiera informacji o strefie czasowej, ale `styles` zawiera flagę DateTimeStyles.AssumeUniversal , metoda analizuje ciąg, nie wykonuje konwersji strefy czasowej na zwróconą DateTime wartość i ustawia Kind właściwość na DateTimeKind.Utcwartość . We wszystkich innych przypadkach flaga nie wywiera żadnego wpływu.
AllowInnerWhite	Określa, że odstęp niezdefiniowany przez `format` program może występować między dowolnym pojedynczym elementem daty lub godziny.
AllowLeadingWhite	Określa, że białe znaki niezdefiniowane przez `format` program mogą pojawić się na początku .`s`
AllowTrailingWhite	Określa, że biały znak niezdefiniowany przez `format` może być wyświetlany na końcu .`s`
AllowWhiteSpaces	Określa, że `s` może zawierać wiodące, wewnętrzne i końcowe białe spacje niezdefiniowane przez `format`.
AssumeLocal	Określa, że jeśli `s` brakuje informacji o strefie czasowej, przyjmuje się, że reprezentuje czas lokalny. Jeśli flaga DateTimeStyles.AdjustToUniversal nie jest obecna, Kind właściwość zwróconej DateTime wartości jest ustawiona na DateTimeKind.Localwartość .
AssumeUniversal	Określa, że jeśli `s` brakuje informacji o strefie czasowej, przyjmuje się, że reprezentuje UTC. Jeśli flaga DateTimeStyles.AdjustToUniversal nie jest obecna, metoda konwertuje zwracaną DateTime wartość z czasu UTC na czas lokalny i ustawia jej Kind właściwość na DateTimeKind.Local.
NoCurrentDateDefault	Jeśli `s` zawiera godzinę bez informacji o dacie, data zwracanej wartości jest ustawiona na wartość `DateTime.MinValue.Date`.
None	Parametr `s` jest analizowany przy użyciu wartości domyślnych. Nie jest dozwolone żadne białe znaki inne niż obecne w `format` elem. Jeśli `s` brakuje składnika daty, data zwracanej DateTime wartości jest ustawiona na 1/1/0001. Jeśli `s` nie zawiera informacji o strefie czasowej, Kind właściwość zwróconego DateTime obiektu jest ustawiona na wartość DateTimeKind.Unspecified. Jeśli informacje o strefie czasowej są obecne w `s`programie , czas jest konwertowany na czas lokalny, a Kind właściwość zwróconego DateTime obiektu jest ustawiona na DateTimeKind.Localwartość .
RoundtripKind	W przypadku ciągów zawierających informacje o strefie czasowej próbuje zapobiec konwersji na datę i godzinę z właściwością Kind ustawioną na DateTimeKind.Localwartość . Ta flaga zapobiega przede wszystkim konwersji czasu UTC na czas lokalny.

Określone symbole i ciągi daty i godziny (takie jak nazwy dni tygodnia w określonym języku) są s definiowane przez provider parametr , podobnie jak dokładny format s , jeśli format jest standardowym ciągiem specyfikatora formatu. Parametr provider może być dowolnym z następujących:

CultureInfo Obiekt reprezentujący kulturę używaną do interpretowania selementu . Obiekt DateTimeFormatInfo zwracany przez jego DateTimeFormat właściwość definiuje symbole i formatowanie w pliku s.
DateTimeFormatInfo Obiekt, który definiuje format danych daty i godziny.
Implementacja niestandardowa IFormatProvider , której GetFormat metoda zwraca CultureInfo obiekt lub DateTimeFormatInfo obiekt, który dostarcza informacje o formatowaniu.

Jeśli provider parametr ma nullwartość , CultureInfo używany jest obiekt odpowiadający bieżącej kulturze.

Uwagi dotyczące wywoływania

Zobacz też

Dotyczy

Udostępnij za pośrednictwem

DateTime.ParseExact Metoda

Definicja

Przeciążenia

Uwagi

ParseExact(String, String, IFormatProvider)

Parametry

Zwraca

Wyjątki

Przykłady

Uwagi

Uwagi dotyczące wywoływania

Zobacz też

Dotyczy

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

Parametry

Zwraca

Dotyczy

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

Parametry

Zwraca

Dotyczy

ParseExact(String, String, IFormatProvider, DateTimeStyles)

Parametry

Zwraca

Wyjątki

Przykłady

Uwagi

Uwagi dotyczące wywoływania

Zobacz też

Dotyczy

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

Parametry

Zwraca

Wyjątki

Przykłady

Uwagi

Uwagi dotyczące wywoływania

Zobacz też

Dotyczy

Dodatkowe zasoby