DateTime.TryParseExact Metod

public:
 static bool TryParseExact(ReadOnlySpan<char> s, ReadOnlySpan<char> format, IFormatProvider ^ provider, System::Globalization::DateTimeStyles style, [Runtime::InteropServices::Out] DateTime % result);

public static bool TryParseExact(ReadOnlySpan<char> s, ReadOnlySpan<char> format, IFormatProvider provider, System.Globalization.DateTimeStyles style, out DateTime result);

static member TryParseExact : ReadOnlySpan<char> * ReadOnlySpan<char> * IFormatProvider * System.Globalization.DateTimeStyles * DateTime -> bool

Public Shared Function TryParseExact (s As ReadOnlySpan(Of Char), format As ReadOnlySpan(Of Char), provider As IFormatProvider, style As DateTimeStyles, ByRef result As DateTime) As Boolean

Parametrar

Returer

true om s har konverterats, annars false.

Undantag

public:
 static bool TryParseExact(ReadOnlySpan<char> s, cli::array <System::String ^> ^ formats, IFormatProvider ^ provider, System::Globalization::DateTimeStyles style, [Runtime::InteropServices::Out] DateTime % result);

public static bool TryParseExact(ReadOnlySpan<char> s, string[] formats, IFormatProvider provider, System.Globalization.DateTimeStyles style, out DateTime result);

static member TryParseExact : ReadOnlySpan<char> * string[] * IFormatProvider * System.Globalization.DateTimeStyles * DateTime -> bool

Public Shared Function TryParseExact (s As ReadOnlySpan(Of Char), formats As String(), provider As IFormatProvider, style As DateTimeStyles, ByRef result As DateTime) As Boolean

Parametrar

Returer

true om s har konverterats, annars false.

Undantag

public:
 static bool TryParseExact(System::String ^ s, System::String ^ format, IFormatProvider ^ provider, System::Globalization::DateTimeStyles style, [Runtime::InteropServices::Out] DateTime % result);

public static bool TryParseExact(string s, string format, IFormatProvider provider, System.Globalization.DateTimeStyles style, out DateTime result);

static member TryParseExact : string * string * IFormatProvider * System.Globalization.DateTimeStyles * DateTime -> bool

Public Shared Function TryParseExact (s As String, format As String, provider As IFormatProvider, style As DateTimeStyles, ByRef result As DateTime) As Boolean

Parametrar

Returer

true om s har konverterats, annars false.

Undantag

Exempel

I följande exempel visas DateTime.TryParseExact(String, String, IFormatProvider, DateTimeStyles, DateTime) 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";
      if (DateTime.TryParseExact(dateString, "g", enUS,
                                 DateTimeStyles.None, out dateValue))
         Console.WriteLine("Converted '{0}' to {1} ({2}).", dateString, dateValue,
                           dateValue.Kind);
      else
         Console.WriteLine("'{0}' is not in an acceptable format.", dateString);

      // Allow a leading space in the date string.
      if (DateTime.TryParseExact(dateString, "g", enUS,
                                 DateTimeStyles.AllowLeadingWhite, out dateValue))
         Console.WriteLine("Converted '{0}' to {1} ({2}).", dateString, dateValue,
                           dateValue.Kind);
      else
         Console.WriteLine("'{0}' is not in an acceptable format.", dateString);

      // Use custom formats with M and MM.
      dateString = "5/01/2009 09:00";
      if (DateTime.TryParseExact(dateString, "M/dd/yyyy hh:mm", enUS,
                                 DateTimeStyles.None, out dateValue))
         Console.WriteLine("Converted '{0}' to {1} ({2}).", dateString, dateValue,
                           dateValue.Kind);
      else
         Console.WriteLine("'{0}' is not in an acceptable format.", dateString);

      // Allow a leading space in the date string.
      if (DateTime.TryParseExact(dateString, "MM/dd/yyyy hh:mm", enUS,
                              DateTimeStyles.None, out dateValue))
         Console.WriteLine("Converted '{0}' to {1} ({2}).", dateString, dateValue,
                           dateValue.Kind);
      else
         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";
      if (DateTime.TryParseExact(dateString, "MM/dd/yyyy hh:mm:ss tt zzz", enUS,
                              DateTimeStyles.None, out dateValue))
         Console.WriteLine("Converted '{0}' to {1} ({2}).", dateString, dateValue,
                           dateValue.Kind);
      else
         Console.WriteLine("'{0}' is not in an acceptable format.", dateString);

      // Allow a leading space in the date string.
      if (DateTime.TryParseExact(dateString, "MM/dd/yyyy hh:mm:ss tt zzz", enUS,
                              DateTimeStyles.AdjustToUniversal, out dateValue))
         Console.WriteLine("Converted '{0}' to {1} ({2}).", dateString, dateValue,
                           dateValue.Kind);
      else
         Console.WriteLine("'{0}' is not in an acceptable format.", dateString);

      // Parse a string representing UTC.
      dateString = "2008-06-11T16:11:20.0904778Z";
      if (DateTime.TryParseExact(dateString, "o", CultureInfo.InvariantCulture,
                                     DateTimeStyles.None, out dateValue))
         Console.WriteLine("Converted '{0}' to {1} ({2}).", dateString, dateValue,
                           dateValue.Kind);
      else
         Console.WriteLine("'{0}' is not in an acceptable format.", dateString);

      if (DateTime.TryParseExact(dateString, "o", CultureInfo.InvariantCulture,
                                 DateTimeStyles.RoundtripKind, out dateValue))
         Console.WriteLine("Converted '{0}' to {1} ({2}).", dateString, dateValue,
                           dateValue.Kind);
      else
         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"
    match DateTime.TryParseExact(dateString, "g", enUS, DateTimeStyles.None) with
    | true, dateValue ->
        printfn $"Converted '{dateString}' to {dateValue} ({dateValue.Kind})."              
    | _ ->
        printfn $"'{dateString}' is not in an acceptable format."

    // Allow a leading space in the date string.
    match DateTime.TryParseExact(dateString, "g", enUS, DateTimeStyles.AllowLeadingWhite) with
    | true, dateValue ->
        printfn $"Converted '{dateString}' to {dateValue} ({dateValue.Kind})."
    | _ ->
        printfn $"'{dateString}' is not in an acceptable format."

    // Use custom formats with M and MM.
    let dateString = "5/01/2009 09:00"
    match DateTime.TryParseExact(dateString, "M/dd/yyyy hh:mm", enUS, DateTimeStyles.None) with
    | true, dateValue ->
        printfn $"Converted '{dateString}' to {dateValue} ({dateValue.Kind})."
    | _ ->
        printfn $"'{dateString}' is not in an acceptable format."

    // Allow a leading space in the date string.
    match DateTime.TryParseExact(dateString, "MM/dd/yyyy hh:mm", enUS, DateTimeStyles.None) with
    | true, dateValue ->
        printfn $"Converted '{dateString}' to {dateValue} ({dateValue.Kind})."
    | _ ->
        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"
    match DateTime.TryParseExact(dateString, "MM/dd/yyyy hh:mm:ss tt zzz", enUS, DateTimeStyles.None) with
    | true, dateValue ->
        printfn $"Converted '{dateString}' to {dateValue} ({dateValue.Kind})."
    | _ ->
        printfn $"'{dateString}' is not in an acceptable format."

    // Allow a leading space in the date string.
    match DateTime.TryParseExact(dateString, "MM/dd/yyyy hh:mm:ss tt zzz", enUS, DateTimeStyles.AdjustToUniversal) with
    | true, dateValue ->
        printfn $"Converted '{dateString}' to {dateValue} ({dateValue.Kind})."
    | _ ->
        printfn $"'{dateString}' is not in an acceptable format."

    // Parse a string representing UTC.
    let dateString = "2008-06-11T16:11:20.0904778Z"
    match DateTime.TryParseExact(dateString, "o", CultureInfo.InvariantCulture, DateTimeStyles.None) with
    | true, dateValue ->
        printfn $"Converted '{dateString}' to {dateValue} ({dateValue.Kind})."
    | _ ->
        printfn $"'{dateString}' is not in an acceptable format."

    match DateTime.TryParseExact(dateString, "o", CultureInfo.InvariantCulture, DateTimeStyles.RoundtripKind) with
    | true, dateValue ->
        printfn $"Converted '{dateString}' to {dateValue} ({dateValue.Kind})."
    | _ ->
        printfn $"'{dateString}' is not in an acceptable format."

    0

    // 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

Public 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"
      If Date.TryParseExact(dateString, "g", enUS, _
                            DateTimeStyles.None, dateValue) Then
         Console.WriteLine("Converted '{0}' to {1} ({2}).", dateString, dateValue, _
                           dateValue.Kind)
      Else
         Console.WriteLine("'{0}' is not in an acceptable format.", dateString)
      End If
      ' Allow a leading space in the date string.
      If Date.TryParseExact(dateString, "g", enUS, _
                            DateTimeStyles.AllowLeadingWhite, dateValue) Then
         Console.WriteLine("Converted '{0}' to {1} ({2}).", dateString, dateValue, _
                           dateValue.Kind)
      Else
         Console.WriteLine("'{0}' is not in an acceptable format.", dateString)
      End If
      
      ' Use custom formats with M and MM.
      dateString = "5/01/2009 09:00"
      If Date.TryParseExact(dateString, "M/dd/yyyy hh:mm", enUS, _
                            DateTimeStyles.None, dateValue) Then
         Console.WriteLine("Converted '{0}' to {1} ({2}).", dateString, dateValue, _
                           dateValue.Kind)
      Else
         Console.WriteLine("'{0}' is not in an acceptable format.", dateString)
      End If
      ' Allow a leading space in the date string.
      If Date.TryParseExact(dateString, "MM/dd/yyyy hh:mm", enUS, _
                            DateTimeStyles.None, dateValue) Then
         Console.WriteLine("Converted '{0}' to {1} ({2}).", dateString, dateValue, _
                           dateValue.Kind)
      Else
         Console.WriteLine("'{0}' is not in an acceptable format.", dateString)
      End If

      ' Parse a string with time zone information.
      dateString = "05/01/2009 01:30:42 PM -05:00" 
      If Date.TryParseExact(dateString, "MM/dd/yyyy hh:mm:ss tt zzz", enUS, _
                            DateTimeStyles.None, dateValue) Then
         Console.WriteLine("Converted '{0}' to {1} ({2}).", dateString, dateValue, _
                           dateValue.Kind)
      Else
         Console.WriteLine("'{0}' is not in an acceptable format.", dateString)
      End If
      ' Allow a leading space in the date string.
      If Date.TryParseExact(dateString, "MM/dd/yyyy hh:mm:ss tt zzz", enUS, _
                            DateTimeStyles.AdjustToUniversal, dateValue) Then
         Console.WriteLine("Converted '{0}' to {1} ({2}).", dateString, dateValue, _
                           dateValue.Kind)
      Else
         Console.WriteLine("'{0}' is not in an acceptable format.", dateString)
      End If
           
      ' Parse a string representing UTC.
      dateString = "2008-06-11T16:11:20.0904778Z"
      If Date.TryParseExact(dateString, "o", CultureInfo.InvariantCulture, _
                                     DateTimeStyles.None, dateValue) Then
         Console.WriteLine("Converted '{0}' to {1} ({2}).", dateString, dateValue, _
                           dateValue.Kind)
      Else
         Console.WriteLine("'{0}' is not in an acceptable format.", dateString)
      End If
      
      If Date.TryParseExact(dateString, "o", CultureInfo.InvariantCulture, _
                            DateTimeStyles.RoundtripKind, dateValue) Then
         Console.WriteLine("Converted '{0}' to {1} ({2}).", dateString, dateValue, _
                           dateValue.Kind)
      Else
         Console.WriteLine("'{0}' is not in an acceptable format.", dateString)
      End If
   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.TryParseExact(String, String, IFormatProvider, DateTimeStyles, DateTime) parsar strängrepresentationen av ett datum, som måste vara i det format som definieras av parametern format . Det liknar DateTime.ParseExact(String, String, IFormatProvider, DateTimeStyles) metoden, förutom att TryParseExact(String, String, IFormatProvider, DateTimeStyles, DateTime) metoden inte utlöser ett undantag om konverteringen misslyckas.

Parametern s innehåller datum och tid som ska parsas och måste vara i ett format som definieras av parametern format . Om elementen datum, tid och tidszon finns i småste de också visas i den ordning som anges av format. 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 som standard ett datum på DateTime.Now.Date, eller så har det ett datum DateTime.MinValue.Date för om styles innehåller DateTimeStyles.NoCurrentDateDefault flaggan. Parametern style avgör om parametern s kan innehålla inledande, inre eller avslutande blankstegstecken.

Om s innehåller ingen tidszonsinformation är DateTimeKind.Unspecifiedegenskapen för Kind det returnerade DateTime 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 ange Kind egenskapen till DateTimeKind.Utc.

Parametern format innehåller ett mönster som motsvarar det förväntade formatet för parametern s . Mönstret i parametern format 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 .

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

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.

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 TryParseExact(String, String, IFormatProvider, DateTimeStyles, DateTime) 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 skonverteras 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 DateTime värde med egenskapen Kind inställd på DateTimeKind.Local. Den här flaggan förhindrar främst konvertering av UTC-tider till lokala tider.

Anteckningar till anropare

I .NET Framework 4 returnerar metoden TryParseExactfalse 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

• ParseExact
• CultureInfo
• DateTimeFormatInfo
• Parsing date and time strings in the .NET Framework
• Standardformatsträngar för datum och tid
• Anpassade formatsträngar för datum och tid

public:
 static bool TryParseExact(System::String ^ s, cli::array <System::String ^> ^ formats, IFormatProvider ^ provider, System::Globalization::DateTimeStyles style, [Runtime::InteropServices::Out] DateTime % result);

public static bool TryParseExact(string s, string[] formats, IFormatProvider provider, System.Globalization.DateTimeStyles style, out DateTime result);

static member TryParseExact : string * string[] * IFormatProvider * System.Globalization.DateTimeStyles * DateTime -> bool

Public Shared Function TryParseExact (s As String, formats As String(), provider As IFormatProvider, style As DateTimeStyles, ByRef result As DateTime) As Boolean

Parametrar

Returer

trueom parametern s har konverterats, annars . false

Undantag

Exempel

I följande exempel används DateTime.TryParseExact(String, String, IFormatProvider, DateTimeStyles, DateTime) 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"};
      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"};
      DateTime dateValue;

      foreach (string dateString in dateStrings)
      {
         if (DateTime.TryParseExact(dateString, formats,
                                    new CultureInfo("en-US"),
                                    DateTimeStyles.None,
                                    out dateValue))
            Console.WriteLine("Converted '{0}' to {1}.", dateString, dateValue);
         else
            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.

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" |]

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" ]

for dateString in dateStrings do
    match DateTime.TryParseExact(dateString, formats, CultureInfo "en-US", DateTimeStyles.None) with
    | true, dateValue ->
        printfn $"Converted '{dateString}' to {dateValue}."
    | _ ->
        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.

Imports System.Globalization

Public 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"}
      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"} 

      Dim dateValue As DateTime
      
      For Each dateString As String In dateStrings
         If Date.TryParseExact(dateString, formats, _
                               New CultureInfo("en-US"), _
                               DateTimeStyles.None, _
                               dateValue) Then
            Console.WriteLine("Converted '{0}' to {1}.", dateString, dateValue)
         Else
            Console.WriteLine("Unable to convert '{0}' to a date.", dateString)
         End If                                               
      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.

Kommentarer

Metoden DateTime.TryParseExact(String, String[], IFormatProvider, DateTimeStyles, DateTime) parsar strängrepresentationen av ett datum som matchar något av de mönster som tilldelats parametern formats . Det är som DateTime.ParseExact(String, String[], IFormatProvider, DateTimeStyles) metoden, förutom att TryParseExact metoden inte utlöser ett undantag om konverteringen misslyckas.

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.

Om s innehåller ingen tidszonsinformation är DateTimeKind.Unspecifiedegenskapen för Kind det returnerade DateTime 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 ange Kind egenskapen till DateTimeKind.Utc.

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 .

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

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.

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 TryParseExact(String, String[], IFormatProvider, DateTimeStyles, DateTime) 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 skonverteras 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 DateTime värde med egenskapen Kind inställd på DateTimeKind.Local. Den här flaggan förhindrar främst konvertering av UTC-tider till lokala tider.

Anteckningar till anropare

I .NET Framework 4 returnerar metoden TryParseExactfalse 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

• ParseExact
• CultureInfo
• DateTimeFormatInfo
• Parsing date and time strings in the .NET Framework
• Standardformatsträngar för datum och tid
• Anpassade formatsträngar för datum och tid