DateTime.TryParse Metod

Definition

Namnområde:: System

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

Sammansättning:: System.Runtime.dll

Sammansättning:: netstandard.dll

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

Sammansättning:: mscorlib.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 dess DateTime motsvarighet och returnerar ett värde som anger om konverteringen lyckades.

Överlagringar

Name	Description
TryParse(ReadOnlySpan<Char>, DateTime)	Konverterar det angivna teckenintervallet för ett datum och en tid till dess DateTime motsvarighet och returnerar ett värde som anger om konverteringen lyckades.
TryParse(String, DateTime)	Konverterar den angivna strängrepresentationen av ett datum och en tid till dess DateTime motsvarighet och returnerar ett värde som anger om konverteringen lyckades.
TryParse(ReadOnlySpan<Char>, IFormatProvider, DateTime)	Försöker parsa ett teckenintervall till ett värde.
TryParse(String, IFormatProvider, DateTime)	Försöker parsa en sträng till ett värde.
TryParse(String, IFormatProvider, DateTimeStyles, DateTime)	Konverterar den angivna strängrepresentationen av ett datum och en tid till dess DateTime motsvarighet med den angivna kulturspecifika formatinformationen och formateringsformatet och returnerar ett värde som anger om konverteringen lyckades.
TryParse(ReadOnlySpan<Char>, IFormatProvider, DateTimeStyles, DateTime)	Konverterar spanrepresentationen av ett datum och en tid till motsvarande DateTime med den angivna kulturspecifika formatinformationen och formateringsformatet och returnerar ett värde som anger om konverteringen lyckades.

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.

TryParse(ReadOnlySpan<Char>, DateTime)

Källa:: DateTime.cs

Källa:: DateTime.cs

Källa:: DateTime.cs

Källa:: DateTime.cs

Källa:: DateTime.cs

Konverterar det angivna teckenintervallet för ett datum och en tid till dess DateTime motsvarighet och returnerar ett värde som anger om konverteringen lyckades.

public:
 static bool TryParse(ReadOnlySpan<char> s, [Runtime::InteropServices::Out] DateTime % result);

public static bool TryParse(ReadOnlySpan<char> s, out DateTime result);

static member TryParse : ReadOnlySpan<char> * DateTime -> bool

Public Shared Function TryParse (s As ReadOnlySpan(Of Char), ByRef result As DateTime) As Boolean

Parametrar

s: ReadOnlySpan<Char>

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

result: DateTime

När den här metoden returneras innehåller värdet DateTime som motsvarar datum och tid i s, om konverteringen lyckades eller DateTime.MinValue om konverteringen misslyckades. Konverteringen misslyckas om parametern s är null, är en tom sträng (") eller inte innehåller en giltig strängrepresentation av ett datum och en tid. Den här parametern skickas oinitierad.

Returer

Boolean

trueom parametern s har konverterats, annars . false

Gäller för

TryParse(String, DateTime)

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 och returnerar ett värde som anger om konverteringen lyckades.

public:
 static bool TryParse(System::String ^ s, [Runtime::InteropServices::Out] DateTime % result);

public static bool TryParse(string s, out DateTime result);

public static bool TryParse(string? s, out DateTime result);

static member TryParse : string * DateTime -> bool

Public Shared Function TryParse (s As String, ByRef result As DateTime) As Boolean

Parametrar

s: String

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

result: DateTime

Returer

Boolean

trueom parametern s har konverterats, annars . false

Exempel

I följande exempel skickas ett antal datum- och tidssträngar till DateTime.TryParse(String, DateTime) metoden.

using System;
using System.Globalization;

public class Example
{
   public static void Main()
   {
      string[] dateStrings = {"05/01/2009 14:57:32.8", "2009-05-01 14:57:32.8",
                              "2009-05-01T14:57:32.8375298-04:00", "5/01/2008",
                              "5/01/2008 14:57:32.80 -07:00",
                              "1 May 2008 2:57:32.8 PM", "16-05-2009 1:00:32 PM",
                              "Fri, 15 May 2009 20:10:57 GMT" };
      DateTime dateValue;

      Console.WriteLine("Attempting to parse strings using {0} culture.",
                        CultureInfo.CurrentCulture.Name);
      foreach (string dateString in dateStrings)
      {
         if (DateTime.TryParse(dateString, out dateValue))
            Console.WriteLine("  Converted '{0}' to {1} ({2}).", dateString,
                              dateValue, dateValue.Kind);
         else
            Console.WriteLine("  Unable to parse '{0}'.", dateString);
      }
   }
}
// The example displays output like the following:
//    Attempting to parse strings using en-US culture.
//      Converted '05/01/2009 14:57:32.8' to 5/1/2009 2:57:32 PM (Unspecified).
//      Converted '2009-05-01 14:57:32.8' to 5/1/2009 2:57:32 PM (Unspecified).
//      Converted '2009-05-01T14:57:32.8375298-04:00' to 5/1/2009 11:57:32 AM (Local).
//
//      Converted '5/01/2008' to 5/1/2008 12:00:00 AM (Unspecified).
//      Converted '5/01/2008 14:57:32.80 -07:00' to 5/1/2008 2:57:32 PM (Local).
//      Converted '1 May 2008 2:57:32.8 PM' to 5/1/2008 2:57:32 PM (Unspecified).
//      Unable to parse '16-05-2009 1:00:32 PM'.
//      Converted 'Fri, 15 May 2009 20:10:57 GMT' to 5/15/2009 1:10:57 PM (Local).

open System
open System.Globalization

let dateStrings = 
    [ "05/01/2009 14:57:32.8"; "2009-05-01 14:57:32.8"
      "2009-05-01T14:57:32.8375298-04:00"; "5/01/2008"
      "5/01/2008 14:57:32.80 -07:00"
      "1 May 2008 2:57:32.8 PM"; "16-05-2009 1:00:32 PM"
      "Fri, 15 May 2009 20:10:57 GMT" ]

printfn $"Attempting to parse strings using {CultureInfo.CurrentCulture.Name} culture."
for dateString in dateStrings do
    match DateTime.TryParse dateString with
    | true, dateValue ->
        printfn $"  Converted '{dateString}' to {dateValue} ({dateValue.Kind})."
    | _ ->
        printfn $"  Unable to parse '{dateString}'."


// The example displays output like the following:
//    Attempting to parse strings using en-US culture.
//      Converted '05/01/2009 14:57:32.8' to 5/1/2009 2:57:32 PM (Unspecified).
//      Converted '2009-05-01 14:57:32.8' to 5/1/2009 2:57:32 PM (Unspecified).
//      Converted '2009-05-01T14:57:32.8375298-04:00' to 5/1/2009 11:57:32 AM (Local).
//      Converted '5/01/2008' to 5/1/2008 12:00:00 AM (Unspecified).
//      Converted '5/01/2008 14:57:32.80 -07:00' to 5/1/2008 2:57:32 PM (Local).
//      Converted '1 May 2008 2:57:32.8 PM' to 5/1/2008 2:57:32 PM (Unspecified).
//      Unable to parse '16-05-2009 1:00:32 PM'.
//      Converted 'Fri, 15 May 2009 20:10:57 GMT' to 5/15/2009 1:10:57 PM (Local).

Imports System.Globalization

Public Module Example
   Public Sub Main()
      Dim dateStrings() As String = {"05/01/2009 14:57:32.8", "2009-05-01 14:57:32.8",
                                     "2009-05-01T14:57:32.8375298-04:00", "5/01/2008",
                                     "5/01/2008 14:57:32.80 -07:00",
                                     "1 May 2008 2:57:32.8 PM", "16-05-2009 1:00:32 PM",
                                     "Fri, 15 May 2009 20:10:57 GMT"}
      Dim dateValue As Date
      
      Console.WriteLine("Attempting to parse strings using {0} culture.", _
                        CultureInfo.CurrentCulture.Name)
      For Each dateString As String In dateStrings
         If Date.TryParse(dateString, dateValue) Then
            Console.WriteLine("  Converted '{0}' to {1} ({2}).", dateString, _
                              dateValue, dateValue.Kind)
         Else
            Console.WriteLine("  Unable to parse '{0}'.", dateString)
         End If
      Next
   End Sub
End Module
' The example displays output like the following:
'    Attempting to parse strings using en-US culture.
'      Converted '05/01/2009 14:57:32.8' to 5/1/2009 2:57:32 PM (Unspecified).
'      Converted '2009-05-01 14:57:32.8' to 5/1/2009 2:57:32 PM (Unspecified).
'      Converted '2009-05-01T14:57:32.8375298-04:00' to 5/1/2009 11:57:32 AM (Local).
'
'      Converted '5/01/2008' to 5/1/2008 12:00:00 AM (Unspecified).
'      Converted '5/01/2008 14:57:32.80 -07:00' to 5/1/2008 2:57:32 PM (Local).
'      Converted '1 May 2008 2:57:32.8 PM' to 5/1/2008 2:57:32 PM (Unspecified).
'      Unable to parse '16-05-2009 1:00:32 PM'.
'      Converted 'Fri, 15 May 2009 20:10:57 GMT' to 5/15/2009 1:10:57 PM (Local).

Kommentarer

Metoden DateTime.TryParse(String, DateTime) liknar DateTime.Parse(String) metoden, förutom att TryParse(String, DateTime) metoden inte utlöser ett undantag om konverteringen misslyckas.

Strängen s parsas med formateringsinformation i det aktuella DateTimeFormatInfo objektet, som tillhandahålls implicit av den aktuella kulturen.

Den här metoden försöker ignorera okända data, om möjligt, och fyller i information om saknade månader, dagar och år med aktuellt datum. Om s endast innehåller ett datum och ingen tid förutsätter den här metoden att tiden är 12:00 midnatt. Om s innehåller en datumkomponent med ett tvåsiffrigt år konverteras den till ett år i den aktuella kulturens aktuella kalender baserat på värdet för Calendar.TwoDigitYearMax egenskapen. Alla inledande, inre eller avslutande blankstegstecken i s ignoreras. Datum och tid kan omslutas av ett par inledande och avslutande NUMBER SIGN-tecken ('#', U+0023) och kan följas av ett eller flera NULL-tecken (U+0000).

DateTime.TryParse(String, DateTime) Eftersom metoden försöker parsa strängrepresentationen av ett datum och en tid med hjälp av formateringsreglerna för den aktuella kulturen kan försök att parsa en viss sträng mellan olika kulturer antingen misslyckas eller returnera olika resultat. Om ett specifikt datum- och tidsformat parsas mellan olika nationella inställningar använder du DateTime.TryParse(String, IFormatProvider, DateTimeStyles, DateTime) metoden eller en av överlagringarna av TryParseExact metoden och anger en formatspecificerare.

Om s är strängrepresentationen av en skottdag under ett skottår i den aktuella kalendern, parserar metoden s framgångsrikt. Om s är strängrepresentationen av en skottdag under ett icke-skottår i den aktuella kulturens aktuella kalender misslyckas parsningsåtgärden och metoden returnerar false.

Om s innehåller ingen tidszonsinformation result , innehåller ett DateTime värde vars Kind egenskap är DateTimeKind.Unspecified när metoden returneras. Om strängen som ska parsas innehåller tidszonsinformation result , innehåller ett DateTime värde vars Kind egenskap är DateTimeKind.Local när metoden returneras.

Anteckningar till anropare

Formateringen påverkas av egenskaperna för det aktuella objektet DateTimeFormatInfo, som som standard härleds från objektet Regional och Language Options i ovládací panel. Metoden TryParse kan oväntat misslyckas och returneras False om aktuella DateSeparator egenskaper och TimeSeparator egenskaper är inställda på samma värde.

Se även

Gäller för

TryParse(ReadOnlySpan<Char>, IFormatProvider, DateTime)

Källa:: DateTime.cs

Källa:: DateTime.cs

Källa:: DateTime.cs

Källa:: DateTime.cs

Källa:: DateTime.cs

Försöker parsa ett teckenintervall till ett värde.

public:
 static bool TryParse(ReadOnlySpan<char> s, IFormatProvider ^ provider, [Runtime::InteropServices::Out] DateTime % result) = ISpanParsable<DateTime>::TryParse;

public static bool TryParse(ReadOnlySpan<char> s, IFormatProvider? provider, out DateTime result);

static member TryParse : ReadOnlySpan<char> * IFormatProvider * DateTime -> bool

Public Shared Function TryParse (s As ReadOnlySpan(Of Char), provider As IFormatProvider, ByRef result As DateTime) As Boolean

Parametrar

s: ReadOnlySpan<Char>

Det intervall med tecken som ska parsas.

provider: IFormatProvider

Ett objekt som tillhandahåller kulturspecifik formateringsinformation om s.

result: DateTime

När den här metoden returneras innehåller resultatet av parsning seller ett odefinierat värde vid fel.

Returer

Boolean

trueom s har parsats, annars . false

Gäller för

TryParse(String, IFormatProvider, DateTime)

Källa:: DateTime.cs

Källa:: DateTime.cs

Källa:: DateTime.cs

Källa:: DateTime.cs

Källa:: DateTime.cs

Försöker parsa en sträng till ett värde.

public:
 static bool TryParse(System::String ^ s, IFormatProvider ^ provider, [Runtime::InteropServices::Out] DateTime % result) = IParsable<DateTime>::TryParse;

public static bool TryParse(string? s, IFormatProvider? provider, out DateTime result);

static member TryParse : string * IFormatProvider * DateTime -> bool

Public Shared Function TryParse (s As String, provider As IFormatProvider, ByRef result As DateTime) As Boolean

Parametrar

s: String

Strängen som ska parsas.

provider: IFormatProvider

Ett objekt som tillhandahåller kulturspecifik formateringsinformation om s.

result: DateTime

När den här metoden returneras innehåller resultatet av parsning s eller ett odefinierat värde vid fel.

Returer

Boolean

trueom s har parsats, annars . false

Gäller för

TryParse(String, IFormatProvider, DateTimeStyles, DateTime)

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 den angivna kulturspecifika formatinformationen och formateringsformatet och returnerar ett värde som anger om konverteringen lyckades.

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

public static bool TryParse(string s, IFormatProvider provider, System.Globalization.DateTimeStyles styles, out DateTime result);

public static bool TryParse(string? s, IFormatProvider? provider, System.Globalization.DateTimeStyles styles, out DateTime result);

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

Public Shared Function TryParse (s As String, provider As IFormatProvider, styles As DateTimeStyles, ByRef result As DateTime) As Boolean

Parametrar

s: String

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

provider: IFormatProvider

Ett objekt som tillhandahåller kulturspecifik formateringsinformation om s.

styles: DateTimeStyles

En bitvis kombination av uppräkningsvärden som definierar hur du tolkar det tolkade datumet i förhållande till den aktuella tidszonen eller det aktuella datumet. Ett typiskt värde att ange är None.

result: DateTime

Returer

Boolean

trueom parametern s har konverterats, annars . false

Undantag

ArgumentException

styles är inte ett giltigt DateTimeStyles värde.

-eller-

styles innehåller en ogiltig kombination av DateTimeStyles värden (till exempel både AssumeLocal och AssumeUniversal).

NotSupportedException

provider är en neutral kultur och kan inte användas i en parsningsåtgärd.

Exempel

I följande exempel visas DateTime.TryParse(String, IFormatProvider, DateTimeStyles, DateTime) metoden.

using System;
using System.Globalization;

public class Example
{
   public static void Main()
   {
      string dateString;
      CultureInfo culture;
      DateTimeStyles styles;
      DateTime dateResult;

      // Parse a date and time with no styles.
      dateString = "03/01/2009 10:00 AM";
      culture = CultureInfo.CreateSpecificCulture("en-US");
      styles = DateTimeStyles.None;
      if (DateTime.TryParse(dateString, culture, styles, out dateResult))
         Console.WriteLine("{0} converted to {1} {2}.",
                           dateString, dateResult, dateResult.Kind);
      else
         Console.WriteLine("Unable to convert {0} to a date and time.",
                           dateString);

      // Parse the same date and time with the AssumeLocal style.
      styles = DateTimeStyles.AssumeLocal;
      if (DateTime.TryParse(dateString, culture, styles, out dateResult))
         Console.WriteLine("{0} converted to {1} {2}.",
                           dateString, dateResult, dateResult.Kind);
      else
         Console.WriteLine("Unable to convert {0} to a date and time.", dateString);

      // Parse a date and time that is assumed to be local.
      // This time is five hours behind UTC. The local system's time zone is
      // eight hours behind UTC.
      dateString = "2009/03/01T10:00:00-5:00";
      styles = DateTimeStyles.AssumeLocal;
      if (DateTime.TryParse(dateString, culture, styles, out dateResult))
         Console.WriteLine("{0} converted to {1} {2}.",
                           dateString, dateResult, dateResult.Kind);
      else
         Console.WriteLine("Unable to convert {0} to a date and time.", dateString);

      // Attempt to convert a string in improper ISO 8601 format.
      dateString = "03/01/2009T10:00:00-5:00";
      if (DateTime.TryParse(dateString, culture, styles, out dateResult))
         Console.WriteLine("{0} converted to {1} {2}.",
                           dateString, dateResult, dateResult.Kind);
      else
         Console.WriteLine("Unable to convert {0} to a date and time.", dateString);

      // Assume a date and time string formatted for the fr-FR culture is the local
      // time and convert it to UTC.
      dateString = "2008-03-01 10:00";
      culture = CultureInfo.CreateSpecificCulture("fr-FR");
      styles = DateTimeStyles.AdjustToUniversal | DateTimeStyles.AssumeLocal;
      if (DateTime.TryParse(dateString, culture, styles, out dateResult))
         Console.WriteLine("{0} converted to {1} {2}.",
                           dateString, dateResult, dateResult.Kind);
      else
         Console.WriteLine("Unable to convert {0} to a date and time.", dateString);
   }
}
// The example displays the following output to the console:
//       03/01/2009 10:00 AM converted to 3/1/2009 10:00:00 AM Unspecified.
//       03/01/2009 10:00 AM converted to 3/1/2009 10:00:00 AM Local.
//       2009/03/01T10:00:00-5:00 converted to 3/1/2009 7:00:00 AM Local.
//       Unable to convert 03/01/2009T10:00:00-5:00 to a date and time.
//       2008-03-01 10:00 converted to 3/1/2008 6:00:00 PM Utc.

open System
open System.Globalization

[<EntryPoint>]
let main _ =
    // Parse a date and time with no styles.
    let dateString = "03/01/2009 10:00 AM"
    let culture = CultureInfo.CreateSpecificCulture "en-US"
    let styles = DateTimeStyles.None
    match DateTime.TryParse(dateString, culture, styles) with
    | true, dateResult ->
        printfn $"{dateString} converted to {dateResult} {dateResult.Kind}."
    | _ -> 
        printfn $"Unable to convert {dateString} to a date and time."

    // Parse the same date and time with the AssumeLocal style.
    let styles = DateTimeStyles.AssumeLocal
    match DateTime.TryParse(dateString, culture, styles) with
    | true, dateResult ->
        printfn $"{dateString} converted to {dateResult} {dateResult.Kind}." 
    | _ ->
        printfn $"Unable to convert {dateString} to a date and time."

    // Parse a date and time that is assumed to be local.
    // This time is five hours behind UTC. The local system's time zone is
    // eight hours behind UTC.
    let dateString = "2009/03/01T10:00:00-5:00"
    let styles = DateTimeStyles.AssumeLocal
    match DateTime.TryParse(dateString, culture, styles) with
    | true, dateResult ->
        printfn $"{dateString} converted to {dateResult} {dateResult.Kind}."
    | _ ->
        printfn $"Unable to convert {dateString} to a date and time."

    // Attempt to convert a string in improper ISO 8601 format.
    let dateString = "03/01/2009T10:00:00-5:00"
    match DateTime.TryParse(dateString, culture, styles) with
    | true, dateResult ->
        printfn $"{dateString} converted to {dateResult} {dateResult.Kind}."
    | _ ->
        printfn $"Unable to convert {dateString} to a date and time."

    // Assume a date and time string formatted for the fr-FR culture is the local
    // time and convert it to UTC.
    let dateString = "2008-03-01 10:00"
    let culture = CultureInfo.CreateSpecificCulture "fr-FR"
    let styles = DateTimeStyles.AdjustToUniversal ||| DateTimeStyles.AssumeLocal
    match DateTime.TryParse(dateString, culture, styles) with
    | true, dateResult ->
        printfn $"{dateString} converted to {dateResult} {dateResult.Kind}." 
    | _ ->
        printfn $"Unable to convert {dateString} to a date and time."

    0

// The example displays the following output to the console:
//       03/01/2009 10:00 AM converted to 3/1/2009 10:00:00 AM Unspecified.
//       03/01/2009 10:00 AM converted to 3/1/2009 10:00:00 AM Local.
//       2009/03/01T10:00:00-5:00 converted to 3/1/2009 7:00:00 AM Local.
//       Unable to convert 03/01/2009T10:00:00-5:00 to a date and time.
//       2008-03-01 10:00 converted to 3/1/2008 6:00:00 PM Utc.

Imports System.Globalization

Public Module Example
   Public Sub Main()
      Dim dateString As String
      Dim culture As CultureInfo
      Dim styles As DateTimeStyles 
      Dim dateResult As DateTime
      
      ' Parse a date and time with no styles.
      dateString = "03/01/2009 10:00 AM"
      culture = CultureInfo.CreateSpecificCulture("en-US")
      styles = DateTimeStyles.None
      If DateTime.TryParse(dateString, culture, styles, dateResult) Then
         Console.WriteLine("{0} converted to {1} {2}.", _
                           dateString, dateResult, dateResult.Kind)
      Else
         Console.WriteLine("Unable to convert {0} to a date and time.", dateString)
      End If      
      
      ' Parse the same date and time with the AssumeLocal style.
      styles = DateTimeStyles.AssumeLocal
      If DateTime.TryParse(dateString, culture, styles, dateResult)
         Console.WriteLine("{0} converted to {1} {2}.", _
                           dateString, dateResult, dateResult.Kind)
      Else
         Console.WriteLine("Unable to convert {0} to a date and time.", dateString)
      End If      
      
      ' Parse a date and time that is assumed to be local.
      ' This time is five hours behind UTC. The local system's time zone is 
      ' eight hours behind UTC.
      dateString = "2009/03/01T10:00:00-5:00"
      styles = DateTimeStyles.AssumeLocal
      If DateTime.TryParse(dateString, culture, styles, dateResult)
         Console.WriteLine("{0} converted to {1} {2}.", _
                           dateString, dateResult, dateResult.Kind)
      Else
         Console.WriteLine("Unable to convert {0} to a date and time.", dateString)
      End If      
      
      ' Attempt to convert a string in improper ISO 8601 format.
      dateString = "03/01/2009T10:00:00-5:00"
      If DateTime.TryParse(dateString, culture, styles, dateResult)
         Console.WriteLine("{0} converted to {1} {2}.", _
                           dateString, dateResult, dateResult.Kind)
      Else
         Console.WriteLine("Unable to convert {0} to a date and time.", dateString)
      End If      

      ' Assume a date and time string formatted for the fr-FR culture is the local 
      ' time and convert it to UTC.
      dateString = "2008-03-01 10:00"
      culture = CultureInfo.CreateSpecificCulture("fr-FR")
      styles = DateTimeStyles.AdjustToUniversal Or DateTimeStyles.AssumeLocal
      If DateTime.TryParse(dateString, culture, styles, dateResult)
         Console.WriteLine("{0} converted to {1} {2}.", _
                           dateString, dateResult, dateResult.Kind)
      Else
         Console.WriteLine("Unable to convert {0} to a date and time.", dateString)
      End If      
   End Sub
End Module
' The example displays the following output to the console:
'       03/01/2009 10:00 AM converted to 3/1/2009 10:00:00 AM Unspecified.
'       03/01/2009 10:00 AM converted to 3/1/2009 10:00:00 AM Local.
'       2009/03/01T10:00:00-5:00 converted to 3/1/2009 7:00:00 AM Local.
'       Unable to convert 03/01/2009T10:00:00-5:00 to a date and time.
'       2008-03-01 10:00 converted to 3/1/2008 6:00:00 PM Utc.

Kommentarer

Mer information om det här API:et finns i Kompletterande API-kommentarer för DateTime.TryParse.

Anteckningar till anropare

Formateringen påverkas av egenskaperna för det aktuella DateTimeFormatInfo objektet, som tillhandahålls av parametern provider . Metoden TryParse kan oväntat misslyckas och returneras False om aktuella DateSeparator egenskaper och TimeSeparator egenskaper är inställda på samma värde.

Se även

Gäller för

TryParse(ReadOnlySpan<Char>, IFormatProvider, DateTimeStyles, DateTime)

Källa:: DateTime.cs

Källa:: DateTime.cs

Källa:: DateTime.cs

Källa:: DateTime.cs

Källa:: DateTime.cs

Konverterar spanrepresentationen av ett datum och en tid till motsvarande DateTime med den angivna kulturspecifika formatinformationen och formateringsformatet och returnerar ett värde som anger om konverteringen lyckades.

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

public static bool TryParse(ReadOnlySpan<char> s, IFormatProvider? provider, System.Globalization.DateTimeStyles styles, out DateTime result);

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

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

Public Shared Function TryParse (s As ReadOnlySpan(Of Char), provider As IFormatProvider, styles As DateTimeStyles, ByRef result As DateTime) As Boolean

Parametrar

s: ReadOnlySpan<Char>

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

provider: IFormatProvider

Ett objekt som tillhandahåller kulturspecifik formateringsinformation om s.

styles: DateTimeStyles

result: DateTime

Returer

Boolean

trueom parametern s har konverterats, annars . false

Gäller för

Feedback

Var den här sidan till hjälp?