DateTime.ParseExact Méthode

Définition

Espace de noms:: System

Assemblys:: mscorlib.dll, System.Runtime.dll

Assemblys:: netstandard.dll, System.Runtime.dll

Assembly:: System.Runtime.dll

Assembly:: mscorlib.dll

Assembly:: netstandard.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 DateTime équivalent. Le format de la représentation sous forme de chaîne doit correspondre exactement à un format spécifié ou une exception est levée.

Surcharges

Nom	Description
ParseExact(String, String, IFormatProvider)	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 des informations de format spécifiques à la culture et au format spécifiés. Le format de la représentation sous forme de chaîne doit correspondre exactement au format spécifié.
ParseExact(ReadOnlySpan<Char>, ReadOnlySpan<Char>, IFormatProvider, DateTimeStyles)	Convertit la représentation d’étendue spécifiée d’une date et d’une heure en son DateTime équivalent à l’aide des informations de format spécifiques à la culture et au format spécifiés. Le format de la représentation sous forme de chaîne doit correspondre exactement au format spécifié ou une exception est levée.
ParseExact(ReadOnlySpan<Char>, String[], IFormatProvider, DateTimeStyles)	Convertit la représentation d’étendue 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 ou une exception est levée.
ParseExact(String, String, IFormatProvider, DateTimeStyles)	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 des informations de format spécifiques à la culture et au format spécifiés. Le format de la représentation sous forme de chaîne doit correspondre exactement au format spécifié ou une exception est levée.
ParseExact(String, String[], IFormatProvider, DateTimeStyles)	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 ou une exception est levée.

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 a marqué le début de l’ère Reiwa dans le 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 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.

ParseExact(String, String, IFormatProvider)

Source:: DateTime.cs

Source:: DateTime.cs

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 des informations de format spécifiques à la culture et au format spécifiés. Le format de la représentation sous forme de chaîne doit correspondre exactement au format spécifié.

public:
 static DateTime ParseExact(System::String ^ s, System::String ^ format, IFormatProvider ^ provider);

public static DateTime ParseExact(string s, string format, IFormatProvider provider);

public static DateTime ParseExact(string s, string format, IFormatProvider? provider);

static member ParseExact : string * string * IFormatProvider -> DateTime

Public Shared Function ParseExact (s As String, format As String, provider As IFormatProvider) As DateTime

Paramètres

s: String

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

format: String

Spécificateur de format qui définit le format requis de s. Pour plus d’informations, consultez la section Remarques.

provider: IFormatProvider

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

Retours

DateTime

Objet équivalent à la date et à l’heure contenues dans s, comme spécifié par format et provider.

Exceptions

ArgumentNullException

s ou format est null.

FormatException

s ou format est une chaîne vide.

- ou -

s ne contient pas de date et d’heure qui correspond au modèle spécifié dans format.

- ou -

Le composant horaire et l’indicateur AM/PM ne s sont pas d’accord.

Exemples

L’exemple suivant illustre la ParseExact méthode.

using System;
using System.Globalization;

public class Example
{
   public static void Main()
   {
      string dateString, format;
      DateTime result;
      CultureInfo provider = CultureInfo.InvariantCulture;

      // Parse date-only value with invariant culture.
      dateString = "06/15/2008";
      format = "d";
      try {
         result = DateTime.ParseExact(dateString, format, provider);
         Console.WriteLine("{0} converts to {1}.", dateString, result.ToString());
      }
      catch (FormatException) {
         Console.WriteLine("{0} is not in the correct format.", dateString);
      }

      // Parse date-only value without leading zero in month using "d" format.
      // Should throw a FormatException because standard short date pattern of
      // invariant culture requires two-digit month.
      dateString = "6/15/2008";
      try {
         result = DateTime.ParseExact(dateString, format, provider);
         Console.WriteLine("{0} converts to {1}.", dateString, result.ToString());
      }
      catch (FormatException) {
         Console.WriteLine("{0} is not in the correct format.", dateString);
      }

      // Parse date and time with custom specifier.
      dateString = "Sun 15 Jun 2008 8:30 AM -06:00";
      format = "ddd dd MMM yyyy h:mm tt zzz";
      try {
         result = DateTime.ParseExact(dateString, format, provider);
         Console.WriteLine("{0} converts to {1}.", dateString, result.ToString());
      }
      catch (FormatException) {
         Console.WriteLine("{0} is not in the correct format.", dateString);
      }

      // Parse date and time with offset but without offset's minutes.
      // Should throw a FormatException because "zzz" specifier requires leading
      // zero in hours.
      dateString = "Sun 15 Jun 2008 8:30 AM -06";
      try {
         result = DateTime.ParseExact(dateString, format, provider);
         Console.WriteLine("{0} converts to {1}.", dateString, result.ToString());
      }
      catch (FormatException) {
         Console.WriteLine("{0} is not in the correct format.", dateString);
      }

      dateString = "15/06/2008 08:30";
      format = "g";
      provider = new CultureInfo("fr-FR");
      try {
         result = DateTime.ParseExact(dateString, format, provider);
         Console.WriteLine("{0} converts to {1}.", dateString, result.ToString());
      }
      catch (FormatException) {
         Console.WriteLine("{0} is not in the correct format.", dateString);
      }

      // Parse a date that includes seconds and milliseconds
      // by using the French (France) and invariant cultures.
      dateString = "18/08/2015 06:30:15.006542";
      format = "dd/MM/yyyy HH:mm:ss.ffffff";
      try {
         result = DateTime.ParseExact(dateString, format, provider);
         Console.WriteLine("{0} converts to {1}.", dateString, result.ToString());
      }
      catch (FormatException) {
         Console.WriteLine("{0} is not in the correct format.", dateString);
      }
   }
}
// The example displays the following output:
//       06/15/2008 converts to 6/15/2008 12:00:00 AM.
//       6/15/2008 is not in the correct format.
//       Sun 15 Jun 2008 8:30 AM -06:00 converts to 6/15/2008 7:30:00 AM.
//       Sun 15 Jun 2008 8:30 AM -06 is not in the correct format.
//       15/06/2008 08:30 converts to 6/15/2008 8:30:00 AM.
//       18/08/2015 06:30:15.006542 converts to 8/18/2015 6:30:15 AM.

open System
open System.Globalization

[<EntryPoint>]
let main _ =
    let provider = CultureInfo.InvariantCulture

    // Parse date-only value with invariant culture.
    let dateString = "06/15/2008"
    let format = "d"
    try
        let result = DateTime.ParseExact(dateString, format, provider)
        printfn $"{dateString} converts to {result}."
    with :? FormatException ->
        printfn $"{dateString} is not in the correct format."

    // Parse date-only value without leading zero in month using "d" format.
    // Should throw a FormatException because standard short date pattern of
    // invariant culture requires two-digit month.
    let dateString = "6/15/2008"
    try
        let result = DateTime.ParseExact(dateString, format, provider)
        printfn $"{dateString} converts to {result}."
    with :? FormatException ->
        printfn $"{dateString} is not in the correct format."

    // Parse date and time with custom specifier.
    let dateString = "Sun 15 Jun 2008 8:30 AM -06:00"
    let format = "ddd dd MMM yyyy h:mm tt zzz"
    try
        let result = DateTime.ParseExact(dateString, format, provider)
        printfn $"{dateString} converts to {result}."
    with :? FormatException ->
        printfn $"{dateString} is not in the correct format."

    // Parse date and time with offset but without offset's minutes.
    // Should throw a FormatException because "zzz" specifier requires leading
    // zero in hours.
    let dateString = "Sun 15 Jun 2008 8:30 AM -06"
    try
        let result = DateTime.ParseExact(dateString, format, provider)
        printfn $"{dateString} converts to {result}."
    with :? FormatException ->
        printfn $"{dateString} is not in the correct format."

    let dateString = "15/06/2008 08:30"
    let format = "g"
    let provider = CultureInfo "fr-FR"
    try
        let result = DateTime.ParseExact(dateString, format, provider)
        printfn $"{dateString} converts to {result}."
    with :? FormatException ->
        printfn $"{dateString} is not in the correct format."

    // Parse a date that includes seconds and milliseconds
    // by using the French (France) and invariant cultures.
    let dateString = "18/08/2015 06:30:15.006542"
    let format = "dd/MM/yyyy HH:mm:ss.ffffff"
    try
        let result = DateTime.ParseExact(dateString, format, provider)
        printfn $"{dateString} converts to {result}."
    with :? FormatException ->
        printfn $"{dateString} is not in the correct format."

    0

// The example displays the following output:
//       06/15/2008 converts to 6/15/2008 12:00:00 AM.
//       6/15/2008 is not in the correct format.
//       Sun 15 Jun 2008 8:30 AM -06:00 converts to 6/15/2008 7:30:00 AM.
//       Sun 15 Jun 2008 8:30 AM -06 is not in the correct format.
//       15/06/2008 08:30 converts to 6/15/2008 8:30:00 AM.
//       18/08/2015 06:30:15.006542 converts to 8/18/2015 6:30:15 AM.

Imports System.Globalization

Module Example
   Public Sub Main()
      Dim dateString, format As String  
      Dim result As Date
      Dim provider As CultureInfo = CultureInfo.InvariantCulture

      ' Parse date-only value with invariant culture.
      dateString = "06/15/2008"
      format = "d"
      Try
         result = Date.ParseExact(dateString, format, provider)
         Console.WriteLine("{0} converts to {1}.", dateString, result.ToString())
      Catch e As FormatException
         Console.WriteLine("{0} is not in the correct format.", dateString)
      End Try 

      ' Parse date-only value without leading zero in month using "d" format.
      ' Should throw a FormatException because standard short date pattern of 
      ' invariant culture requires two-digit month.
      dateString = "6/15/2008"
      Try
         result = Date.ParseExact(dateString, format, provider)
         Console.WriteLine("{0} converts to {1}.", dateString, result.ToString())
      Catch e As FormatException
         Console.WriteLine("{0} is not in the correct format.", dateString)
      End Try 
      
      ' Parse date and time with custom specifier.
      dateString = "Sun 15 Jun 2008 8:30 AM -06:00"
      format = "ddd dd MMM yyyy h:mm tt zzz"        
      Try
         result = Date.ParseExact(dateString, format, provider)
         Console.WriteLine("{0} converts to {1}.", dateString, result.ToString())
      Catch e As FormatException
         Console.WriteLine("{0} is not in the correct format.", dateString)
      End Try 
      
      ' Parse date and time with offset but without offset's minutes.
      ' Should throw a FormatException because "zzz" specifier requires leading  
      ' zero in hours.
      dateString = "Sun 15 Jun 2008 8:30 AM -06"
      Try
         result = Date.ParseExact(dateString, format, provider)
         Console.WriteLine("{0} converts to {1}.", dateString, result.ToString())
      Catch e As FormatException
         Console.WriteLine("{0} is not in the correct format.", dateString)
      End Try 
      
      ' Parse a date string using the French (France) culture.
      dateString = "15/06/2008 08:30"
      format = "g"
      provider = New CultureInfo("fr-FR")
      Try
         result = Date.ParseExact(dateString, format, provider)
         Console.WriteLine("{0} converts to {1}.", dateString, result.ToString())
      Catch e As FormatException
         Console.WriteLine("{0} is not in the correct format.", dateString)
      End Try

      ' Parse a date that includes seconds and milliseconds
      ' by using the French (France) and invariant cultures.
      dateString = "18/08/2015 06:30:15.006542"
      format = "dd/MM/yyyy HH:mm:ss.ffffff"
      Try
         result = Date.ParseExact(dateString, format, provider)
         Console.WriteLine("{0} converts to {1}.", dateString, result.ToString())
      Catch e As FormatException
         Console.WriteLine("{0} is not in the correct format.", dateString)
      End Try
   End Sub
End Module
' The example displays the following output:
'       06/15/2008 converts to 6/15/2008 12:00:00 AM.
'       6/15/2008 is not in the correct format.
'       Sun 15 Jun 2008 8:30 AM -06:00 converts to 6/15/2008 7:30:00 AM.
'       Sun 15 Jun 2008 8:30 AM -06 is not in the correct format.
'       15/06/2008 08:30 converts to 6/15/2008 8:30:00 AM.
'       18/08/2015 06:30:15.006542 converts to 8/18/2015 6:30:15 AM.

Remarques

La DateTime.ParseExact(String, String, IFormatProvider) 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. Il exige également que les <éléments Date> et <Heure> de la représentation sous forme de chaîne d’une date et d’une heure apparaissent dans l’ordre spécifié par format, et qui s n’ont pas d’espace blanc autre que celui autorisé 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 a une date de DateTime.Now.Date.

Si s elle ne représente pas une heure dans un fuseau horaire particulier et que l’opération d’analyse réussit, la Kind propriété de la valeur retournée DateTime est DateTimeKind.Unspecified. Si s elle représente l’heure dans un fuseau horaire particulier et format autorise la présence d’informations de fuseau horaire (par exemple, si format elle est égale aux spécificateurs de format standard « o », « r » ou « u », ou si elle contient les spécificateurs de format personnalisés « z », « zz » ou « zzz »), la Kind propriété de la valeur retournée DateTime est DateTimeKind.Local.

Le format paramètre est une chaîne qui contient un spécificateur de format standard unique, ou un ou plusieurs spécificateurs de format personnalisés qui définissent le format requis de s. Pour plus d’informations sur les codes de mise en forme valides, consultez Chaînes de format de date et d’heure standard ou chaînes de format de date et d’heure personnalisées.

Note

S’il s’agit format d’un modèle de format personnalisé qui n’inclut pas de séparateurs de date ou d’heure (tels que « yyyyMMddHmm »), utilisez la culture invariante 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 de format, spécifiez le formulaire plus large, « HH », au lieu du formulaire plus étroit , « H ».

Les symboles et chaînes de date et d’heure particuliers (tels que les noms des jours de la semaine dans une langue particulière) utilisés dans s un langage particulier sont définis par le provider paramètre, comme c’est le format précis de s’il sformat s’agit d’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é.

Notes pour les appelants

Dans .NET Framework 4, la ParseExact méthode lève une FormatException valeur 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 à

ParseExact(ReadOnlySpan<Char>, ReadOnlySpan<Char>, IFormatProvider, DateTimeStyles)

Source:: DateTime.cs

Source:: DateTime.cs

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 des informations de format spécifiques à la culture et au format spécifiés. Le format de la représentation sous forme de chaîne doit correspondre exactement au format spécifié ou une exception est levée.

public static DateTime ParseExact(ReadOnlySpan<char> s, ReadOnlySpan<char> format, IFormatProvider? provider, System.Globalization.DateTimeStyles style = System.Globalization.DateTimeStyles.None);

public static DateTime ParseExact(ReadOnlySpan<char> s, ReadOnlySpan<char> format, IFormatProvider provider, System.Globalization.DateTimeStyles style = System.Globalization.DateTimeStyles.None);

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

Public Shared Function ParseExact (s As ReadOnlySpan(Of Char), format As ReadOnlySpan(Of Char), provider As IFormatProvider, Optional style As DateTimeStyles = System.Globalization.DateTimeStyles.None) As DateTime

Paramètres

s: ReadOnlySpan<Char>

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

format: ReadOnlySpan<Char>

Étendue contenant les caractères qui représentent un spécificateur de format qui définit le format requis de s.

provider: IFormatProvider

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

style: DateTimeStyles

Combinaison de bits des valeurs d’énumération qui fournit des informations supplémentaires sur sles éléments de style qui peuvent être présents ou ssur la conversion d’une sDateTime valeur. Une valeur classique à spécifier est None.

Retours

DateTime

Objet équivalent à la date et à l’heure contenues dans s, comme spécifié par format, provideret style.

S’applique à

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

Source:: DateTime.cs

Source:: DateTime.cs

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 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 ou une exception est levée.

public static DateTime ParseExact(ReadOnlySpan<char> s, string[] formats, IFormatProvider? provider, System.Globalization.DateTimeStyles style = System.Globalization.DateTimeStyles.None);

public static DateTime ParseExact(ReadOnlySpan<char> s, string[] formats, IFormatProvider provider, System.Globalization.DateTimeStyles style = System.Globalization.DateTimeStyles.None);

static member ParseExact : ReadOnlySpan<char> * string[] * IFormatProvider * System.Globalization.DateTimeStyles -> DateTime

Public Shared Function ParseExact (s As ReadOnlySpan(Of Char), formats As String(), provider As IFormatProvider, Optional style As DateTimeStyles = System.Globalization.DateTimeStyles.None) As DateTime

Paramètres

s: ReadOnlySpan<Char>

Étendue contenant les caractères qui représentent 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 bits de valeurs d’énumération qui indique le format autorisé de s. Une valeur classique à spécifier est None.

Retours

DateTime

Objet équivalent à la date et à l’heure contenues dans s, comme spécifié par formats, provideret style.

S’applique à

ParseExact(String, String, IFormatProvider, DateTimeStyles)

Source:: DateTime.cs

Source:: DateTime.cs

Source:: DateTime.cs

Source:: DateTime.cs

Source:: DateTime.cs

public:
 static DateTime ParseExact(System::String ^ s, System::String ^ format, IFormatProvider ^ provider, System::Globalization::DateTimeStyles style);

public static DateTime ParseExact(string s, string format, IFormatProvider provider, System.Globalization.DateTimeStyles style);

public static DateTime ParseExact(string s, string format, IFormatProvider? provider, System.Globalization.DateTimeStyles style);

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

Public Shared Function ParseExact (s As String, format As String, provider As IFormatProvider, style As DateTimeStyles) As DateTime

Paramètres

s: String

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

format: String

Spécificateur de format qui définit le format requis de s. Pour plus d’informations, consultez la section Remarques.

provider: IFormatProvider

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

style: DateTimeStyles

Retours

DateTime

Objet équivalent à la date et à l’heure contenues dans s, comme spécifié par format, provideret style.

Exceptions

ArgumentNullException

s ou format est null.

FormatException

s ou format est une chaîne vide.

- ou -

s ne contient pas de date et d’heure qui correspond au modèle spécifié dans format.

- ou -

Le composant horaire et l’indicateur AM/PM ne s sont pas d’accord.

ArgumentException

style contient une combinaison de DateTimeStyles valeurs non valide. Par exemple, AssumeLocal et AssumeUniversal.

Exemples

L’exemple suivant illustre la ParseExact(String, String, IFormatProvider) 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";
      try {
         dateValue = DateTime.ParseExact(dateString, "g", enUS, DateTimeStyles.None);
         Console.WriteLine("Converted '{0}' to {1} ({2}).", dateString, dateValue,
                           dateValue.Kind);
      }
      catch (FormatException) {
         Console.WriteLine("'{0}' is not in an acceptable format.", dateString);
      }
      // Allow a leading space in the date string.
      try {
         dateValue = DateTime.ParseExact(dateString, "g", enUS, DateTimeStyles.AllowLeadingWhite);
         Console.WriteLine("Converted '{0}' to {1} ({2}).", dateString, dateValue,
                           dateValue.Kind);
      }
      catch (FormatException) {
         Console.WriteLine("'{0}' is not in an acceptable format.", dateString);
      }

      // Use custom formats with M and MM.
      dateString = "5/01/2009 09:00";
      try {
         dateValue = DateTime.ParseExact(dateString, "M/dd/yyyy hh:mm", enUS, DateTimeStyles.None);
         Console.WriteLine("Converted '{0}' to {1} ({2}).", dateString, dateValue,
                           dateValue.Kind);
      }
      catch (FormatException) {
         Console.WriteLine("'{0}' is not in an acceptable format.", dateString);
      }
      // Allow a leading space in the date string.
      try {
         dateValue = DateTime.ParseExact(dateString, "MM/dd/yyyy hh:mm", enUS, DateTimeStyles.None);
         Console.WriteLine("Converted '{0}' to {1} ({2}).", dateString, dateValue,
                           dateValue.Kind);
      }
      catch (FormatException) {
         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";
      try {
         dateValue = DateTime.ParseExact(dateString, "MM/dd/yyyy hh:mm:ss tt zzz", enUS, DateTimeStyles.None);
         Console.WriteLine("Converted '{0}' to {1} ({2}).", dateString, dateValue,
                           dateValue.Kind);
      }
      catch (FormatException) {
         Console.WriteLine("'{0}' is not in an acceptable format.", dateString);
      }
      // Allow a leading space in the date string.
      try {
         dateValue = DateTime.ParseExact(dateString, "MM/dd/yyyy hh:mm:ss tt zzz", enUS,
                                     DateTimeStyles.AdjustToUniversal);
         Console.WriteLine("Converted '{0}' to {1} ({2}).", dateString, dateValue,
                           dateValue.Kind);
      }
      catch (FormatException) {
         Console.WriteLine("'{0}' is not in an acceptable format.", dateString);
      }

      // Parse a string representing UTC.
      dateString = "2008-06-11T16:11:20.0904778Z";
      try {
         dateValue = DateTime.ParseExact(dateString, "o", CultureInfo.InvariantCulture,
                                     DateTimeStyles.None);
         Console.WriteLine("Converted '{0}' to {1} ({2}).", dateString, dateValue,
                           dateValue.Kind);
      }
      catch (FormatException) {
         Console.WriteLine("'{0}' is not in an acceptable format.", dateString);
      }
      try {
         dateValue = DateTime.ParseExact(dateString, "o", CultureInfo.InvariantCulture,
                                     DateTimeStyles.RoundtripKind);
         Console.WriteLine("Converted '{0}' to {1} ({2}).", dateString, dateValue,
                           dateValue.Kind);
      }
      catch (FormatException) {
         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"
    try
        let dateValue = DateTime.ParseExact(dateString, "g", enUS, DateTimeStyles.None)
        printfn $"Converted '{dateString}' to {dateValue} ({dateValue.Kind})."
    with :? FormatException ->
        printfn $"'{dateString}' is not in an acceptable format."
    
    // Allow a leading space in the date string.
    try
        let dateValue = DateTime.ParseExact(dateString, "g", enUS, DateTimeStyles.AllowLeadingWhite)
        printfn $"Converted '{dateString}' to {dateValue} ({dateValue.Kind})."
    with :? FormatException ->
        printfn $"'{dateString}' is not in an acceptable format."

    // Use custom formats with M and MM.
    let dateString = "5/01/2009 09:00"
    try
        let dateValue = DateTime.ParseExact(dateString, "M/dd/yyyy hh:mm", enUS, DateTimeStyles.None)
        printfn $"Converted '{dateString}' to {dateValue} ({dateValue.Kind})."
    with :? FormatException ->
        printfn $"'{dateString}' is not in an acceptable format."

    // Allow a leading space in the date string.
    try
        let dateValue = DateTime.ParseExact(dateString, "MM/dd/yyyy hh:mm", enUS, DateTimeStyles.None)
        printfn $"Converted '{dateString}' to {dateValue} ({dateValue.Kind})."
    with :? FormatException ->
        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"
    try
        let dateValue = DateTime.ParseExact(dateString, "MM/dd/yyyy hh:mm:ss tt zzz", enUS, DateTimeStyles.None)
        printfn $"Converted '{dateString}' to {dateValue} ({dateValue.Kind})."
    with :? FormatException ->
        printfn $"'{dateString}' is not in an acceptable format."

    // Allow a leading space in the date string.
    try
        let dateValue = DateTime.ParseExact(dateString, "MM/dd/yyyy hh:mm:ss tt zzz", enUS, DateTimeStyles.AdjustToUniversal)
        printfn $"Converted '{dateString}' to {dateValue} ({dateValue.Kind})."
    with :? FormatException ->
        printfn $"'{dateString}' is not in an acceptable format."

    // Parse a string representing UTC.
    let dateString = "2008-06-11T16:11:20.0904778Z"
    try
        let dateValue = DateTime.ParseExact(dateString, "o", CultureInfo.InvariantCulture, DateTimeStyles.None)
        printfn $"Converted '{dateString}' to {dateValue} ({dateValue.Kind})."
    with :? FormatException ->
        printfn $"'{dateString}' is not in an acceptable format."

    try
        let dateValue = DateTime.ParseExact(dateString, "o", CultureInfo.InvariantCulture, DateTimeStyles.RoundtripKind)
        printfn $"Converted '{dateString}' to {dateValue} ({dateValue.Kind})."
    with :? FormatException ->
        printfn $"'{dateString}' is not in an acceptable format."


// 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

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"
      Try
         dateValue = Date.ParseExact(dateString, "g", enUS, DateTimeStyles.None)
         Console.WriteLine("Converted '{0}' to {1} ({2}).", dateString, dateValue, _
                           dateValue.Kind)
      Catch e As FormatException
         Console.WriteLine("'{0}' is not in an acceptable format.", dateString)
      End Try
      ' Allow a leading space in the date string.
      Try
         dateValue = Date.ParseExact(dateString, "g", enUS, DateTimeStyles.AllowLeadingWhite)
         Console.WriteLine("Converted '{0}' to {1} ({2}).", dateString, dateValue, _
                           dateValue.Kind)
      Catch e As FormatException
         Console.WriteLine("'{0}' is not in an acceptable format.", dateString)
      End Try
      
      ' Use custom formats with M and MM.
      dateString = "5/01/2009 09:00"
      Try
         dateValue = Date.ParseExact(dateString, "M/dd/yyyy hh:mm", enUS, DateTimeStyles.None)
         Console.WriteLine("Converted '{0}' to {1} ({2}).", dateString, dateValue, _
                           dateValue.Kind)
      Catch e As FormatException
         Console.WriteLine("'{0}' is not in an acceptable format.", dateString)
      End Try
      ' Allow a leading space in the date string.
      Try
         dateValue = Date.ParseExact(dateString, "MM/dd/yyyy hh:mm", enUS, DateTimeStyles.None)
         Console.WriteLine("Converted '{0}' to {1} ({2}).", dateString, dateValue, _
                           dateValue.Kind)
      Catch e As FormatException
         Console.WriteLine("'{0}' is not in an acceptable format.", dateString)
      End Try

      ' Parse a string with time zone information.
      dateString = "05/01/2009 01:30:42 PM -05:00" 
      Try
         dateValue = Date.ParseExact(dateString, "MM/dd/yyyy hh:mm:ss tt zzz", enUS, DateTimeStyles.None)
         Console.WriteLine("Converted '{0}' to {1} ({2}).", dateString, dateValue, _
                           dateValue.Kind)
      Catch e As FormatException
         Console.WriteLine("'{0}' is not in an acceptable format.", dateString)
      End Try
      ' Allow a leading space in the date string.
      Try
         dateValue = Date.ParseExact(dateString, "MM/dd/yyyy hh:mm:ss tt zzz", enUS, _
                                     DateTimeStyles.AdjustToUniversal)
         Console.WriteLine("Converted '{0}' to {1} ({2}).", dateString, dateValue, _
                           dateValue.Kind)
      Catch e As FormatException
         Console.WriteLine("'{0}' is not in an acceptable format.", dateString)
      End Try
           
      ' Parse a string representing UTC.
      dateString = "2008-06-11T16:11:20.0904778Z"
      Try
         dateValue = Date.ParseExact(dateString, "o", CultureInfo.InvariantCulture, _
                                     DateTimeStyles.None)
         Console.WriteLine("Converted '{0}' to {1} ({2}).", dateString, dateValue, _
                           dateValue.Kind)
      Catch e As FormatException
         Console.WriteLine("'{0}' is not in an acceptable format.", dateString)
      End Try
      Try
         dateValue = Date.ParseExact(dateString, "o", CultureInfo.InvariantCulture, _
                                     DateTimeStyles.RoundtripKind)
         Console.WriteLine("Converted '{0}' to {1} ({2}).", dateString, dateValue, _
                           dateValue.Kind)
      Catch e As FormatException
         Console.WriteLine("'{0}' is not in an acceptable format.", dateString)
      End Try
   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.ParseExact(String, String, IFormatProvider, DateTimeStyles) méthode analyse la représentation sous forme de chaîne d’une date, qui doit être dans un format défini par le format paramètre. Il exige également que les éléments s de date et d’heure apparaissent dans l’ordre spécifié par format. Si s elle ne correspond pas au modèle du format paramètre, avec des variantes définies par le style paramètre, la méthode lève un FormatException. En revanche, la DateTime.Parse(String, IFormatProvider, DateTimeStyles) méthode analyse la représentation sous forme de chaîne d’une date dans l’un des formats reconnus par l’objet du fournisseur de DateTimeFormatInfo format. La DateTime.Parse(String, IFormatProvider, DateTimeStyles) méthode permet également aux éléments de date et d’heure d’apparaître s dans n’importe quel ordre.

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 caractères d’espace blanc de début, d’intérieur 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 elle 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 définit le modèle requis du s paramètre. Il peut se composer 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 du tableau 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 ».

Note

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

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 ParseExact(String, String, IFormatProvider, DateTimeStyles) 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, `s`l’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 date DateTime et heure de valeur avec sa Kind propriété définie sur DateTimeKind.Local. Cet indicateur empêche principalement la conversion des heures UTC en heures locales.

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

Notes pour les appelants

Voir aussi

S’applique à

ParseExact(String, String[], IFormatProvider, DateTimeStyles)

Source:: DateTime.cs

Source:: DateTime.cs

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 ou une exception est levée.

public:
 static DateTime ParseExact(System::String ^ s, cli::array <System::String ^> ^ formats, IFormatProvider ^ provider, System::Globalization::DateTimeStyles style);

public static DateTime ParseExact(string s, string[] formats, IFormatProvider provider, System.Globalization.DateTimeStyles style);

public static DateTime ParseExact(string s, string[] formats, IFormatProvider? provider, System.Globalization.DateTimeStyles style);

static member ParseExact : string * string[] * IFormatProvider * System.Globalization.DateTimeStyles -> DateTime

Public Shared Function ParseExact (s As String, formats As String(), provider As IFormatProvider, style As DateTimeStyles) As DateTime

Paramètres

s: String

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

formats: String[]

Tableau de formats autorisés de s. Pour plus d’informations, consultez la section Remarques.

provider: IFormatProvider

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

style: DateTimeStyles

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

Retours

DateTime

Objet équivalent à la date et à l’heure contenues dans s, comme spécifié par formats, provideret style.

Exceptions

ArgumentNullException

s ou formats est null.

FormatException

s est une chaîne vide.

- ou -

un élément d’une formats chaîne vide.

- ou -

s ne contient pas de date et d’heure qui correspond à n’importe quel élément de formats.

- ou -

Le composant horaire et l’indicateur AM/PM ne s sont pas d’accord.

ArgumentException

style contient une combinaison de DateTimeStyles valeurs non valide. Par exemple, AssumeLocal et AssumeUniversal.

Exemples

L’exemple suivant utilise la DateTime.ParseExact(String, String[], IFormatProvider, DateTimeStyles) 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",
                         "MM/d/yyyy HH:mm:ss.ffffff" };
      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",
                              "08/28/2015 16:17:39.125", "08/28/2015 16:17:39.125000" };
      DateTime dateValue;

      foreach (string dateString in dateStrings)
      {
         try {
            dateValue = DateTime.ParseExact(dateString, formats,
                                            new CultureInfo("en-US"),
                                            DateTimeStyles.None);
            Console.WriteLine("Converted '{0}' to {1}.", dateString, dateValue);
         }
         catch (FormatException) {
            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.
//       Unable to convert '08/28/2015 16:17:39.125' to a date.
//       Converted '08/28/2015 16:17:39.125000' to 8/28/2015 4:17:39 PM.

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"
       "MM/d/yyyy HH:mm:ss.ffffff" |]

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"
      "08/28/2015 16:17:39.125"; "08/28/2015 16:17:39.125000" ]

for dateString in dateStrings do
    try
        let dateValue = DateTime.ParseExact(dateString, formats, CultureInfo "en-US", DateTimeStyles.None)
        printfn $"Converted '{dateString}' to {dateValue}."
    with :? FormatException ->
        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.
//       Unable to convert '08/28/2015 16:17:39.125' to a date.
//       Converted '08/28/2015 16:17:39.125000' to 8/28/2015 4:17:39 PM.

Imports System.Globalization

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",
                                 "MM/d/yyyy HH:mm:ss.ffffff" }
      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",
                                     "08/28/2015 16:17:39.125", "08/28/2015 16:17:39.125000" }

      Dim dateValue As DateTime
      
      For Each dateString As String In dateStrings
         Try
            dateValue = DateTime.ParseExact(dateString, formats, _
                                            New CultureInfo("en-US"), _
                                            DateTimeStyles.None)
            Console.WriteLine("Converted '{0}' to {1}.", dateString, dateValue)
         Catch e As FormatException
            Console.WriteLine("Unable to convert '{0}' to a date.", dateString)
         End Try                                               
      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.
'       Unable to convert '08/28/2015 16:17:39.125' to a date.
'       Converted '08/28/2015 16:17:39.125000' to 8/28/2015 4:17:39 PM.

Remarques

La DateTime.ParseExact(String, String[], IFormatProvider, DateTimeStyles) 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. Si la chaîne s ne correspond à aucun de ces modèles avec l’une des variantes définies par le styles paramètre, la méthode lève un FormatException. Outre la comparaison s à plusieurs modèles de mise en forme, plutôt qu’à un modèle de mise en forme unique, cette surcharge se comporte de façon identique à la DateTime.ParseExact(String, String, IFormatProvider, DateTimeStyles) méthode.

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.

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 .

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, `s`l’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 date et heure avec sa Kind propriété définie sur DateTimeKind.Local. Cet indicateur empêche principalement la conversion des heures UTC en heures locales.

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

Notes pour les appelants

Voir aussi

S’applique à

Commentaires

Cette page a-t-elle été utile ?

Partager via

DateTime.ParseExact Méthode

Définition

Surcharges

Remarques

ParseExact(String, String, IFormatProvider)

Paramètres

Retours

Exceptions

Exemples

Remarques

Notes pour les appelants

Voir aussi

S’applique à

ParseExact(ReadOnlySpan<Char>, ReadOnlySpan<Char>, IFormatProvider, DateTimeStyles)

Paramètres

Retours

S’applique à

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

Paramètres

Retours

S’applique à

ParseExact(String, String, IFormatProvider, DateTimeStyles)

Paramètres

Retours

Exceptions

Exemples

Remarques

Notes pour les appelants

Voir aussi

S’applique à

ParseExact(String, String[], IFormatProvider, DateTimeStyles)

Paramètres

Retours

Exceptions

Exemples

Remarques

Notes pour les appelants

Voir aussi

S’applique à

Commentaires