DateTime.TryParseExact 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. Le format de la représentation sous forme de chaîne doit correspondre exactement à un format spécifié. La méthode retourne une valeur qui indique si la conversion a réussi.

Surcharges

TryParseExact(ReadOnlySpan<Char>, ReadOnlySpan<Char>, IFormatProvider, DateTimeStyles, DateTime)	Convertit la représentation d’étendue spécifiée d’une date et d’une heure en son DateTime équivalent à l’aide du format spécifié, des informations de format spécifiques à la culture et du style. Le format de la représentation sous forme de chaîne doit correspondre exactement au format spécifié. La méthode retourne une valeur qui indique si la conversion a réussi.
TryParseExact(ReadOnlySpan<Char>, String[], IFormatProvider, DateTimeStyles, 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.
TryParseExact(String, 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 DateTime équivalent à l’aide du format spécifié, des informations de format propres à la culture et du style. Le format de la représentation sous forme de chaîne doit correspondre exactement au format spécifié. La méthode retourne une valeur qui indique si la conversion a réussi.
TryParseExact(String, 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 DateTime équivalent à l’aide du tableau de formats, des informations de format spécifiques à la culture et du style spécifiés. Le format de la représentation sous forme de chaîne doit correspondre exactement à l’un des formats spécifiés. La méthode retourne une valeur qui indique si la conversion a réussi.

Remarques

Important

Les ères dans les calendriers japonais sont basées sur le règne de l’empereur et sont donc censées changer. Par exemple, le 1er mai 2019 marque le début de l’ère Reiwa dans les 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 la modification de l’ère japonaise. Pour les fonctionnalités de .NET qui prennent en charge les calendriers avec plusieurs ères et pour les meilleures pratiques lors de l’utilisation de calendriers qui prennent en charge plusieurs ères, consultez Utilisation des ères.

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

Source:: DateTime.cs

Source:: DateTime.cs

Source:: DateTime.cs

Convertit la représentation d’étendue spécifiée d’une date et d’une heure en son DateTime équivalent à l’aide du format spécifié, des informations de format spécifiques à la culture et du style. Le format de la représentation sous forme de chaîne doit correspondre exactement au format spécifié. La méthode retourne une valeur qui indique si la conversion a réussi.

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

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

Paramètres

s: ReadOnlySpan<Char>

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

format: ReadOnlySpan<Char>

Format requis de s.

provider: IFormatProvider

Objet qui fournit des informations de mise en forme spécifiques à la culture sur s.

style: DateTimeStyles

Combinaison au niveau du bit d’une ou plusieurs valeurs d’énumération qui indiquent le format autorisé de s.

result: DateTime

Lorsque cette méthode est retournée, contient la valeur DateTime é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 ou format est null, est une chaîne vide ou ne contient pas de date et d’heure correspondant au modèle spécifié dans format. Ce paramètre est passé non initialisé.

Retours

Boolean

true si s a été convertie avec succès ; sinon, false.

S’applique à

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

Source:: DateTime.cs

Source:: DateTime.cs

Source:: DateTime.cs

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

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

Paramètres

s: ReadOnlySpan<Char>

Étendue contenant la chaîne à analyser.

formats: String[]

Tableau de formats autorisés de s.

provider: IFormatProvider

Objet qui fournit des informations de mise en forme spécifiques à la culture sur s.

style: DateTimeStyles

Combinaison de valeurs d’énumération au niveau du bit qui définit comment interpréter la date analysée par rapport au fuseau horaire actuel ou à la date actuelle. Une valeur classique à spécifier est None.

result: DateTime

Lorsque cette méthode est retournée, contient la valeur DateTime é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 Emptyou ne contient pas de représentation sous forme de chaîne valide d’une date et d’une heure. Ce paramètre est passé non initialisé.

Retours

Boolean

true si le paramètre s a été converti correctement ; sinon, false.

S’applique à

TryParseExact(String, String, IFormatProvider, DateTimeStyles, DateTime)

Source:: DateTime.cs

Source:: DateTime.cs

Source:: DateTime.cs

Convertit la représentation sous forme de chaîne spécifiée d’une date et d’une heure en son DateTime équivalent à l’aide du format spécifié, des informations de format propres à la culture et du style. Le format de la représentation sous forme de chaîne doit correspondre exactement au format spécifié. La méthode retourne une valeur qui indique si la conversion a réussi.

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

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

Paramètres

s: String

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

format: String

Format requis de s.

provider: IFormatProvider

Objet qui fournit des informations de mise en forme spécifiques à la culture sur s.

style: DateTimeStyles

Combinaison au niveau du bit d’une ou plusieurs valeurs d’énumération qui indiquent le format autorisé de s.

result: DateTime

Retours

Boolean

true si s a été convertie avec succès ; sinon, false.

Exceptions

ArgumentException

style n’est pas une valeur de DateTimeStyles valide.

-ou-

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

Exemples

L’exemple suivant illustre la méthode DateTime.TryParseExact(String, String, IFormatProvider, DateTimeStyles, DateTime). Notez que la chaîne « 5/01/2009 8:30 AM » ne peut pas être analysée correctement lorsque le paramètre styles est égal à DateTimeStyles.None, car les espaces de début ne sont pas autorisés par format. En outre, la chaîne « 5/01/2009 09:00 » ne peut pas être analysée correctement avec un format de « MM/dd/aaaah :mm », car la chaîne de date ne précède pas le nombre de mois avec un zéro non significatif, car format nécessite.

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

Remarques

La méthode DateTime.TryParseExact(String, String, IFormatProvider, DateTimeStyles, DateTime) analyse la représentation sous forme de chaîne d’une date, qui doit être au format défini par le paramètre format. Il est similaire à la méthode DateTime.ParseExact(String, String, IFormatProvider, DateTimeStyles), sauf que la méthode TryParseExact(String, String, IFormatProvider, DateTimeStyles, DateTime) ne lève pas d’exception si la conversion échoue.

Le paramètre s contient la date et l’heure à analyser et doit être dans un format défini par le paramètre format. Si les éléments date, heure et fuseau horaire sont présents dans s, ils doivent également apparaître dans l’ordre spécifié par format. Si format définit une date sans élément d’heure et que l’opération d’analyse réussit, la valeur de DateTime résultante a une heure de minuit (00:00:00). Si format définit une heure sans élément de date et que l’opération d’analyse réussit, la valeur de DateTime obtenue par défaut a une date de DateTime.Now.Date, ou a une date de DateTime.MinValue.Date si styles inclut l’indicateur de DateTimeStyles.NoCurrentDateDefault. Le paramètre style détermine si le paramètre s peut contenir des espaces blancs de début, internes ou de fin.

Si s ne contient aucune information de fuseau horaire, la propriété Kind de l’objet DateTime retourné est DateTimeKind.Unspecified. Ce comportement peut être modifié à l’aide de l’indicateur de DateTimeStyles.AssumeLocal, qui retourne une valeur DateTime dont la propriété Kind est DateTimeKind.Local, ou en utilisant les indicateurs DateTimeStyles.AssumeUniversal et DateTimeStyles.AdjustToUniversal, qui retourne une valeur DateTime dont la propriété Kind est DateTimeKind.Utc. Si s contient des informations de fuseau horaire, l’heure est convertie en heure locale, si nécessaire, et la propriété Kind de l’objet DateTime retourné est définie sur DateTimeKind.Local. Ce comportement peut être modifié à l’aide de l’indicateur de DateTimeStyles.RoundtripKind pour ne pas convertir le temps universel coordonné (UTC) en heure locale et définir la propriété Kind sur DateTimeKind.Utc.

Le paramètre format contient un modèle qui correspond au format attendu du paramètre s. Le modèle dans le paramètre se compose d’un ou plusieurs spécificateurs de format personnalisés du chaînes de format de date et d’heure personnalisées table, ou d’un spécificateur de format standard unique, qui identifie un modèle prédéfini, à partir des chaînes de format de date et d’heure standard table.

Si vous n’utilisez pas de séparateurs de date ou d’heure dans un modèle de format personnalisé, utilisez la culture invariante pour le paramètre provider et la forme la plus large de chaque spécificateur de format personnalisé. Par exemple, si vous souhaitez spécifier des heures dans le modèle, spécifiez le formulaire plus large , « HH », au lieu du formulaire plus étroit, « H ».

Note

Au lieu d’exiger que les s soient conformes à un format unique pour que l’opération d’analyse réussisse, vous pouvez appeler la méthode DateTime.TryParseExact(String, String[], IFormatProvider, DateTimeStyles, DateTime) et spécifier plusieurs formats autorisés. Cela rend l’opération d’analyse plus susceptible de réussir.

Les symboles et chaînes de date et d’heure spécifiques (tels que les noms des jours de la semaine dans une langue particulière) utilisés dans s sont définis par le paramètre provider, comme le format précis de s si format est une chaîne de spécificateur de format standard. Le paramètre provider peut être l’un des éléments suivants :

Objet CultureInfo qui représente la culture utilisée pour interpréter s. L’objet DateTimeFormatInfo retourné par sa propriété DateTimeFormat définit les symboles et la mise en forme dans s.
Objet DateTimeFormatInfo qui définit le format des données de date et d’heure.
Implémentation IFormatProvider personnalisée dont la méthode GetFormat retourne l’objet CultureInfo ou l’objet DateTimeFormatInfo qui fournit des informations de mise en forme.

Si provider est null, l’objet CultureInfo qui correspond à la culture actuelle est utilisé.

Le paramètre styles inclut un ou plusieurs membres de l’énumération DateTimeStyles qui déterminent si et où l’espace blanc non défini par format peut apparaître dans s et qui contrôlent le comportement précis de l’opération d’analyse. Le tableau suivant décrit comment chaque membre de l’énumération DateTimeStyles affecte l’opération de la méthode TryParseExact(String, String, IFormatProvider, DateTimeStyles, DateTime).

Membre DateTimeStyles	Description
AdjustToUniversal	Analyse `s` 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 de DateTimeStyles.AssumeLocal, la méthode analyse la chaîne, appelle ToUniversalTime pour convertir la valeur de DateTime retournée en UTC et définit la propriété Kind sur DateTimeKind.Utc. Si `s` indique qu’il représente UTC ou si `s` ne contient pas d’informations de fuseau horaire, mais `styles` inclut l’indicateur de DateTimeStyles.AssumeUniversal, la méthode analyse la chaîne, n’effectue aucune conversion de fuseau horaire sur la valeur de DateTime retournée et définit la propriété Kind sur DateTimeKind.Utc. Dans tous les autres cas, l’indicateur n’a aucun effet.
AllowInnerWhite	Spécifie que l’espace blanc non défini par `format` peut apparaître entre n’importe quel élément de date ou d’heure individuel.
AllowLeadingWhite	Spécifie que l’espace blanc non défini par `format` peut apparaître au début de `s`.
AllowTrailingWhite	Spécifie que l’espace blanc non défini par `format` peut apparaître à la fin de `s`.
AllowWhiteSpaces	Spécifie que `s` peut contenir des espaces blancs de début, internes et de fin non définis par `format`.
AssumeLocal	Spécifie que si `s` n’a pas d’informations de fuseau horaire, il est supposé représenter une heure locale. Sauf si l’indicateur DateTimeStyles.AdjustToUniversal est présent, la propriété Kind de la valeur de DateTime retournée est définie sur DateTimeKind.Local.
AssumeUniversal	Spécifie que si `s` n’a pas d’informations de fuseau horaire, il est supposé représenter UTC. Sauf si l’indicateur DateTimeStyles.AdjustToUniversal est présent, la méthode convertit la valeur de DateTime retournée de l’heure UTC en heure locale et définit sa propriété Kind sur DateTimeKind.Local.
NoCurrentDateDefault	Si `s` contient l’heure sans informations de date, la date de la valeur de retour est définie sur `DateTime.MinValue.Date`.
None	Le paramètre `s` est analysé à l’aide de valeurs par défaut. Aucun espace blanc autre que celui présent dans `format` n’est autorisé. Si `s` ne dispose pas d’un composant de date, la date de la valeur de DateTime retournée est définie sur 1/1/0001. Si `s` ne contient aucune information de fuseau horaire, la propriété Kind de l’objet DateTime retourné est définie sur DateTimeKind.Unspecified. Si les informations de fuseau horaire sont présentes dans `s`, l’heure est convertie en heure locale et la propriété Kind de l’objet DateTime retourné est définie sur DateTimeKind.Local.
RoundtripKind	Pour les chaînes qui contiennent des informations de fuseau horaire, tente d’empêcher la conversion vers une valeur DateTime avec sa propriété Kind définie sur DateTimeKind.Local. Cet indicateur empêche principalement la conversion des heures UTC en heures locales.

Notes pour les appelants

Dans .NET Framework 4, la méthode TryParseExact retourne false si la chaîne à analyser contient un composant d’heure et un indicateur AM/PM qui ne sont pas en accord. Dans .NET Framework 3.5 et versions antérieures, l’indicateur AM/PM est ignoré.

Voir aussi

S’applique à

TryParseExact(String, String[], IFormatProvider, DateTimeStyles, DateTime)

Source:: DateTime.cs

Source:: DateTime.cs

Source:: DateTime.cs

Convertit la représentation sous forme de chaîne spécifiée d’une date et d’une heure en son DateTime équivalent à l’aide du tableau de formats, des informations de format spécifiques à la culture et du style spécifiés. Le format de la représentation sous forme de chaîne doit correspondre exactement à l’un des formats spécifiés. La méthode retourne une valeur qui indique si la conversion a réussi.

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

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

Paramètres

s: String

Chaîne qui contient une date et une heure à convertir.

formats: String[]

Tableau de formats autorisés de s.

provider: IFormatProvider

Objet qui fournit des informations de format spécifiques à la culture sur s.

style: DateTimeStyles

Combinaison de valeurs d’énumération au niveau du bit qui indique le format autorisé de s. Une valeur classique à spécifier est None.

result: DateTime

Lorsque cette méthode est retournée, contient la valeur DateTime é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 s ou formats est null, s ou un élément de formats est une chaîne vide, ou si le format de s n’est pas exactement tel que spécifié par au moins un des modèles de format dans formats. Ce paramètre est passé non initialisé.

Retours

Boolean

true si le paramètre s a été converti correctement ; sinon, false.

Exceptions

ArgumentException

style n’est pas une valeur de DateTimeStyles valide.

-ou-

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

Exemples

L’exemple suivant utilise la méthode DateTime.TryParseExact(String, String, IFormatProvider, DateTimeStyles, DateTime) pour s’assurer qu’une chaîne dans un certain nombre de formats possibles peut être analysée avec succès.

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.

Remarques

La méthode DateTime.TryParseExact(String, String[], IFormatProvider, DateTimeStyles, DateTime) analyse la représentation sous forme de chaîne d’une date qui correspond à l’un des modèles attribués au paramètre formats. Elle est semblable à la méthode DateTime.ParseExact(String, String[], IFormatProvider, DateTimeStyles), sauf que la méthode TryParseExact ne lève pas d’exception si la conversion échoue.

Le paramètre s contient la date et l’heure à analyser. Si le paramètre s contient uniquement une heure et aucune date, la date actuelle est utilisée, sauf si le paramètre style inclut l’indicateur DateTimeStyles.NoCurrentDateDefault, auquel cas la date par défaut (DateTime.Date.MinValue) est utilisée. Si le paramètre s contient uniquement une date et aucune heure, minuit (00:00:00) est utilisé. Le paramètre style détermine également si le paramètre s peut contenir des espaces blancs de début, internes ou de fin autres que ceux autorisés par l’une des chaînes de format dans formats.

Le paramètre formats contient un tableau de modèles, dont l’un s doit correspondre exactement si l’opération d’analyse doit réussir. Les modèles du paramètre se composent d’un ou de plusieurs spécificateurs de format personnalisés de la table chaînes de format de date et d’heure personnalisées table, ou d’un spécificateur de format standard unique, qui identifie un modèle prédéfini, à partir des chaîne s de format de date et d’heure standard table.

Objet CultureInfo qui représente la culture utilisée pour interpréter s. L’objet DateTimeFormatInfo retourné par sa propriété DateTimeFormat définit les symboles et la mise en forme dans s.
Objet DateTimeFormatInfo qui définit le format des données de date et d’heure.
Implémentation IFormatProvider personnalisée dont la méthode GetFormat retourne l’objet CultureInfo ou l’objet DateTimeFormatInfo qui fournit des informations de mise en forme.

Si provider est null, l’objet CultureInfo qui correspond à la culture actuelle est utilisé.

Membre DateTimeStyles	Description
AdjustToUniversal	Analyse `s` 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 de DateTimeStyles.AssumeLocal, la méthode analyse la chaîne, appelle ToUniversalTime pour convertir la valeur de DateTime retournée en UTC et définit la propriété Kind sur DateTimeKind.Utc. Si `s` indique qu’il représente UTC ou si `s` ne contient pas d’informations de fuseau horaire, mais `styles` inclut l’indicateur de DateTimeStyles.AssumeUniversal, la méthode analyse la chaîne, n’effectue aucune conversion de fuseau horaire sur la valeur de DateTime retournée et définit la propriété Kind sur DateTimeKind.Utc. Dans tous les autres cas, l’indicateur n’a aucun effet.
AllowInnerWhite	Spécifie que l’espace blanc non défini par `format` peut apparaître entre n’importe quel élément de date ou d’heure individuel.
AllowLeadingWhite	Spécifie que l’espace blanc non défini par `format` peut apparaître au début de `s`.
AllowTrailingWhite	Spécifie que l’espace blanc non défini par `format` peut apparaître à la fin de `s`.
AllowWhiteSpaces	Spécifie que `s` peut contenir des espaces blancs de début, internes et de fin non définis par `format`.
AssumeLocal	Spécifie que si `s` n’a pas d’informations de fuseau horaire, il est supposé représenter une heure locale. Sauf si l’indicateur DateTimeStyles.AdjustToUniversal est présent, la propriété Kind de la valeur de DateTime retournée est définie sur DateTimeKind.Local.
AssumeUniversal	Spécifie que si `s` n’a pas d’informations de fuseau horaire, il est supposé représenter UTC. Sauf si l’indicateur DateTimeStyles.AdjustToUniversal est présent, la méthode convertit la valeur de DateTime retournée de l’heure UTC en heure locale et définit sa propriété Kind sur DateTimeKind.Local.
NoCurrentDateDefault	Si `s` contient l’heure sans informations de date, la date de la valeur de retour est définie sur `DateTime.MinValue.Date`.
None	Le paramètre `s` est analysé à l’aide de valeurs par défaut. Aucun espace blanc autre que celui présent dans `format` n’est autorisé. Si `s` ne dispose pas d’un composant de date, la date de la valeur de DateTime retournée est définie sur 1/1/0001. Si `s` ne contient aucune information de fuseau horaire, la propriété Kind de l’objet DateTime retourné est définie sur DateTimeKind.Unspecified. Si les informations de fuseau horaire sont présentes dans `s`, l’heure est convertie en heure locale et la propriété Kind de l’objet DateTime retourné est définie sur DateTimeKind.Local.
RoundtripKind	Pour les chaînes qui contiennent des informations de fuseau horaire, tente d’empêcher la conversion vers une valeur DateTime avec sa propriété Kind définie sur DateTimeKind.Local. Cet indicateur empêche principalement la conversion des heures UTC en heures locales.

Notes pour les appelants

Voir aussi

S’applique à

Partager via

DateTime.TryParseExact Méthode

Définition

Surcharges

Remarques

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

Paramètres

Retours

S’applique à

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

Paramètres

Retours

S’applique à

TryParseExact(String, String, IFormatProvider, DateTimeStyles, DateTime)

Paramètres

Retours

Exceptions

Exemples

Remarques

Notes pour les appelants

Voir aussi

S’applique à

TryParseExact(String, String[], IFormatProvider, DateTimeStyles, DateTime)

Paramètres

Retours

Exceptions

Exemples

Remarques

Notes pour les appelants

Voir aussi

S’applique à

Ressources supplémentaires