DateTime.ParseExact Méthode

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

Retours

DateTime

Objet qui équivaut à la date et à l'heure figurant dans s, comme spécifié par format et provider.

Exceptions

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.

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. Elle requiert également que les <Date> <Time> éléments et de la représentation sous forme de chaîne d’une date et d’une heure s’affichent dans l’ordre spécifié par format , et qui n' s ont pas d’espace blanc autre que celui autorisé par format . Si format définit une date sans élément d’heure et que l’opération d’analyse aboutit, la valeur résultante DateTime a une heure de minuit (00:00:00). Si format définit une heure sans élément de date et que l’opération d’analyse aboutit, la valeur résultante DateTime a une date de DateTime.Now.Date .

Si s ne représente pas une heure dans un fuseau horaire particulier et que l’opération d’analyse s’effectue correctement, la Kind propriété de la valeur retournée DateTime est DateTimeKind.Unspecified . Si s représente l’heure dans un fuseau horaire particulier et format autorise la présence d’informations de fuseau horaire (par exemple, si format est égal aux spécificateurs de format standard « o », « r » ou « u », ou s’il 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 soit un spécificateur de format standard unique, soit 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.

Les symboles et les 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 sont définis par le provider paramètre, tout 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 :

• CultureInfoObjet qui représente la culture utilisée pour interpréter s . L' DateTimeFormatInfo objet retourné par sa DateTimeFormat propriété définit les symboles et la mise en forme dans s .

• DateTimeFormatInfoObjet 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' CultureInfo objet ou l' DateTimeFormatInfo objet qui fournit les informations de mise en forme.

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

Notes pour les appelants

dans le .NET Framework 4, la ParseExact méthode lève une exception FormatException si la chaîne à analyser contient un composant heure et un indicateur AM/PM qui ne sont pas en accord. dans le .NET Framework 3,5 et les versions antérieures, l’indicateur AM/PM est ignoré.

Voir aussi

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

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

Retours

DateTime

Objet qui équivaut à la date et à l'heure figurant dans s, comme spécifié par format, provider et style.

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

Retours

DateTime

Objet qui équivaut à la date et à l'heure figurant dans s, comme spécifié par formats, provider et style.

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

Retours

DateTime

Objet qui équivaut à la date et à l'heure figurant dans s, comme spécifié par format, provider et style.

Exceptions

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 styles paramètre est égal DateTimeStyles.None à car les espaces de début ne sont pas autorisés par format . En outre, la chaîne « 5/01/2009 09:00 » ne peut pas être analysée correctement avec un format de « mm/jj/yyyyhh : mm », car la chaîne de date ne précède pas le numéro de mois avec un zéro non significatif, comme le format requiert.

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

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. Elle requiert également que les éléments de date et d’heure de s apparaissent dans l’ordre spécifié par format . Si s ne correspond pas au modèle du format paramètre, avec les variations définies par le style paramètre, la méthode lève une 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 format DateTimeFormatInfo . La DateTime.Parse(String, IFormatProvider, DateTimeStyles) méthode permet également aux éléments de date et d’heure dans s d’apparaître dans n’importe quel ordre.

Si le s paramètre contient uniquement une heure et aucune date, la date actuelle est utilisée, sauf si le style paramètre inclut l' DateTimeStyles.NoCurrentDateDefault indicateur, 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.

Si s ne contient pas d’informations de fuseau horaire, la Kind propriété de l' DateTime objet retourné est DateTimeKind.Unspecified . Ce comportement peut être modifié à l’aide de l' DateTimeStyles.AssumeLocal indicateur, qui retourne une DateTime valeur dont la Kind propriété a DateTimeKind.Local la valeur, ou à l’aide des DateTimeStyles.AssumeUniversal DateTimeStyles.AdjustToUniversal indicateurs et, qui retourne une DateTime valeur dont la Kind propriété a la valeur 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' DateTime objet retourné a la valeur DateTimeKind.Local . Ce comportement peut être modifié à l’aide de l' DateTimeStyles.RoundtripKind indicateur pour ne pas convertir le temps universel coordonné (UTC, Universal Time Coordinated) en heure locale et pour affecter à la propriété la valeur Kind DateTimeKind.Utc .

Le format paramètre définit le modèle requis du s paramètre. Il peut se composer d’un ou de plusieurs spécificateurs de format personnalisés du tableau de chaînes de format de date et d’heure personnalisé , ou d’un spécificateur de format standard unique, qui identifie un modèle prédéfini, à partir du tableau de 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 dite indifférente pour le provider paramètre et la forme la plus étendue de chaque spécificateur de format personnalisé. Par exemple, si vous souhaitez spécifier des heures dans le modèle, spécifiez la forme plus large, « HH », au lieu de la forme plus étroite, « H ».

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

Les symboles et les 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 sont définis par le provider paramètre, tout 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 :

• CultureInfoObjet qui représente la culture utilisée pour interpréter s . L' DateTimeFormatInfo objet retourné par sa DateTimeFormat propriété définit les symboles et la mise en forme dans s .

• DateTimeFormatInfoObjet 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' CultureInfo objet ou l' DateTimeFormatInfo objet qui fournit les informations de mise en forme.

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

Notes pour les appelants

dans le .NET Framework 4, la ParseExact méthode lève une exception FormatException si la chaîne à analyser contient un composant heure et un indicateur AM/PM qui ne sont pas en accord. dans le .NET Framework 3,5 et les versions antérieures, l’indicateur AM/PM est ignoré.

Voir aussi

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

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

Retours

DateTime

Objet qui équivaut à la date et à l'heure figurant dans s, comme spécifié par formats, provider et style.

Exceptions

Exemples

L’exemple suivant utilise la DateTime.ParseExact(String, String[], IFormatProvider, DateTimeStyles) méthode pour garantir 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.

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 affectés au formats paramètre. Si la chaîne s ne correspond à aucun de ces modèles avec l’une des variations définies par le styles paramètre, la méthode lève une FormatException . Outre la comparaison s à plusieurs modèles de mise en forme, plutôt qu’à un seul modèle de mise en forme, cette surcharge se comporte de la même façon que 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 contient uniquement une heure et aucune date, la date actuelle est utilisée, sauf si le style paramètre inclut l' DateTimeStyles.NoCurrentDateDefault indicateur, 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 ne contient pas d’informations de fuseau horaire, la Kind propriété de l' DateTime objet retourné est DateTimeKind.Unspecified . Ce comportement peut être modifié à l’aide de l' DateTimeStyles.AssumeLocal indicateur, qui retourne une DateTime valeur dont la Kind propriété a DateTimeKind.Local la valeur, ou à l’aide des DateTimeStyles.AssumeUniversal DateTimeStyles.AdjustToUniversal indicateurs et, qui retourne une DateTime valeur dont la Kind propriété a la valeur 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' DateTime objet retourné a la valeur DateTimeKind.Local . Ce comportement peut être modifié à l’aide de l' DateTimeStyles.RoundtripKind indicateur pour ne pas convertir le temps universel coordonné (UTC, Universal Time Coordinated) en heure locale et affecter à la propriété la valeur Kind DateTimeKind.Utc .

Le formats paramètre contient un tableau de modèles, dont l’un s doit correspondre exactement si l’opération d’analyse doit être effectuée correctement. Les modèles du formats paramètre se composent d’un ou de plusieurs spécificateurs de format personnalisés du tableau de chaînes de format de date et d’heure personnalisé , ou d’un spécificateur de format standard unique, qui identifie un modèle prédéfini, à partir du tableau de 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 dite indifférente pour le provider paramètre et la forme la plus étendue de chaque spécificateur de format personnalisé. Par exemple, si vous souhaitez spécifier des heures dans le modèle, spécifiez la forme plus large, « HH », au lieu de la forme plus étroite, « H ».

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

Les symboles et les 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 sont définis par le provider paramètre, tout 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 :

• CultureInfoObjet qui représente la culture utilisée pour interpréter s . L' DateTimeFormatInfo objet retourné par sa DateTimeFormat propriété définit les symboles et la mise en forme dans s .

• DateTimeFormatInfoObjet 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' CultureInfo objet ou l' DateTimeFormatInfo objet qui fournit les informations de mise en forme.

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

Notes pour les appelants

dans le .NET Framework 4, la ParseExact méthode lève une exception FormatException si la chaîne à analyser contient un composant heure et un indicateur AM/PM qui ne sont pas en accord. dans le .NET Framework 3,5 et les versions antérieures, l’indicateur AM/PM est ignoré.

Voir aussi

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