DateTime.TryParse Methode

Definitie

Naamruimte:: System

Assembly's:: netstandard.dll, System.Runtime.dll

Assembly:: System.Runtime.dll

Assembly:: netstandard.dll

Assembly's:: mscorlib.dll, System.Runtime.dll

Assembly:: mscorlib.dll

Belangrijk

Bepaalde informatie heeft betrekking op een voorlopige productversie die aanzienlijk kan worden gewijzigd voordat deze wordt uitgebracht. Microsoft biedt geen enkele expliciete of impliciete garanties met betrekking tot de informatie die hier wordt verstrekt.

Converteert de opgegeven tekenreeksweergave van een datum en tijd naar het DateTime equivalent ervan en retourneert een waarde die aangeeft of de conversie is geslaagd.

Overloads

Name	Description
TryParse(ReadOnlySpan<Char>, DateTime)	Converteert het opgegeven tekenbereik van een datum en tijd naar het DateTime equivalent ervan en retourneert een waarde die aangeeft of de conversie is geslaagd.
TryParse(String, DateTime)	Converteert de opgegeven tekenreeksweergave van een datum en tijd naar het DateTime equivalent ervan en retourneert een waarde die aangeeft of de conversie is geslaagd.
TryParse(ReadOnlySpan<Char>, IFormatProvider, DateTime)	Probeert een reeks tekens te parseren in een waarde.
TryParse(String, IFormatProvider, DateTime)	Probeert een tekenreeks te parseren in een waarde.
TryParse(String, IFormatProvider, DateTimeStyles, DateTime)	Converteert de opgegeven tekenreeksweergave van een datum en tijd naar DateTime het equivalent ervan met behulp van de opgegeven cultuurspecifieke notatiegegevens en opmaakstijl en retourneert een waarde die aangeeft of de conversie is geslaagd.
TryParse(ReadOnlySpan<Char>, IFormatProvider, DateTimeStyles, DateTime)	Converteert de spanweergave van een datum en tijd naar DateTime het equivalent ervan met behulp van de opgegeven cultuurspecifieke notatiegegevens en opmaakstijl en retourneert een waarde die aangeeft of de conversie is geslaagd.

Opmerkingen

Important

Tijdperken in de Japanse kalenders zijn gebaseerd op het keizerrijk en zullen daarom naar verwachting veranderen. Bijvoorbeeld: 1 mei 2019 markeerde het begin van het Reiwa-tijdperk in de JapaneseCalendar en JapaneseLunisolarCalendar. Een dergelijke wijziging van het tijdperk is van invloed op alle toepassingen die gebruikmaken van deze agenda's. Zie Verwerken van een nieuw tijdperk in de Japanse kalender in .NET voor meer informatie en om te bepalen of uw toepassingen worden beïnvloed. Zie Uw toepassing voorbereiden voor de wijziging in het Japanse tijdperk voor informatie over het testen van uw toepassingen op Windows-systemen om ervoor te zorgen dat deze gereed zijn voor de wijziging van het tijdperk. Zie Werken met tijdperken voor functies in .NET die agenda's met meerdere tijdperken ondersteunen en voor aanbevolen procedures bij het werken met agenda's die meerdere tijdperken ondersteunen.

TryParse(ReadOnlySpan<Char>, DateTime)

Bron:: DateTime.cs

Bron:: DateTime.cs

Bron:: DateTime.cs

Bron:: DateTime.cs

Bron:: DateTime.cs

Converteert het opgegeven tekenbereik van een datum en tijd naar het DateTime equivalent ervan en retourneert een waarde die aangeeft of de conversie is geslaagd.

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

Parameters

s: ReadOnlySpan<Char>

Een tekenreeks met een datum en tijd die moet worden geconverteerd.

result: DateTime

Wanneer deze methode retourneert, bevat deze de DateTime waarde die gelijk is aan de datum en tijd in s, als de conversie is geslaagd of DateTime.MinValue als de conversie is mislukt. De conversie mislukt als de s parameter een lege tekenreeks ("") is nullof geen geldige tekenreeksweergave van een datum en tijd bevat. Deze parameter wordt niet-geïnitialiseerd doorgegeven.

Retouren

Boolean

trueals de s parameter is geconverteerd; anders. false

Van toepassing op

TryParse(String, DateTime)

Bron:: DateTime.cs

Bron:: DateTime.cs

Bron:: DateTime.cs

Bron:: DateTime.cs

Bron:: DateTime.cs

Converteert de opgegeven tekenreeksweergave van een datum en tijd naar het DateTime equivalent ervan en retourneert een waarde die aangeeft of de conversie is geslaagd.

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

Parameters

s: String

Een tekenreeks met een datum en tijd die moet worden geconverteerd.

result: DateTime

Retouren

Boolean

trueals de s parameter is geconverteerd; anders. false

Voorbeelden

In het volgende voorbeeld wordt een aantal datum- en tijdtekenreeksen doorgegeven aan de DateTime.TryParse(String, DateTime) methode.

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

Opmerkingen

De DateTime.TryParse(String, DateTime) methode is vergelijkbaar met de DateTime.Parse(String) methode, behalve dat de TryParse(String, DateTime) methode geen uitzondering genereert als de conversie mislukt.

De tekenreeks s wordt geparseerd met behulp van opmaakgegevens in het huidige DateTimeFormatInfo object, dat impliciet wordt geleverd door de huidige cultuur.

Met deze methode wordt geprobeerd niet-herkende gegevens te negeren, indien mogelijk, en worden ontbrekende maand-, dag- en jaargegevens ingevuld met de huidige datum. Als s deze methode alleen een datum en geen tijd bevat, wordt ervan uitgegaan dat de tijd 12:00 middernacht is. Als s een datumonderdeel met een jaar van twee cijfers is opgenomen, wordt het geconverteerd naar een jaar in de huidige kalender van de huidige cultuur op basis van de waarde van de Calendar.TwoDigitYearMax eigenschap. Voorlooptekens, binnenste of volgspaties s worden genegeerd. De datum en tijd kunnen worden geplaatst tussen een paar voorloop- en afsluitende NUMMERTEKEN-tekens ('#', U+0023) en kunnen worden gevolgd door een of meer NULL-tekens (U+0000).

Omdat de methode probeert DateTime.TryParse(String, DateTime) de tekenreeksweergave van een datum en tijd te parseren met behulp van de opmaakregels van de huidige cultuur, kan het parseren van een bepaalde tekenreeks in verschillende culturen mislukken of verschillende resultaten retourneren. Als een specifieke datum- en tijdnotatie wordt geparseerd op verschillende landinstellingen, gebruikt u de DateTime.TryParse(String, IFormatProvider, DateTimeStyles, DateTime) methode of een van de overbelastingen van de TryParseExact methode en geeft u een notatieaanduiding op.

Als s de tekenreeksweergave is van een schrikkeldag in een schrikkeljaar in de huidige kalender, parseert de methode s succesvol. Als s dit de tekenreeksweergave is van een schrikkeldag in een niet-schrikkeljaar in de huidige kalender van de huidige cultuur, mislukt de parseringsbewerking en retourneert falsede methode.

Als s er geen tijdzone-informatie is, result bevat u een DateTime waarde waarvan Kind de eigenschap is DateTimeKind.Unspecified wanneer de methode retourneert. Als de tekenreeks die moet worden geparseerd tijdzone-informatie bevat, result bevat deze een DateTime waarde waarvan Kind de eigenschap is DateTimeKind.Local wanneer de methode wordt geretourneerd.

Notities voor bellers

Opmaak wordt beïnvloed door eigenschappen van het huidige DateTimeFormatInfo-object, die standaard zijn afgeleid van het item Regional en Language Options in Configuratiescherm. De TryParse methode kan onverwacht mislukken en retourneren False als de huidige DateSeparator en TimeSeparator eigenschappen zijn ingesteld op dezelfde waarde.

Zie ook

Van toepassing op

TryParse(ReadOnlySpan<Char>, IFormatProvider, DateTime)

Bron:: DateTime.cs

Bron:: DateTime.cs

Bron:: DateTime.cs

Bron:: DateTime.cs

Bron:: DateTime.cs

Probeert een reeks tekens te parseren in een waarde.

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

Parameters

s: ReadOnlySpan<Char>

De reeks tekens die moeten worden geparseerd.

provider: IFormatProvider

Een object dat cultuurspecifieke opmaakinformatie biedt over s.

result: DateTime

Wanneer deze methode wordt geretourneerd, bevat het resultaat van het parseren sof een niet-gedefinieerde waarde bij een fout.

Retouren

Boolean

trueindien s geparseerd; anders. false

Van toepassing op

TryParse(String, IFormatProvider, DateTime)

Bron:: DateTime.cs

Bron:: DateTime.cs

Bron:: DateTime.cs

Bron:: DateTime.cs

Bron:: DateTime.cs

Probeert een tekenreeks te parseren in een waarde.

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

Parameters

s: String

De tekenreeks die moet worden geparseerd.

provider: IFormatProvider

Een object dat cultuurspecifieke opmaakinformatie biedt over s.

result: DateTime

Wanneer deze methode wordt geretourneerd, bevat dit het resultaat van het parseren s of van een niet-gedefinieerde waarde bij een fout.

Retouren

Boolean

trueindien s geparseerd; anders. false

Van toepassing op

TryParse(String, IFormatProvider, DateTimeStyles, DateTime)

Bron:: DateTime.cs

Bron:: DateTime.cs

Bron:: DateTime.cs

Bron:: DateTime.cs

Bron:: DateTime.cs

Converteert de opgegeven tekenreeksweergave van een datum en tijd naar DateTime het equivalent ervan met behulp van de opgegeven cultuurspecifieke notatiegegevens en opmaakstijl en retourneert een waarde die aangeeft of de conversie is geslaagd.

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

Parameters

s: String

Een tekenreeks met een datum en tijd die moet worden geconverteerd.

provider: IFormatProvider

Een object dat cultuurspecifieke opmaakinformatie over slevert.

styles: DateTimeStyles

Een bitsgewijze combinatie van opsommingswaarden waarmee wordt gedefinieerd hoe de geparseerde datum moet worden geïnterpreteerd ten opzichte van de huidige tijdzone of de huidige datum. Een typische waarde die moet worden opgegeven, is None.

result: DateTime

Retouren

Boolean

trueals de s parameter is geconverteerd; anders. false

Uitzonderingen

ArgumentException

styles is geen geldige DateTimeStyles waarde.

– of –

styles bevat een ongeldige combinatie van DateTimeStyles waarden (bijvoorbeeld zowel AssumeLocal als AssumeUniversal).

NotSupportedException

provider is een neutrale cultuur en kan niet worden gebruikt in een parseringsbewerking.

Voorbeelden

In het volgende voorbeeld ziet u de DateTime.TryParse(String, IFormatProvider, DateTimeStyles, DateTime) methode.

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.

Opmerkingen

Zie Aanvullende API-opmerkingen voor DateTime.TryParse voor meer informatie over deze API.

Notities voor bellers

Opmaak wordt beïnvloed door eigenschappen van het huidige DateTimeFormatInfo object, dat wordt geleverd door de provider parameter. De TryParse methode kan onverwacht mislukken en retourneren False als de huidige DateSeparator en TimeSeparator eigenschappen zijn ingesteld op dezelfde waarde.

Zie ook

Van toepassing op

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

Bron:: DateTime.cs

Bron:: DateTime.cs

Bron:: DateTime.cs

Bron:: DateTime.cs

Bron:: DateTime.cs

Converteert de spanweergave van een datum en tijd naar DateTime het equivalent ervan met behulp van de opgegeven cultuurspecifieke notatiegegevens en opmaakstijl en retourneert een waarde die aangeeft of de conversie is geslaagd.

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

Parameters

s: ReadOnlySpan<Char>

Een periode met de tekens die de datum en tijd vertegenwoordigen die moeten worden geconverteerd.

provider: IFormatProvider

Een object dat cultuurspecifieke opmaakinformatie over slevert.

styles: DateTimeStyles

result: DateTime

Retouren

Boolean

trueals de s parameter is geconverteerd; anders. false

Van toepassing op

Feedback

Is deze pagina nuttig?