DateTime.TryParseExact Méthode

Source:

DateTime.cs

Source:

DateTime.cs

Source:

DateTime.cs

Source:

DateTime.cs

Source:

DateTime.cs

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

Retours

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

Exceptions

Source:

DateTime.cs

Source:

DateTime.cs

Source:

DateTime.cs

Source:

DateTime.cs

Source:

DateTime.cs

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

Retours

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

Exceptions

Source:

DateTime.cs

Source:

DateTime.cs

Source:

DateTime.cs

Source:

DateTime.cs

Source:

DateTime.cs

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

Retours

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

Exceptions

Exemples

L’exemple suivant illustre la DateTime.TryParseExact(String, String, IFormatProvider, DateTimeStyles, DateTime) méthode. Notez que la chaîne « 5/01/2009 8:30 AM » ne peut pas être analysée correctement lorsque le paramètre est DateTimeStyles.None égal, car les styles 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 avec succès avec un format « 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, comme format cela est nécessaire.

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

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

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

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

Si vous n’utilisez pas de séparateurs de date ou d’heure dans un modèle de format personnalisé, utilisez la culture indifférente pour le provider paramètre 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 ».

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 une langue particulière sont définis par le provider paramètre, comme le format précis de s si format est une chaîne de spécificateur de format standard. Le provider paramètre 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 DateTimeFormat propriété 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 personnalisée IFormatProvider dont GetFormat la méthode retourne l’objet CultureInfo ou l’objet DateTimeFormatInfo qui fournit des informations de mise en forme.

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

Le styles paramètre inclut un ou plusieurs membres de l’énumération DateTimeStyles qui déterminent si et où l’espace blanc n’est pas défini par format peut apparaître 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 TryParseExact(String, String, IFormatProvider, DateTimeStyles, DateTime) méthode.

Membre DateTimeStyles	Description
AdjustToUniversal	Analyse s et, si nécessaire, le convertit en UTC. Si s inclut un décalage de fuseau horaire, ou s’il 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é DateTimeKind.Utcsur . Si s elle indique qu’elle représente UTC, ou si s elle 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é DateTimeKind.Utcsur . 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 qui s peut contenir des espaces blancs de début, internes et de fin non définis par format.
AssumeLocal	Spécifie que si s ne contient 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 retournée DateTime est définie sur DateTimeKind.Local.
AssumeUniversal	Spécifie que si s manque d'informations sur le fuseau horaire, il est supposé représenter l'heure UTC. Sauf si l’indicateur DateTimeStyles.AdjustToUniversal est présent, la méthode convertit la valeur retournée DateTime de UTC en heure locale et définit sa propriété Kind sur DateTimeKind.Local.
NoCurrentDateDefault	Si s elle contient l’heure sans informations de date, la date de la valeur de retour est définie sur DateTime.MinValue.Date.
None	Le s paramètre est analysé à l’aide de valeurs par défaut. Aucun espace blanc autre que celui présent dans format n’est autorisé. S’il s n’existe pas de composant de date, la date de la valeur retournée DateTime est définie sur 1/1/0001. Si s aucune information de fuseau horaire n’est contenue, la Kind propriété de l’objet retourné DateTime est définie DateTimeKind.Unspecifiedsur . Si les informations de fuseau horaire sont présentes, sl’heure est convertie en heure locale et la Kind propriété de l’objet retourné DateTime est définie DateTimeKind.Localsur .
RoundtripKind	Pour les chaînes qui contiennent des informations de fuseau horaire, tente d’empêcher la conversion en valeur DateTime avec sa Kind propriété 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 TryParseExact méthode retourne false si la chaîne à analyser contient un composant horaire 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

• ParseExact
• CultureInfo
• DateTimeFormatInfo
• Analyse des chaînes de date et d’heure dans le .NET Framework
• Chaînes au format date et heure standard
• Chaînes de format de date et d'heure personnalisées

Source:

DateTime.cs

Source:

DateTime.cs

Source:

DateTime.cs

Source:

DateTime.cs

Source:

DateTime.cs

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

Retours

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

Exceptions

Exemples

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

Le s paramètre contient la date et l’heure à analyser. Si le s paramètre ne contient qu’une heure et aucune date, la date actuelle est utilisée, sauf si le style paramètre inclut l’indicateur DateTimeStyles.NoCurrentDateDefault , auquel cas la date par défaut (DateTime.Date.MinValue) est utilisée. Si le s paramètre contient uniquement une date et aucune heure, minuit (00:00:00) est utilisé. Le style paramètre détermine également si le s paramètre 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.

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

Le formats paramètre 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 formats paramètre se composent d’un ou plusieurs spécificateurs de format personnalisé à partir du tableau Chaînes de format date et heure personnalisées , ou d’un spécificateur de format standard unique, qui identifie un modèle prédéfini, à partir de la table Chaînes de format de date et d’heure standard .

Si vous n’utilisez pas de séparateurs de date ou d’heure dans un modèle de format personnalisé, utilisez la culture indifférente pour le provider paramètre 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 ».

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 une langue particulière sont définis par le provider paramètre, comme le format précis de s si format est une chaîne de spécificateur de format standard. Le provider paramètre 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 DateTimeFormat propriété 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 personnalisée IFormatProvider dont GetFormat la méthode retourne l’objet CultureInfo ou l’objet DateTimeFormatInfo qui fournit des informations de mise en forme.

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

Le styles paramètre inclut un ou plusieurs membres de l’énumération DateTimeStyles qui déterminent si et où l’espace blanc n’est pas défini par format peut apparaître 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 TryParseExact(String, String[], IFormatProvider, DateTimeStyles, DateTime) méthode.

Membre DateTimeStyles	Description
AdjustToUniversal	Analyse s et, si nécessaire, le convertit en UTC. Si s inclut un décalage de fuseau horaire, ou s’il 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é DateTimeKind.Utcsur . Si s elle indique qu’elle représente UTC, ou si s elle 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é DateTimeKind.Utcsur . 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 qui s peut contenir des espaces blancs de début, internes et de fin non définis par format.
AssumeLocal	Spécifie que si s ne contient 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 retournée DateTime est définie sur DateTimeKind.Local.
AssumeUniversal	Spécifie que si s manque d'informations sur le fuseau horaire, il est supposé représenter l'heure UTC. Sauf si l’indicateur DateTimeStyles.AdjustToUniversal est présent, la méthode convertit la valeur retournée DateTime de UTC en heure locale et définit sa propriété Kind sur DateTimeKind.Local.
NoCurrentDateDefault	Si s elle contient l’heure sans informations de date, la date de la valeur de retour est définie sur DateTime.MinValue.Date.
None	Le s paramètre est analysé à l’aide de valeurs par défaut. Aucun espace blanc autre que celui présent dans format n’est autorisé. S’il s n’existe pas de composant de date, la date de la valeur retournée DateTime est définie sur 1/1/0001. Si s aucune information de fuseau horaire n’est contenue, la Kind propriété de l’objet retourné DateTime est définie DateTimeKind.Unspecifiedsur . Si les informations de fuseau horaire sont présentes, sl’heure est convertie en heure locale et la Kind propriété de l’objet retourné DateTime est définie DateTimeKind.Localsur .
RoundtripKind	Pour les chaînes qui contiennent des informations de fuseau horaire, tente d’empêcher la conversion en valeur DateTime avec sa Kind propriété 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 TryParseExact méthode retourne false si la chaîne à analyser contient un composant horaire 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

• ParseExact
• CultureInfo
• DateTimeFormatInfo
• Analyse des chaînes de date et d’heure dans le .NET Framework
• Chaînes au format date et heure standard
• Chaînes de format de date et d'heure personnalisées