DateTime.TryParse Méthode

Référence

Définition

Espace de noms:: System

Assembly:: System.Runtime.dll

Assembly:: netstandard.dll

Assembly:: mscorlib.dll

Important

Certaines informations portent sur la préversion du produit qui est susceptible d’être en grande partie modifiée avant sa publication. Microsoft exclut toute garantie, expresse ou implicite, concernant les informations fournies ici.

Convertit la représentation sous forme de chaîne spécifiée d'une date et d'une heure en son équivalent DateTime et retourne une valeur qui indique si la conversion a réussi.

Surcharges

TryParse(ReadOnlySpan<Char>, DateTime)	Convertit l’étendue de caractères spécifiée d’une date et d’une heure en son équivalent DateTime et retourne une valeur qui indique si la conversion a réussi.
TryParse(String, DateTime)	Convertit la représentation sous forme de chaîne spécifiée d'une date et d'une heure en son équivalent DateTime et retourne une valeur qui indique si la conversion a réussi.
TryParse(ReadOnlySpan<Char>, IFormatProvider, DateTime)	Tente d’analyser une étendue de caractères dans une valeur.
TryParse(String, IFormatProvider, DateTime)	Tente d’analyser une chaîne dans une valeur.
TryParse(String, IFormatProvider, DateTimeStyles, DateTime)	Convertit la représentation sous forme de chaîne spécifiée d'une date et d'une heure en son équivalent DateTime à l'aide des informations de format et du style de mise en forme propres à la culture spécifiés, et retourne une valeur qui indique si la conversion a réussi.
TryParse(ReadOnlySpan<Char>, IFormatProvider, DateTimeStyles, DateTime)	Convertit la représentation sous forme d’étendue d’une date et d’une heure en son équivalent DateTime à l’aide des informations de format et du style de mise en forme propres à la culture spécifiés, et retourne une valeur qui indique si la conversion a réussi.

Remarques

Important

Les ères des calendriers japonais sont basées sur le règne de l’empereur et sont donc amenées à changer. Par exemple, le 1 mai 2019 a marqué le début de l’ère Reiwa dans JapaneseCalendar et JapaneseLunisolarCalendar. Ce changement d’ère affecte toutes les applications qui utilisent ces calendriers. Pour plus d’informations et pour déterminer si vos applications sont affectées, consultez Gestion d’une nouvelle ère dans le calendrier japonais dans .NET. Pour plus d’informations sur le test de vos applications sur les systèmes Windows afin de garantir leur préparation au changement d’ère, consultez Préparer votre application pour le changement d’ère japonaise. Pour connaître les fonctionnalités de .NET qui prennent en charge les calendriers avec plusieurs ères et pour connaître les meilleures pratiques lors de l’utilisation de calendriers qui prennent en charge plusieurs ères, consultez Utilisation des ères.

TryParse(ReadOnlySpan<Char>, DateTime)

Convertit l’étendue de caractères spécifiée d’une date et d’une heure en son équivalent DateTime et retourne une valeur qui indique si la conversion a réussi.

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

Paramètres

s: ReadOnlySpan<Char>

Chaîne contenant une date et une heure à convertir.

result: DateTime

Lorsque cette méthode est retournée, contient la DateTime valeur équivalente à la date et à l’heure contenues dans s, si la conversion a réussi, ou DateTime.MinValue si la conversion a échoué. La conversion échoue si le paramètre s est null, est une chaîne vide ("") ou ne contient pas de représentation sous forme de chaîne valide d'une date et d'une heure. Ce paramètre est passé sans être initialisé.

Retours

Boolean

true si la conversion du paramètre s a réussi ; sinon, false.

S’applique à

TryParse(String, DateTime)

Convertit la représentation sous forme de chaîne spécifiée d'une date et d'une heure en son équivalent DateTime et retourne une valeur qui indique si la conversion a réussi.

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

Paramètres

s: String

Chaîne contenant une date et une heure à convertir.

result: DateTime

Retours

Boolean

true si la conversion du paramètre s a réussi ; sinon, false.

Exemples

L’exemple suivant passe un certain nombre de chaînes de date et d’heure à la DateTime.TryParse(String, DateTime) méthode .

using namespace System;
using namespace System::Globalization;

void main()
{
   array<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 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);
   for each (String^ dateString in dateStrings)
   {
      if (DateTime::TryParse(dateString, dateValue)) 
         Console::WriteLine("  Converted '{0}' to {1} ({2}).", dateString, 
                           dateValue, dateValue.Kind);
      else
         Console::WriteLine("  Unable to parse '{0}'.", dateString);
   }
}
// The example displays the following output: 
//    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 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).

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

Remarques

La DateTime.TryParse(String, DateTime) méthode est similaire à la DateTime.Parse(String) méthode , sauf que la TryParse(String, DateTime) méthode ne lève pas d’exception en cas d’échec de la conversion.

La chaîne s est analysée à l’aide des informations de mise en forme dans l’objet actuel DateTimeFormatInfo , qui sont fournies implicitement par la culture actuelle.

Cette méthode tente d’ignorer les données non reconnues, si possible, et remplit les informations manquantes sur le mois, le jour et l’année avec la date actuelle. Si s contient uniquement une date et aucune heure, cette méthode suppose que l’heure est 12:00 minuit. Si s inclut un composant de date avec une année à deux chiffres, il est converti en année dans le calendrier actuel de la culture actuelle en fonction de la valeur de la Calendar.TwoDigitYearMax propriété . Tout caractère d’espace blanc de début, interne ou de fin dans s est ignoré. La date et l’heure peuvent être placées entre crochets par une paire de caractères SIGNE NUMÉRIQUE de début et de fin ('#', U+0023), et peuvent être suivis d’un ou plusieurs caractères NULL (U+0000).

Étant donné que la DateTime.TryParse(String, DateTime) méthode tente d’analyser la représentation sous forme de chaîne d’une date et d’une heure à l’aide des règles de mise en forme de la culture actuelle, la tentative d’analyse d’une chaîne particulière dans différentes cultures peut échouer ou renvoyer des résultats différents. Si un format de date et d’heure spécifique est analysé sur différents paramètres régionaux, utilisez la DateTime.TryParse(String, IFormatProvider, DateTimeStyles, DateTime) méthode ou l’une des surcharges de la TryParseExact méthode et fournissez un spécificateur de format.

Si s est la représentation sous forme de chaîne d’un jour bissextile dans une année bissextile s dans le calendrier actuel, la méthode analyse correctement. Si s est la représentation sous forme de chaîne d’un jour bissextile dans une année non bissextile dans le calendrier actuel de la culture actuelle, l’opération d’analyse échoue et la méthode retourne false.

Si s ne contient aucune information de fuseau horaire, result contient une DateTime valeur dont Kind la propriété est DateTimeKind.Unspecified lorsque la méthode retourne. Si la chaîne à analyser contient des informations de fuseau horaire, result contient une DateTime valeur dont Kind la propriété est DateTimeKind.Local lorsque la méthode retourne.

Notes pour les appelants

La mise en forme est influencée par les propriétés de l’objet actuelDateTimeFormatInfo, qui sont dérivées par défaut de l’élément Options régionales et linguistiques dans Panneau de configuration. La TryParse méthode peut échouer de manière inattendue et retourner False si les propriétés actuelles DateSeparator et TimeSeparator sont définies sur la même valeur.

Voir aussi

S’applique à

TryParse(ReadOnlySpan<Char>, IFormatProvider, DateTime)

Tente d’analyser une étendue de caractères dans une valeur.

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

Paramètres

s: ReadOnlySpan<Char>

Étendue de caractères à analyser.

provider: IFormatProvider

Objet qui fournit des informations de mise en forme propres à la culture concernant s.

result: DateTime

Lorsque cette méthode est retournée, contient le résultat de l’analyse sréussie ou d’une valeur non définie en cas d’échec.

Retours

Boolean

true si s a été correctement analysé ; sinon, false.

S’applique à

TryParse(String, IFormatProvider, DateTime)

Tente d’analyser une chaîne dans une valeur.

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

Paramètres

s: String

Chaîne à analyser.

provider: IFormatProvider

Objet qui fournit des informations de mise en forme propres à la culture concernant s.

result: DateTime

Lorsque cette méthode est retournée, contient le résultat de l’analyse s réussie ou une valeur non définie en cas d’échec.

Retours

Boolean

true si s a été correctement analysé ; sinon, false.

S’applique à

TryParse(String, IFormatProvider, DateTimeStyles, DateTime)

Convertit la représentation sous forme de chaîne spécifiée d'une date et d'une heure en son équivalent DateTime à l'aide des informations de format et du style de mise en forme propres à la culture spécifiés, et retourne une valeur qui indique si la conversion a réussi.

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

Paramètres

s: String

Chaîne contenant une date et une heure à convertir.

provider: IFormatProvider

Objet qui fournit des informations de mise en forme propres à la culture sur s.

styles: DateTimeStyles

Combinaison d'opérations de bits de valeurs d'énumération qui définit la manière d'interpréter les données analysées par rapport au fuseau horaire actuel ou à la date actuelle. Une valeur typique à spécifier est None.

result: DateTime

Retours

Boolean

true si la conversion du paramètre s a réussi ; sinon, false.

Exceptions

ArgumentException

styles n’est pas une valeur de DateTimeStyles valide.

- ou -

styles contient une combinaison non valide de valeurs DateTimeStyles (par exemple, AssumeLocal et AssumeUniversal).

NotSupportedException

provider est une culture neutre et ne peut pas être utilisé dans une opération d’analyse.

Exemples

L’exemple suivant illustre la DateTime.TryParse(String, IFormatProvider, DateTimeStyles, DateTime) méthode .

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.

Remarques

La DateTime.TryParse(String, IFormatProvider, DateTimeStyles, DateTime) méthode analyse une chaîne qui peut contenir des informations de date, d’heure et de fuseau horaire. Elle est similaire à la DateTime.Parse(String, IFormatProvider, DateTimeStyles) méthode , sauf que la DateTime.TryParse(String, DateTime) méthode ne lève pas d’exception en cas d’échec de la conversion.

Cette méthode tente d’ignorer les données non reconnues s et d’analyser complètement. Si s contient une heure mais aucune date, la méthode remplace par défaut la date actuelle ou, si styles inclut l’indicateur NoCurrentDateDefault , elle remplace DateTime.Date.MinValue. Si s contient une date mais aucune heure, 12:00 minuit est utilisé comme heure par défaut. Si une date est présente mais que son composant année se compose uniquement de deux chiffres, elle est convertie en une année dans le provider calendrier actuel du paramètre en fonction de la valeur de la Calendar.TwoDigitYearMax propriété . Tous les espaces blancs de début, internes ou de fin dans s sont ignorés. La date et l’heure peuvent être placées entre crochets par une paire de caractères SIGNE NUMÉRIQUE de début et de fin ('#', U+0023), et peuvent être suivis d’un ou plusieurs caractères NULL (U+0000).

Les formats valides spécifiques pour les éléments de date et d’heure, ainsi que les noms et symboles utilisés dans les dates et les heures, sont définis par le provider paramètre , qui peut être l’un des éléments suivants :

Objet CultureInfo qui représente la culture dont la mise en forme est utilisée dans le s paramètre . L’objet DateTimeFormatInfo retourné par la CultureInfo.DateTimeFormat propriété définit la mise en forme utilisée dans s.
Objet DateTimeFormatInfo qui définit la mise en forme utilisée dans s.
Implémentation IFormatProvider personnalisée. Sa IFormatProvider.GetFormat méthode retourne un DateTimeFormatInfo objet qui définit la mise en forme utilisée dans s.

Si provider est null, la culture actuelle est utilisée.

Si s est la représentation sous forme de chaîne d’un jour bissextile dans une année bissextile s dans le calendrier actuel, la méthode analyse correctement. Si s est la représentation sous forme de chaîne d’un jour bissextile dans une année non bissextile dans le calendrier actuel de , l’opération d’analyse provideréchoue et la méthode retourne false.

Le styles paramètre définit l’interprétation précise de la chaîne analysée et la façon dont l’opération d’analyse doit la gérer. Il peut s’agir d’un ou plusieurs membres de l’énumération DateTimeStyles , comme décrit dans le tableau suivant.

Membre DateTimeStyles	Description
AdjustToUniversal	`s` Analyse et, si nécessaire, la convertit en UTC. Si `s` inclut un décalage de fuseau horaire, ou si `s` ne contient aucune information de fuseau horaire, mais `styles` inclut l’indicateur DateTimeStyles.AssumeLocal , la méthode analyse la chaîne, appelle ToUniversalTime pour convertir la valeur retournée DateTime en UTC et définit la Kind propriété sur DateTimeKind.Utc. Si `s` indique qu’elle représente utc, ou si `s` ne contient pas d’informations de fuseau horaire, mais `styles` inclut l’indicateur DateTimeStyles.AssumeUniversal , la méthode analyse la chaîne, n’effectue aucune conversion de fuseau horaire sur la valeur retournée DateTime et définit la Kind propriété sur DateTimeKind.Utc. Dans tous les autres cas, l’indicateur n’a aucun effet.
AllowInnerWhite	Bien que valide, cette valeur est ignorée. L’espace blanc interne est autorisé dans les éléments de date et d’heure de `s`.
AllowLeadingWhite	Bien que valide, cette valeur est ignorée. L’espace blanc de début est autorisé dans les éléments de date et d’heure de `s`.
AllowTrailingWhite	Bien que valide, cette valeur est ignorée. Les espaces blancs de fin sont autorisés dans les éléments de date et d’heure de `s`.
AllowWhiteSpaces	Spécifie qui `s` peuvent contenir des espaces blancs de début, internes et de fin. Il s'agit du comportement par défaut. Il ne peut pas être remplacé en fournissant une valeur d’énumération plus restrictive DateTimeStyles telle que DateTimeStyles.None.
AssumeLocal	Spécifie que s’il `s` manque des informations de fuseau horaire, il est supposé représenter une heure locale. Sauf si l’indicateur DateTimeStyles.AdjustToUniversal est présent, la Kind propriété de la valeur retournée DateTime est définie sur DateTimeKind.Local.
AssumeUniversal	Spécifie que s’il `s` manque des informations de fuseau horaire, il est supposé représenter UTC. À moins que l’indicateur DateTimeStyles.AdjustToUniversal ne soit présent, la méthode convertit la valeur retournée DateTime d’UTC en heure locale et définit sa Kind propriété sur DateTimeKind.Local.
None	Bien que valide, cette valeur est ignorée.
RoundtripKind	Pour les chaînes qui contiennent des informations de fuseau horaire, tente d’empêcher la conversion d’une chaîne de date et d’heure en valeur DateTime avec sa Kind propriété définie sur DateTimeKind.Local. En règle générale, une telle chaîne est créée en appelant la méthode à l’aide DateTime.ToString(String) des spécificateurs de format standard « o », « r » ou « u ».

Si s ne contient aucune information de fuseau horaire, la méthode retourne une DateTime valeur dont Kind la DateTime.TryParse(String, IFormatProvider, DateTimeStyles, DateTime) propriété estDateTimeKind.Unspecified, sauf indication contraire d’un styles indicateur. Si s inclut des informations de fuseau horaire ou de décalage de fuseau horaire, la DateTime.TryParse(String, IFormatProvider, DateTimeStyles, DateTime) méthode effectue toute conversion d’heure nécessaire et retourne l’un des éléments suivants :

Valeur DateTime dont la date et l’heure reflètent l’heure locale et dont Kind la propriété est DateTimeKind.Local.
Ou, si styles inclut l’indicateur, une DateTime valeur dont la AdjustToUniversal date et l’heure reflètent UTC et dont Kind la propriété est DateTimeKind.Utc.

Ce comportement peut être remplacé à l’aide de l’indicateur DateTimeStyles.RoundtripKind .

Analyse des cultures personnalisées

Si vous analysez une chaîne de date et d’heure générée pour une culture personnalisée, utilisez la méthode à la TryParseExact place de la TryParse méthode pour améliorer la probabilité que l’opération d’analyse réussisse. Une chaîne de date et d’heure de culture personnalisée peut être compliquée et difficile à analyser. La TryParse méthode tente d’analyser une chaîne avec plusieurs modèles d’analyse implicites, qui peuvent tous échouer. En revanche, la TryParseExact méthode vous oblige à désigner explicitement un ou plusieurs modèles d’analyse exacts susceptibles de réussir.

Pour plus d’informations sur les cultures personnalisées, consultez la System.Globalization.CultureAndRegionInfoBuilder classe .

Notes pour les appelants

La mise en forme est influencée par les propriétés de l’objet actuel DateTimeFormatInfo , qui est fourni par le provider paramètre . La TryParse méthode peut échouer de manière inattendue et retourner False si les propriétés actuelles DateSeparator et TimeSeparator sont définies sur la même valeur.

Voir aussi

S’applique à

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

Convertit la représentation sous forme d’étendue d’une date et d’une heure en son équivalent DateTime à l’aide des informations de format et du style de mise en forme propres à la culture spécifiés, et retourne une valeur qui indique si la conversion a réussi.

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

Paramètres

s: ReadOnlySpan<Char>

Étendue contenant les caractères représentant la date et l’heure à convertir.

provider: IFormatProvider

Objet qui fournit des informations de mise en forme propres à la culture sur s.

styles: DateTimeStyles

result: DateTime

Lorsque cette méthode retourne, contient la DateTime valeur équivalente à la date et à l’heure contenues dans s, si la conversion a réussi, ou DateTime.MinValue si la conversion a échoué. La conversion échoue si le paramètre s est null, est une chaîne vide ("") ou ne contient pas de représentation sous forme de chaîne valide d'une date et d'une heure. Ce paramètre est passé sans être initialisé.

Retours

Boolean

true si la conversion du paramètre s a réussi ; sinon, false.

S’applique à

DateTime.TryParse Méthode

Définition

Surcharges

Remarques

TryParse(ReadOnlySpan<Char>, DateTime)

Paramètres

Retours

S’applique à

TryParse(String, DateTime)

Paramètres

Retours

Exemples

Remarques

Notes pour les appelants

Voir aussi

S’applique à

TryParse(ReadOnlySpan<Char>, IFormatProvider, DateTime)

Paramètres

Retours

S’applique à

TryParse(String, IFormatProvider, DateTime)

Paramètres

Retours

S’applique à

TryParse(String, IFormatProvider, DateTimeStyles, DateTime)

Paramètres

Retours

Exceptions

Exemples

Remarques

Analyse des cultures personnalisées

Notes pour les appelants

Voir aussi

S’applique à

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

Paramètres

Retours

S’applique à

Ressources supplémentaires