DateTime.ParseExact Metod

Definition

Namnområde:: System

Sammansättningar:: mscorlib.dll, System.Runtime.dll

Sammansättningar:: netstandard.dll, System.Runtime.dll

Sammansättning:: System.Runtime.dll

Sammansättning:: mscorlib.dll

Sammansättning:: netstandard.dll

Viktigt

En del information gäller för förhandsversionen av en produkt och kan komma att ändras avsevärt innan produkten blir allmänt tillgänglig. Microsoft lämnar inga garantier, uttryckliga eller underförstådda, avseende informationen som visas här.

Konverterar den angivna strängrepresentationen av ett datum och en tid till motsvarande DateTime . Formatet för strängrepresentationen måste matcha ett angivet format exakt eller så genereras ett undantag.

Överlagringar

Name	Description
ParseExact(String, String, IFormatProvider)	Konverterar den angivna strängrepresentationen av ett datum och en tid till dess DateTime motsvarighet med hjälp av det angivna formatet och den kulturspecifika formatinformationen. Formatet för strängrepresentationen måste matcha det angivna formatet exakt.
ParseExact(ReadOnlySpan<Char>, ReadOnlySpan<Char>, IFormatProvider, DateTimeStyles)	Konverterar den angivna spännviddsrepresentationen av ett datum och en tid till dess DateTime motsvarighet med det angivna formatet, kulturspecifik formatinformation och formatmall. Formatet för strängrepresentationen måste matcha det angivna formatet exakt eller så genereras ett undantag.
ParseExact(ReadOnlySpan<Char>, String[], IFormatProvider, DateTimeStyles)	Konverterar den angivna intervallrepresentationen av ett datum och en tid till motsvarande DateTime med den angivna matrisen med format, kulturspecifik formatinformation och formatmall. Formatet för strängrepresentationen måste matcha minst ett av de angivna formaten exakt eller så genereras ett undantag.
ParseExact(String, String, IFormatProvider, DateTimeStyles)	Konverterar den angivna strängrepresentationen av ett datum och en tid till dess DateTime motsvarighet med det angivna formatet, kulturspecifik formatinformation och formatmall. Formatet för strängrepresentationen måste matcha det angivna formatet exakt eller så genereras ett undantag.
ParseExact(String, String[], IFormatProvider, DateTimeStyles)	Konverterar den angivna strängrepresentationen av ett datum och en tid till dess DateTime motsvarighet med hjälp av den angivna matrisen med format, kulturspecifik formatinformation och formatmall. Formatet för strängrepresentationen måste matcha minst ett av de angivna formaten exakt eller så genereras ett undantag.

Kommentarer

Important

Epoker i de japanska kalendrarna baseras på kejsarens regeringstid och förväntas därför förändras. Den 1 maj 2019 markerade till exempel början av Reiwa-eran i JapaneseCalendar och JapaneseLunisolarCalendar. En sådan ändring av era påverkar alla program som använder dessa kalendrar. Mer information och för att avgöra om dina program påverkas finns i Hantera en ny era i den japanska kalendern i .NET. Information om hur du testar dina program i Windows-system för att säkerställa att de är redo för tidsändringen finns i Förbereda ditt program för ändringen av den japanska eran. Funktioner i .NET som stöder kalendrar med flera epoker och bästa praxis när du arbetar med kalendrar som stöder flera epoker finns i Arbeta med epoker.

ParseExact(String, String, IFormatProvider)

Källa:: DateTime.cs

Källa:: DateTime.cs

Källa:: DateTime.cs

Källa:: DateTime.cs

Källa:: DateTime.cs

Konverterar den angivna strängrepresentationen av ett datum och en tid till dess DateTime motsvarighet med hjälp av det angivna formatet och den kulturspecifika formatinformationen. Formatet för strängrepresentationen måste matcha det angivna formatet exakt.

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

Parametrar

s: String

En sträng som innehåller ett datum och en tid som ska konverteras.

format: String

En formatspecificerare som definierar det format som krävs för s. Mer information finns i avsnittet Anmärkningar.

provider: IFormatProvider

Ett objekt som tillhandahåller kulturspecifik formatinformation om s.

Returer

DateTime

Ett objekt som motsvarar datum och tid i s, enligt angivet av format och provider.

Undantag

ArgumentNullException

s eller format är null.

FormatException

s eller format är en tom sträng.

-eller-

s innehåller inte ett datum och en tid som motsvarar det mönster som anges i format.

-eller-

Timkomponenten och AM/PM-designatorn i s är inte överens.

Exempel

I följande exempel visas ParseExact metoden.

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.

Kommentarer

Metoden DateTime.ParseExact(String, String, IFormatProvider) parsar strängrepresentationen av ett datum, som måste vara i det format som definieras av parametern format . Det kräver också att elementen Datum och tid< i strängrepresentationen av ett datum och en tid visas i den ordning som anges av >, och som < inte har något annat tomt utrymme än det som tillåts av >.formatsformat Om format definierar ett datum utan tidselement och parsningsåtgärden lyckas, har det resulterande DateTime värdet en tid på midnatt (00:00:00). Om format definierar en tid utan datumelement och parsningsåtgärden lyckas har det resulterande DateTime värdet ett datum på DateTime.Now.Date.

Om s inte representerar en tid i en viss tidszon och parsningsåtgärden lyckas är Kind DateTimeegenskapen för det returnerade DateTimeKind.Unspecified värdet . Om s representerar tiden i en viss tidszon och format tillåter att tidszonsinformation finns (till exempel om format är lika med standardformatsspecificerarna "o", "r" eller "u", eller om den innehåller "z", "zz" eller "zzz" anpassade formatspecificerare), Kind är DateTimeegenskapen för det returnerade DateTimeKind.Local värdet .

Parametern format är en sträng som innehåller antingen en enskild standardformatsspecificerare eller en eller flera anpassade formatspecificerare som definierar det format som krävs för s. Mer information om giltiga formateringskoder finns i Formatsträngar för standarddatum och tid eller anpassade datum- och tidsformatsträngar.

Note

Om format är ett anpassat formatmönster som inte innehåller datum- eller tidsavgränsare (till exempel "ååååÅMMddHHHmm"), använder du den invarianta kulturen för parametern provider och den bredaste formen för varje anpassad formatspecificerare. Om du till exempel vill ange timmar i formatmönstret anger du det bredare formuläret "HH", i stället för det smalare formuläret, "H".

De specifika datum- och tidssymboler och strängar (till exempel namn på veckodagarna på ett visst språk) som används i s definieras av parametern provider , liksom det exakta formatet för s om format är en standardformatsspecificeraresträng. Parametern provider kan vara något av följande:

Ett CultureInfo objekt som representerar den kultur som används för att tolka s. Objektet DateTimeFormatInfo som returneras av dess DateTimeFormat egenskap definierar symbolerna och formateringen i s.
Ett DateTimeFormatInfo objekt som definierar formatet för datum- och tidsdata.
En anpassad IFormatProvider implementering vars GetFormat metod returnerar antingen objektet CultureInfo eller objektet DateTimeFormatInfo som tillhandahåller formateringsinformation.

Om provider är nullanvänds det CultureInfo objekt som motsvarar den aktuella kulturen.

Anteckningar till anropare

I .NET Framework 4 genererar metoden ParseExact en FormatException om strängen som ska parsas innehåller en timkomponent och en AM/PM-designator som inte är överens. I .NET Framework 3.5 och tidigare versioner ignoreras AM/PM-designatorn.

Se även

Gäller för

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

Källa:: DateTime.cs

Källa:: DateTime.cs

Källa:: DateTime.cs

Källa:: DateTime.cs

Källa:: DateTime.cs

Konverterar den angivna spännviddsrepresentationen av ett datum och en tid till dess DateTime motsvarighet med det angivna formatet, kulturspecifik formatinformation och formatmall. Formatet för strängrepresentationen måste matcha det angivna formatet exakt eller så genereras ett undantag.

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

Parametrar

s: ReadOnlySpan<Char>

Ett intervall som innehåller de tecken som representerar ett datum och en tid som ska konverteras.

format: ReadOnlySpan<Char>

Ett intervall som innehåller de tecken som representerar en formatspecificerare som definierar det format som krävs för s.

provider: IFormatProvider

Ett objekt som tillhandahåller kulturspecifik formateringsinformation om s.

style: DateTimeStyles

En bitvis kombination av uppräkningsvärdena som ger ytterligare information om s, om formatelement som kan finnas i seller om konverteringen från s till ett DateTime värde. Ett typiskt värde att ange är None.

Returer

DateTime

Ett objekt som motsvarar datum och tid i s, enligt angivet av format, provideroch style.

Gäller för

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

Källa:: DateTime.cs

Källa:: DateTime.cs

Källa:: DateTime.cs

Källa:: DateTime.cs

Källa:: DateTime.cs

Konverterar den angivna intervallrepresentationen av ett datum och en tid till motsvarande DateTime med den angivna matrisen med format, kulturspecifik formatinformation och formatmall. Formatet för strängrepresentationen måste matcha minst ett av de angivna formaten exakt eller så genereras ett undantag.

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

Parametrar

s: ReadOnlySpan<Char>

Ett intervall som innehåller de tecken som representerar ett datum och en tid som ska konverteras.

formats: String[]

En matris med tillåtna format för s.

provider: IFormatProvider

Ett objekt som tillhandahåller kulturspecifik formatinformation om s.

style: DateTimeStyles

En bitvis kombination av uppräkningsvärden som anger det tillåtna formatet för s. Ett typiskt värde att ange är None.

Returer

DateTime

Ett objekt som motsvarar datum och tid i s, enligt angivet av formats, provideroch style.

Gäller för

ParseExact(String, String, IFormatProvider, DateTimeStyles)

Källa:: DateTime.cs

Källa:: DateTime.cs

Källa:: DateTime.cs

Källa:: DateTime.cs

Källa:: DateTime.cs

Konverterar den angivna strängrepresentationen av ett datum och en tid till dess DateTime motsvarighet med det angivna formatet, kulturspecifik formatinformation och formatmall. Formatet för strängrepresentationen måste matcha det angivna formatet exakt eller så genereras ett undantag.

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

Parametrar

s: String

En sträng som innehåller ett datum och en tid som ska konverteras.

format: String

En formatspecificerare som definierar det format som krävs för s. Mer information finns i avsnittet Anmärkningar.

provider: IFormatProvider

Ett objekt som tillhandahåller kulturspecifik formateringsinformation om s.

style: DateTimeStyles

Returer

DateTime

Ett objekt som motsvarar datum och tid i s, enligt angivet av format, provideroch style.

Undantag

ArgumentNullException

s eller format är null.

FormatException

s eller format är en tom sträng.

-eller-

s innehåller inte ett datum och en tid som motsvarar det mönster som anges i format.

-eller-

Timkomponenten och AM/PM-designatorn i s är inte överens.

ArgumentException

style innehåller en ogiltig kombination av DateTimeStyles värden. Till exempel både AssumeLocal och AssumeUniversal.

Exempel

I följande exempel visas ParseExact(String, String, IFormatProvider) metoden. Observera att strängen " 5/01/2009 8:30 AM" inte kan parsas när parametern styles är lika med eftersom inledande blanksteg inte tillåts DateTimeStyles.None av format. Dessutom kan strängen "5/01/2009 09:00" inte parsas korrekt med " format MM/dd/yyyyyhh:mm" eftersom datumsträngen inte föregår månadsnumret med en inledande nolla, som format kräver.

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

Kommentarer

Metoden DateTime.ParseExact(String, String, IFormatProvider, DateTimeStyles) parsar strängrepresentationen av ett datum, som måste vara i ett format som definieras av parametern format . Det kräver också att datum- och tidselementen i s visas i den ordning som anges av format. Om s inte matchar mönstret för parametern format , med eventuella variationer som definieras av parametern style , genererar metoden en FormatException. Metoden parsar däremot DateTime.Parse(String, IFormatProvider, DateTimeStyles) strängrepresentationen av ett datum i något av formaten som identifieras av formatproviderns DateTimeFormatInfo objekt. Metoden DateTime.Parse(String, IFormatProvider, DateTimeStyles) tillåter också att datum- och tidselementen i s visas i valfri ordning.

Om parametern s endast innehåller en tid och inget datum används det aktuella datumet såvida inte parametern style innehåller DateTimeStyles.NoCurrentDateDefault flaggan, i vilket fall standarddatumet (DateTime.Date.MinValue) används. Om parametern s endast innehåller ett datum och ingen tid används midnatt (00:00:00). Parametern style avgör också om parametern s kan innehålla inledande, inre eller avslutande blankstegstecken.

Om s innehåller ingen tidszonsinformation är Kindegenskapen för DateTime det returnerade DateTimeKind.Unspecified objektet . Det här beteendet kan ändras med hjälp DateTimeStyles.AssumeLocal av flaggan, som returnerar ett DateTime värde vars Kind egenskap är DateTimeKind.Local, eller med hjälp av flaggorna DateTimeStyles.AssumeUniversal och DateTimeStyles.AdjustToUniversal som returnerar ett DateTime värde vars Kind egenskap är DateTimeKind.Utc. Om s innehåller tidszonsinformation konverteras tiden till lokal tid, om det behövs, och Kind egenskapen för det returnerade DateTime objektet är inställd på DateTimeKind.Local. Det här beteendet kan ändras med hjälp DateTimeStyles.RoundtripKind av flaggan för att inte konvertera Coordinated Universal Time (UTC) till en lokal tid och för att ange Kind egenskapen till DateTimeKind.Utc.

Parametern format definierar det obligatoriska mönstret för parametern s . Den kan bestå av antingen en eller flera anpassade formatspecificerare från tabellen Anpassade datum- och tidsformatsträngar , eller en enda standardformatsspecificerare som identifierar ett fördefinierat mönster från tabellen Standard datum- och tidsformatsträngar .

Om du inte använder datum- eller tidsavgränsare i ett anpassat formatmönster använder du den invarianta kulturen för parametern provider och den bredaste formen för varje anpassad formatspecificerare. Om du till exempel vill ange timmar i mönstret anger du det bredare formuläret , "HH", i stället för det smalare formuläret , "H".

Note

I stället för att kräva att detta s överensstämmer med ett enda format för att parsningsåtgärden ska lyckas kan du anropa DateTime.ParseExact(String, String[], IFormatProvider, DateTimeStyles) metoden och ange flera tillåtna format. Detta gör parsningsåtgärden mer sannolikt att lyckas.

Parametern styles innehåller en eller flera medlemmar i DateTimeStyles uppräkningen som avgör om och var tomt utrymme som inte definieras av format kan visas i s och som styr det exakta beteendet för parsningsåtgärden. I följande tabell beskrivs hur varje medlem i DateTimeStyles uppräkningen påverkar metodens ParseExact(String, String, IFormatProvider, DateTimeStyles) funktion.

DateTimeStyles-medlem	Description
AdjustToUniversal	Parsar `s` och konverterar den vid behov till UTC. Om `s` innehåller en tidszonsförskjutning, eller om `s` den inte innehåller någon tidszonsinformation men `styles` innehåller DateTimeStyles.AssumeLocal flaggan, parsar metoden strängen, anropar ToUniversalTime för att konvertera det returnerade DateTime värdet till UTC och anger Kind egenskapen till DateTimeKind.Utc. Om `s` anger att den representerar UTC, eller om `s` den inte innehåller tidszonsinformation men `styles` innehåller DateTimeStyles.AssumeUniversal flaggan, parsar metoden strängen, utför ingen tidszonskonvertering på det returnerade DateTime värdet och anger Kind egenskapen till DateTimeKind.Utc. I alla andra fall har flaggan ingen effekt.
AllowInnerWhite	Anger att tomt utrymme som inte definieras av `format` kan visas mellan ett enskilt datum- eller tidselement.
AllowLeadingWhite	Anger att tomt utrymme som inte definieras av `format` kan visas i början av `s`.
AllowTrailingWhite	Anger att tomt utrymme som inte definieras av `format` kan visas i slutet av `s`.
AllowWhiteSpaces	Anger som kan innehålla inledande, inre och avslutande blanksteg som `s` inte definieras av `format`.
AssumeLocal	Anger att om `s` det inte finns någon tidszonsinformation antas det representera en lokal tid. Om inte DateTimeStyles.AdjustToUniversal flaggan finns, sätts Kind-egenskapen för det returnerade DateTime-värdet till DateTimeKind.Local.
AssumeUniversal	Anger att om `s` det inte finns någon tidszonsinformation antas det representera UTC. DateTimeStyles.AdjustToUniversal Om inte flaggan finns konverterar metoden det returnerade DateTime värdet från UTC till lokal tid och anger dess Kind egenskap till DateTimeKind.Local.
NoCurrentDateDefault	Om `s` innehåller tid utan datuminformation anges returvärdets datum till `DateTime.MinValue.Date`.
None	Parametern `s` parsas med standardvärden. Inget tomt utrymme förutom det som finns i `format` tillåts. Om `s` det saknas en datumkomponent anges datumet för det returnerade DateTime värdet till 1/1/0001. Om `s` innehåller ingen tidszonsinformation Kind är egenskapen för det returnerade DateTime objektet inställd på DateTimeKind.Unspecified. Om tidszonsinformation finns i `s`konverteras tiden till lokal tid och Kind egenskapen för det returnerade DateTime objektet är inställd på DateTimeKind.Local.
RoundtripKind	För strängar som innehåller tidszonsinformation försöker du förhindra konverteringen till ett värdedatum och en DateTime tid med egenskapen Kind inställd på DateTimeKind.Local. Den här flaggan förhindrar främst konvertering av UTC-tider till lokala tider.

De specifika datum- och tidssymboler och strängar (till exempel namnen på veckodagarna på ett visst språk) som används i s definieras av parametern provider , liksom det exakta formatet för s om format är en standardformatsspecificeraresträng. Parametern provider kan vara något av följande:

Ett CultureInfo objekt som representerar den kultur som används för att tolka s. Objektet DateTimeFormatInfo som returneras av dess DateTimeFormat egenskap definierar symbolerna och formateringen i s.
Ett DateTimeFormatInfo objekt som definierar formatet för datum- och tidsdata.
En anpassad IFormatProvider implementering vars GetFormat metod returnerar antingen objektet CultureInfo eller objektet DateTimeFormatInfo som tillhandahåller formateringsinformation.

Om provider är nullanvänds det CultureInfo objekt som motsvarar den aktuella kulturen.

Anteckningar till anropare

Se även

Gäller för

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

Källa:: DateTime.cs

Källa:: DateTime.cs

Källa:: DateTime.cs

Källa:: DateTime.cs

Källa:: DateTime.cs

Konverterar den angivna strängrepresentationen av ett datum och en tid till dess DateTime motsvarighet med hjälp av den angivna matrisen med format, kulturspecifik formatinformation och formatmall. Formatet för strängrepresentationen måste matcha minst ett av de angivna formaten exakt eller så genereras ett undantag.

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

Parametrar

s: String

En sträng som innehåller ett datum och en tid som ska konverteras.

formats: String[]

En matris med tillåtna format för s. Mer information finns i avsnittet Anmärkningar.

provider: IFormatProvider

Ett objekt som tillhandahåller kulturspecifik formatinformation om s.

style: DateTimeStyles

En bitvis kombination av uppräkningsvärden som anger det tillåtna formatet för s. Ett typiskt värde att ange är None.

Returer

DateTime

Ett objekt som motsvarar datum och tid i s, enligt angivet av formats, provideroch style.

Undantag

ArgumentNullException

s eller formats är null.

FormatException

s är en tom sträng.

-eller-

ett element i formats är en tom sträng.

-eller-

s innehåller inte ett datum och en tid som motsvarar något element i formats.

-eller-

Timkomponenten och AM/PM-designatorn i s är inte överens.

ArgumentException

style innehåller en ogiltig kombination av DateTimeStyles värden. Till exempel både AssumeLocal och AssumeUniversal.

Exempel

I följande exempel används DateTime.ParseExact(String, String[], IFormatProvider, DateTimeStyles) metoden för att säkerställa att en sträng i ett antal möjliga format kan parsas .

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.

Kommentarer

Metoden DateTime.ParseExact(String, String[], IFormatProvider, DateTimeStyles) parsar strängrepresentationen av ett datum som matchar något av de mönster som tilldelats parametern formats . Om strängen s inte matchar något av dessa mönster med någon av de varianter som definieras av parametern styles , genererar metoden en FormatException. Förutom att jämföra med s flera formateringsmönster, i stället för ett enda formateringsmönster, fungerar den här överlagringen DateTime.ParseExact(String, String, IFormatProvider, DateTimeStyles) identiskt med metoden.

Parametern s innehåller datum och tid som ska parsas. Om parametern s endast innehåller en tid och inget datum används det aktuella datumet såvida inte parametern style innehåller DateTimeStyles.NoCurrentDateDefault flaggan, i vilket fall standarddatumet (DateTime.Date.MinValue) används. Om parametern s endast innehåller ett datum och ingen tid används midnatt (00:00:00). Parametern style avgör också om parametern s kan innehålla inledande, inre eller avslutande blankstegstecken förutom de som tillåts av en av formatsträngarna i formats.

Parametern formats innehåller en matris med mönster, varav s en måste matcha exakt om parsningsåtgärden ska lyckas. Mönstren i parametern formats består av en eller flera anpassade formatspecificerare från tabellen Anpassade datum- och tidsformatsträngar , eller en enda standardformatsspecificerare, som identifierar ett fördefinierat mönster, från tabellen Standard datum- och tidsformatsträngar .

DateTimeStyles-medlem	Description
AdjustToUniversal	Parsar `s` och konverterar den vid behov till UTC. Om `s` innehåller en tidszonsförskjutning, eller om `s` den inte innehåller någon tidszonsinformation men `styles` innehåller DateTimeStyles.AssumeLocal flaggan, parsar metoden strängen, anropar ToUniversalTime för att konvertera det returnerade DateTime värdet till UTC och anger Kind egenskapen till DateTimeKind.Utc. Om `s` anger att den representerar UTC, eller om `s` den inte innehåller tidszonsinformation men `styles` innehåller DateTimeStyles.AssumeUniversal flaggan, parsar metoden strängen, utför ingen tidszonskonvertering på det returnerade DateTime värdet och anger Kind egenskapen till DateTimeKind.Utc. I alla andra fall har flaggan ingen effekt.
AllowInnerWhite	Anger att tomt utrymme som inte definieras av `format` kan visas mellan ett enskilt datum- eller tidselement.
AllowLeadingWhite	Anger att tomt utrymme som inte definieras av `format` kan visas i början av `s`.
AllowTrailingWhite	Anger att tomt utrymme som inte definieras av `format` kan visas i slutet av `s`.
AllowWhiteSpaces	Anger som kan innehålla inledande, inre och avslutande blanksteg som `s` inte definieras av `format`.
AssumeLocal	Anger att om `s` det inte finns någon tidszonsinformation antas det representera en lokal tid. Om inte DateTimeStyles.AdjustToUniversal flaggan finns, sätts Kind-egenskapen för det returnerade DateTime-värdet till DateTimeKind.Local.
AssumeUniversal	Anger att om `s` det inte finns någon tidszonsinformation antas det representera UTC. DateTimeStyles.AdjustToUniversal Om inte flaggan finns konverterar metoden det returnerade DateTime värdet från UTC till lokal tid och anger dess Kind egenskap till DateTimeKind.Local.
NoCurrentDateDefault	Om `s` innehåller tid utan datuminformation anges returvärdets datum till `DateTime.MinValue.Date`.
None	Parametern `s` parsas med standardvärden. Inget tomt utrymme förutom det som finns i `format` tillåts. Om `s` det saknas en datumkomponent anges datumet för det returnerade DateTime värdet till 1/1/0001. Om `s` innehåller ingen tidszonsinformation Kind är egenskapen för det returnerade DateTime objektet inställd på DateTimeKind.Unspecified. Om tidszonsinformation finns i `s`konverteras tiden till lokal tid och Kind egenskapen för det returnerade DateTime objektet är inställd på DateTimeKind.Local.
RoundtripKind	För strängar som innehåller tidszonsinformation försöker du förhindra konverteringen till ett datum och en tid med egenskapen Kind inställd på DateTimeKind.Local. Den här flaggan förhindrar främst konvertering av UTC-tider till lokala tider.

Ett CultureInfo objekt som representerar den kultur som används för att tolka s. Objektet DateTimeFormatInfo som returneras av dess DateTimeFormat egenskap definierar symbolerna och formateringen i s.
Ett DateTimeFormatInfo objekt som definierar formatet för datum- och tidsdata.
En anpassad IFormatProvider implementering vars GetFormat metod returnerar antingen objektet CultureInfo eller objektet DateTimeFormatInfo som tillhandahåller formateringsinformation.

Om provider är nullanvänds det CultureInfo objekt som motsvarar den aktuella kulturen.

Anteckningar till anropare

Se även

Gäller för

Feedback

Var den här sidan till hjälp?