DateTime.Parse Méthode

Définition

Convertit la représentation sous forme de chaîne d'une date et d'une heure en son équivalent DateTime.Converts the string representation of a date and time to its DateTime equivalent.

Surcharges

Parse(String)

Convertit la représentation sous forme de chaîne d’une date/heure en son équivalent DateTime en utilisant les conventions de la culture du thread actuel.Converts the string representation of a date and time to its DateTime equivalent by using the conventions of the current thread culture.

Parse(String, IFormatProvider)

Convertit la représentation sous forme de chaîne d'une date et d'une heure en DateTime équivalent à l'aide des informations de format propres à la culture.Converts the string representation of a date and time to its DateTime equivalent by using culture-specific format information.

Parse(ReadOnlySpan<Char>, IFormatProvider, DateTimeStyles)

Convertit une étendue de mémoire contenant la représentation sous forme de chaîne d’une date/heure en son équivalent DateTime en utilisant les informations de format propres à la culture et un style de mise en forme.Converts a memory span that contains string representation of a date and time to its DateTime equivalent by using culture-specific format information and a formatting style.

Parse(String, IFormatProvider, DateTimeStyles)

Convertit la représentation sous forme de chaîne d’une date/heure en son équivalent DateTime en utilisant les informations de format propres à la culture et un style de mise en forme.Converts the string representation of a date and time to its DateTime equivalent by using culture-specific format information and a formatting style.

Exemples

De nombreux exemples qui appellent la méthode DateTime.Parse sont intercalés dans la section Notes de cet article et dans la documentation pour les surcharges DateTime.Parse individuelles.Numerous examples that call the DateTime.Parse method are interspersed throughout the Remarks section of this article and in the documentation for the individual DateTime.Parse overloads.

Notes

Certains exemples C# de cet article s’exécutent dans l’exécuteur et le terrain de jeu du code inline Try.NET.Some C# examples in this article run in the Try.NET inline code runner and playground. Sélectionnez le bouton Exécuter pour exécuter un exemple dans une fenêtre interactive.Select the Run button to run an example in an interactive window. Une fois que vous avez exécuté le code, vous pouvez le modifier et exécuter le code modifié en resélectionnant Exécuter.Once you execute the code, you can modify it and run the modified code by selecting Run again. La code modifié s’exécute dans la fenêtre interactive ou, si la compilation échoue, la fenêtre interactive affiche tous les messages d’erreur du compilateur C#.The modified code either runs in the interactive window or, if compilation fails, the interactive window displays all C# compiler error messages.

Le fuseau horaire local de l’exécuteur de code en ligne et du terrain de jeu inline Try.NET est le temps universel coordonné, ou UTC.The local time zone of the Try.NET inline code runner and playground is Coordinated Universal Time, or UTC. Cela peut affecter le comportement et la sortie d’exemples qui illustrent les types DateTime, DateTimeOffset et TimeZoneInfo ainsi que leurs membres.This may affect the behavior and the output of examples that illustrate the DateTime, DateTimeOffset, and TimeZoneInfo types and their members.

Vous pouvez également télécharger un ensemble complet d’exemples DateTime.Parse, qui sont inclus dans un projet .net Core 2,0 pour C# et un projet .net Core 2,0 pour Visual Basic, à partir du référentiel GitHub dotnet/Samples.You can also download a complete set of DateTime.Parse examples, which are included in a .NET Core 2.0 project for C# and a .NET Core 2.0 project for Visual Basic, from the dotnet/samples GitHub repository.

Remarques

Dans cette section :In this section:

Quelle méthode appelle-t-elle ?Which method do I call?

ÀTo CallCall
Analyser une chaîne de date et d’heure à l’aide des conventions de la culture actuelle.Parse a date and time string by using the conventions of the current culture. Parse(String) surchargeParse(String) overload
Analyser une chaîne de date et d’heure à l’aide des conventions d’une culture spécifique.Parse a date and time string by using the conventions of a specific culture. surcharge Parse(String, IFormatProvider) (voir la section analyse et conventions culturelles)Parse(String, IFormatProvider) overload (see Parsing and Cultural Conventions)
Analyser une chaîne de date et d’heure avec des éléments de style spéciaux (tels qu’un espace blanc ou aucun espace blanc).Parse a date and time string with special style elements (such as white space or no white space). Parse(String, IFormatProvider, DateTimeStyles) surchargeParse(String, IFormatProvider, DateTimeStyles) overload
Analyser une chaîne de date et d’heure qui doit être dans un format particulier.Parse a date and time string that must be in a particular format. DateTime.ParseExact ou DateTime.TryParseExactDateTime.ParseExact or DateTime.TryParseExact
Analyser une chaîne de date et d’heure et effectuer une conversion en heure UTC ou locale.Parse a date and time string and perform a conversion to UTC or local time. Parse(String, IFormatProvider, DateTimeStyles) surchargeParse(String, IFormatProvider, DateTimeStyles) overload
Analyser une chaîne de date et d’heure sans gérer les exceptions.Parse a date and time string without handling exceptions. Méthode DateTime.TryParseDateTime.TryParse method
Restore (aller-retour) une valeur de date et d’heure créée par une opération de mise en forme.Restore (round-trip) a date and time value created by a formatting operation. Transmettez la chaîne de format standard "o" ou "r" à la méthode ToString(String), puis appelez la surcharge Parse(String, IFormatProvider, DateTimeStyles) avec DateTimeStyles.RoundtripKindPass the "o" or "r" standard format string to the ToString(String) method, and call the Parse(String, IFormatProvider, DateTimeStyles) overload with DateTimeStyles.RoundtripKind
Analyser une chaîne de date et d’heure dans un format fixe à travers les limites de l’ordinateur (et éventuellement de la culture).Parse a date and time string in a fixed format across machine (and possibly cultural) boundaries. méthode DateTime.ParseExact ou DateTime.TryParseExactDateTime.ParseExact or DateTime.TryParseExact method

Chaîne à analyserThe string to parse

La méthode Parse tente de convertir la représentation sous forme de chaîne d’une valeur de date et d’heure en son équivalent DateTime.The Parse method tries to convert the string representation of a date and time value to its DateTime equivalent. Elle tente d’analyser complètement la chaîne d’entrée sans lever d’exception FormatException.It tries to parse the input string completely without throwing a FormatException exception.

Important

Si l’opération d’analyse échoue en raison d’un format de chaîne non reconnu, la méthode Parse lève une FormatException, tandis que la méthode TryParse retourne false.If the parsing operation fails because of an unrecognized string format, the Parse method throws a FormatException, whereas the TryParse method returns false. Étant donné que la gestion des exceptions peut être coûteuse, vous devez utiliser Parse lorsque l’opération d’analyse est supposée être effectuée, car la source d’entrée est approuvée.Because exception handling can be expensive, you should use Parse when the parsing operation is expected to succeed because the input source is trusted. TryParse est préférable lorsque les échecs d’analyse sont probables, en particulier parce qu’une source d’entrée n’est pas approuvée, ou que vous avez des valeurs par défaut raisonnables à substituer pour les chaînes qui ne sont pas analysées correctement.TryParse is preferable when parsing failures are likely, particularly because an input source is not trusted, or you have reasonable default values to substitute for strings that do not parse successfully.

La chaîne à analyser peut prendre l’une des formes suivantes :The string to be parsed can take any of the following forms:

  • Chaîne avec un composant de date et d’heure.A string with a date and a time component.

  • Chaîne avec un composant date, mais sans heure.A string with a date but no time component. Si le composant heure est absent, la méthode suppose 12:00 minuit.If the time component is absent, the method assumes 12:00 midnight. Si le composant de date a une année à deux chiffres, il est converti en une année basée sur la Calendar.TwoDigitYearMax du calendrier actuel de la culture actuelle ou du calendrier actuel de la culture spécifiée (si vous utilisez une surcharge avec un argument provider non null).If the date component has a two-digit year, it is converted to a year based on the Calendar.TwoDigitYearMax of the current culture's current calendar or the specified culture's current calendar (if you use an overload with a non-null provider argument).

  • Chaîne avec un composant date qui comprend uniquement le composant month et l’année, mais pas le jour.A string with a date component that includes only the month and the year but no day component. La méthode suppose le premier jour du mois.The method assumes the first day of the month.

  • Chaîne avec un composant de date qui comprend uniquement le mois et le jour, mais pas le composant d’année.A string with a date component that includes only the month and the day but no year component. La méthode suppose l’année en cours.The method assumes the current year.

  • Chaîne avec une heure mais sans composant de date.A string with a time but no date component. La méthode suppose la date actuelle, sauf si vous appelez la surcharge Parse(String, IFormatProvider, DateTimeStyles) et incluez DateTimeStyles.NoCurrentDateDefault dans l’argument styles, auquel cas la méthode suppose une date du 1er janvier 0001.The method assumes the current date unless you call the Parse(String, IFormatProvider, DateTimeStyles) overload and include DateTimeStyles.NoCurrentDateDefault in the styles argument, in which case the method assumes a date of January 1, 0001.

  • Chaîne avec un composant d’heure qui comprend uniquement l’heure et un indicateur AM/PM, sans composant de date.A string with a time component that includes only the hour and an AM/PM designator, with no date component. La méthode utilise la date et l’heure actuelles sans aucune minute ni aucune seconde.The method assumes the current date and a time with no minutes and no seconds. Vous pouvez modifier ce comportement en appelant la surcharge Parse(String, IFormatProvider, DateTimeStyles) et inclure DateTimeStyles.NoCurrentDateDefault dans l’argument styles, auquel cas la méthode suppose une date du 1er janvier 0001.You can change this behavior by calling the Parse(String, IFormatProvider, DateTimeStyles) overload and include DateTimeStyles.NoCurrentDateDefault in the styles argument, in which case the method assumes a date of January 1, 0001.

  • Chaîne qui comprend les informations de fuseau horaire et est conforme à la norme ISO 8601.A string that includes time zone information and conforms to ISO 8601. Dans les exemples suivants, la première chaîne désigne le temps universel coordonné (UTC, Universal Time Coordinated), tandis que la seconde désigne l’heure dans un fuseau horaire qui est sept heures avant l’heure UTC :In the following examples, the first string designates Coordinated Universal Time (UTC), and the second designates the time in a time zone that's seven hours earlier than UTC:

    « 2008-11-01T19:35:00.0000000 Z »"2008-11-01T19:35:00.0000000Z"
    « 2008-11-01T19:35:00.0000000-07:00 »"2008-11-01T19:35:00.0000000-07:00"

  • Chaîne qui comprend l’indicateur GMT et est conforme au format d’heure RFC 1123. par exemple :A string that includes the GMT designator and conforms to the RFC 1123 time format; for example:

    « Sat, 01 novembre 2008 19:35:00 GMT »"Sat, 01 Nov 2008 19:35:00 GMT"

  • Chaîne qui contient la date et l’heure, ainsi que les informations de décalage de fuseau horaire ; par exemple :A string that includes the date and time along with time zone offset information; for example:

    "03/01/2009 05:42:00 -5:00""03/01/2009 05:42:00 -5:00"

L’exemple suivant analyse des chaînes dans chacun de ces formats à l’aide des conventions de mise en forme de la culture actuelle, qui dans ce cas est la culture en-US :The following example parses strings in each of these formats by using the formatting conventions of the current culture, which in this case is the en-US culture:

using System;

public class Example
{
   public static void Main()
   {
      (string dateAsString, string description)[]  dateInfo = { ("08/18/2018 07:22:16", "String with a date and time component"),                             
                                                                ("08/18/2018", "String with a date component only"),
                                                                ("8/2018", "String with a month and year component only"),
                                                                ("8/18", "String with a month and day component only"),
                                                                ("07:22:16", "String with a time component only"),
                                                                ("7 PM", "String with an hour and AM/PM designator only"),
                                                                ("2018-08-18T07:22:16.0000000Z", "UTC string that conforms to ISO 8601"),   
                                                                ("2018-08-18T07:22:16.0000000-07:00", "Non-UTC string that conforms to ISO 8601"),
                                                                ("Sat, 18 Aug 2018 07:22:16 GMT", "String that conforms to RFC 1123"),
                                                                ("08/18/2018 07:22:16 -5:00", "String with date, time, and time zone information" ) };
   
      Console.WriteLine($"Today is {DateTime.Now:d}\n");
      
      foreach (var item in dateInfo) {
         Console.WriteLine($"{item.description + ":",-52} '{item.dateAsString}' --> {DateTime.Parse(item.dateAsString)}");        
      }
   }
}
// The example displays output like the following:
//   Today is 2/22/2018
//   
//   String with a date and time component:               '08/18/2018 07:22:16' --> 8/18/2018 7:22:16 AM
//   String with a date component only:                   '08/18/2018' --> 8/18/2018 12:00:00 AM
//   String with a month and year component only:         '8/2018' --> 8/1/2018 12:00:00 AM
//   String with a month and day component only:          '8/18' --> 8/18/2018 12:00:00 AM
//   String with a time component only:                   '07:22:16' --> 2/22/2018 7:22:16 AM
//   String with an hour and AM/PM designator only:       '7 PM' --> 2/22/2018 7:00:00 PM
//   UTC string that conforms to ISO 8601:                '2018-08-18T07:22:16.0000000Z' --> 8/18/2018 12:22:16 AM
//   Non-UTC string that conforms to ISO 8601:            '2018-08-18T07:22:16.0000000-07:00' --> 8/18/2018 7:22:16 AM
//   String that conforms to RFC 1123:                    'Sat, 18 Aug 2018 07:22:16 GMT' --> 8/18/2018 12:22:16 AM
//   String with date, time, and time zone information:   '08/18/2018 07:22:16 -5:00' --> 8/18/2018 5:22:16 AM


Public Module Strings
   Public Sub Main()
      Dim dateInfo() As (dateAsString As String, description As String) = 
                     { ("08/18/2018 07:22:16", "String with a date and time component"),
                       ("08/18/2018", "String with a date component only"),
                       ("8/2018", "String with a month and year component only"),
                       ("8/18", "String with a month and day component only"),
                       ("07:22:16", "String with a time component only"),
                       ("7 PM", "String with an hour and AM/PM designator only"),
                       ("2018-08-18T07:22:16.0000000Z", "UTC string that conforms to ISO 8601"),   
                       ("2018-08-18T07:22:16.0000000-07:00", "Non-UTC string that conforms to ISO 8601"),
                       ("Sat, 18 Aug 2018 07:22:16 GMT", "String that conforms to RFC 1123"),
                       ("08/18/2018 07:22:16 -5:00", "String with date, time, and time zone information" ) }
   
      Console.WriteLine($"Today is {Date.Now:d}{vbCrLf}")
      
      For Each item in dateInfo
         Console.WriteLine($"{item.description + ":",-52} '{item.dateAsString}' --> {DateTime.Parse(item.dateAsString)}")        
      Next
   End Sub
End Module
' The example displays output like the following:
'   Today is 2/22/2018
'   
'   String with a date and time component:               '08/18/2018 07:22:16' --> 8/18/2018 7:22:16 AM
'   String with a date component only:                   '08/18/2018' --> 8/18/2018 12:00:00 AM
'   String with a month and year component only:         '8/2018' --> 8/1/2018 12:00:00 AM
'   String with a month and day component only:          '8/18' --> 8/18/2018 12:00:00 AM
'   String with a time component only:                   '07:22:16' --> 2/22/2018 7:22:16 AM
'   String with an hour and AM/PM designator only:       '7 PM' --> 2/22/2018 7:00:00 PM
'   UTC string that conforms to ISO 8601:                '2018-08-18T07:22:16.0000000Z' --> 8/18/2018 12:22:16 AM
'   Non-UTC string that conforms to ISO 8601:            '2018-08-18T07:22:16.0000000-07:00' --> 8/18/2018 7:22:16 AM
'   String that conforms to RFC 1123:                    'Sat, 18 Aug 2018 07:22:16 GMT' --> 8/18/2018 12:22:16 AM
'   String with date, time, and time zone information:   '08/18/2018 07:22:16 -5:00' --> 8/18/2018 5:22:16 AM

Si la chaîne d’entrée représente un jour d’une année bissextile dans le calendrier utilisé par la méthode d’analyse (voir la section analyse et conventions culturelles), la méthode Parse analyse la chaîne avec succès.If the input string represents a leap day in a leap year in the calendar used by the parsing method (see Parsing and cultural conventions), the Parse method parses the string successfully. Si la chaîne d’entrée représente un jour d’une année bissextile dans une année non bissextile, la méthode lève une FormatException.If the input string represents a leap day in a non-leap year, the method throws a FormatException.

Étant donné que la méthode Parse tente d’analyser la représentation sous forme de chaîne d’une date et d’une heure à l’aide des règles de mise en forme de la culture actuelle ou d’une culture spécifiée, la tentative d’analyse d’une chaîne entre différentes cultures peut échouer.Because the Parse method tries to parse the string representation of a date and time by using the formatting rules of the current or a specified culture, trying to parse a string across different cultures can fail. Pour analyser un format de date et d’heure spécifique sur différents paramètres régionaux, utilisez l’une des surcharges de la méthode DateTime.ParseExact et fournissez un spécificateur de format.To parse a specific date and time format across different locales, use one of the overloads of the DateTime.ParseExact method and provide a format specifier.

Analyse et conventions culturellesParsing and cultural conventions

Toutes les surcharges de la méthode Parse sont dépendantes de la culture, à moins que la chaîne à analyser (représentée par s dans le tableau suivant) soit conforme au modèle ISO 8601.All overloads of the Parse method are culture-sensitive unless the string to be parsed (which is represented by s in the following table) conforms to the ISO 8601 pattern. L’opération d’analyse utilise les informations de mise en forme d’un objet DateTimeFormatInfo qui est dérivé comme suit :The parsing operation uses the formatting information in a DateTimeFormatInfo object that is derived as follows:

Important

Les ères des calendriers japonais sont basées sur le règne de l’empereur et sont donc amenées à changer.Eras in the Japanese calendars are based on the emperor's reign and are therefore expected to change. Par exemple, le 1 mai 2019 a marqué le début de l’ère Reiwa dans JapaneseCalendar et JapaneseLunisolarCalendar.For example, May 1, 2019 marked the beginning of the Reiwa era in the JapaneseCalendar and JapaneseLunisolarCalendar. Ce changement d’ère affecte toutes les applications qui utilisent ces calendriers.Such a change of era affects all applications that use these calendars. Pour plus d’informations et pour déterminer si vos applications sont affectées, consultez Handling a new era in the Japanese calendar in .NET.See Handling a new era in the Japanese calendar in .NET for more information and to determine whether your applications are affected. Pour plus d’informations sur le test de vos applications sur les systèmes Windows pour garantir leur préparation au changement d’ère, consultez Préparer votre application au changement de l’ère japonaise.See Prepare your application for the Japanese era change for information on testing your applications on Windows systems to ensure their readiness for the era change. Consultez Utilisation des ères pour connaître les fonctionnalités de .NET qui prennent en charge les calendriers avec plusieurs ères et les bonnes pratiques d’utilisation de ce type de calendrier.See Working with eras for features in .NET that support calendars with multiple eras and for best practices when working with calendars that support multiple eras.

Si vous appelezIf you call Et provider estAnd provider is Les informations de mise en forme sont dérivées deFormatting information is derived from
Parse(String) - Culture du thread actuel (propriété DateTimeFormatInfo.CurrentInfo)The current thread culture (DateTimeFormatInfo.CurrentInfo property)
Parse(String, IFormatProvider) ou Parse(String, IFormatProvider, DateTimeStyles)Parse(String, IFormatProvider) or Parse(String, IFormatProvider, DateTimeStyles) objet DateTimeFormatInfoa DateTimeFormatInfo object Objet DateTimeFormatInfo spécifiéThe specified DateTimeFormatInfo object
Parse(String, IFormatProvider) ou Parse(String, IFormatProvider, DateTimeStyles)Parse(String, IFormatProvider) or Parse(String, IFormatProvider, DateTimeStyles) null Culture du thread actuel (propriété DateTimeFormatInfo.CurrentInfo)The current thread culture (DateTimeFormatInfo.CurrentInfo property)
Parse(String, IFormatProvider) ou Parse(String, IFormatProvider, DateTimeStyles)Parse(String, IFormatProvider) or Parse(String, IFormatProvider, DateTimeStyles) objet CultureInfoa CultureInfo object La propriété CultureInfo.DateTimeFormatThe CultureInfo.DateTimeFormat property
Parse(String, IFormatProvider) ou Parse(String, IFormatProvider, DateTimeStyles)Parse(String, IFormatProvider) or Parse(String, IFormatProvider, DateTimeStyles) Implémentation IFormatProvider personnaliséeCustom IFormatProvider implementation Méthode IFormatProvider.GetFormatThe IFormatProvider.GetFormat method

Lorsque les informations de mise en forme sont dérivées d’un objet DateTimeFormatInfo, la propriété DateTimeFormatInfo.Calendar définit le calendrier utilisé dans l’opération d’analyse.When formatting information is derived from a DateTimeFormatInfo object, the DateTimeFormatInfo.Calendar property defines the calendar used in the parsing operation.

Si vous analysez une chaîne de date et d’heure à l’aide d’un objet DateTimeFormatInfo avec des paramètres personnalisés qui sont différents de ceux d’une culture standard, utilisez la méthode ParseExact au lieu de la méthode Parse pour améliorer les chances de réussite de la conversion.If you parse a date and time string by using a DateTimeFormatInfo object with customized settings that are different from those of a standard culture, use the ParseExact method instead of the Parse method to improve the chances for a successful conversion. Une chaîne de date et d’heure non standard peut être compliquée et difficile à analyser.A non-standard date and time string can be complicated and difficult to parse. La méthode Parse tente d’analyser une chaîne avec plusieurs modèles d’analyse implicite, qui peuvent tous échouer.The Parse method tries to parse a string with several implicit parse patterns, all of which might fail. En revanche, la méthode ParseExact vous oblige à désigner explicitement un ou plusieurs modèles d’analyse exacts susceptibles d’être correctement exécutés.In contrast, the ParseExact method requires you to explicitly designate one or more exact parse patterns that are likely to succeed. Pour plus d’informations, consultez la section « DateTimeFormatInfo et Dynamic Data » dans la rubrique DateTimeFormatInfo.For more information, see the "DateTimeFormatInfo and Dynamic Data" section in the DateTimeFormatInfo topic.

Important

Notez que les conventions de mise en forme d’une culture particulière sont dynamiques et peuvent faire l’objet de modifications.Note that the formatting conventions for a particular culture are dynamic and can be subject to change. Cela signifie que les opérations d’analyse qui dépendent des conventions de mise en forme de la culture par défaut (actuelle) ou qui spécifient un objet IFormatProvider représentant une culture autre que la culture dite indifférente peuvent échouer de façon inattendue si l’une des conditions suivantes se produit :This means that parsing operations that depend on the formatting conventions of the default (current) culture or that specify an IFormatProvider object that represents a culture other than the invariant culture can unexpectedly fail if any of the following occurs:

  • Les données spécifiques à la culture ont changé entre les versions majeures ou mineures du .NET Framework ou à la suite d’une mise à jour de la version existante du .NET Framework.The culture-specific data has changed between major or minor versions of the .NET Framework or as the result of an update to the existing version of the .NET Framework.
  • Les données spécifiques à la culture reflètent les préférences de l’utilisateur, qui peuvent varier d’un ordinateur à l’ordinateur ou d’une session à l’autres.The culture-specific data reflects user preferences, which can vary from machine to machine or session to session.
  • Les données spécifiques à la culture représentent une culture de remplacement qui remplace les paramètres d’une culture standard ou d’une culture personnalisée.The culture-specific data represents a replacement culture that overrides the settings of a standard culture or a custom culture.

Pour éviter les difficultés liées à l’analyse des données et des chaînes de temps associées aux modifications apportées aux données culturelles, vous pouvez analyser les chaînes de date et d’heure à l’aide de la culture dite indifférente, ou vous pouvez appeler la méthode ParseExact ou TryParseExact et spécifier le format exact de la chaîne à analyser.To prevent the difficulties in parsing data and time strings that are associated with changes in cultural data, you can parse date and time strings by using the invariant culture, or you can call the ParseExact or TryParseExact method and specify the exact format of the string to be parsed. Si vous sérialisez et désérialisez des données de date et d’heure, vous pouvez utiliser les conventions de mise en forme de la culture dite indifférente, ou vous pouvez sérialiser et désérialiser la valeur DateTime dans un format binaire.If you are serializing and deserializing date and time data, you can either use the formatting conventions of the invariant culture, or you can serialize and deserialize the DateTime value in a binary format.

Pour plus d’informations, consultez la section « données de culture dynamique » dans la rubrique CultureInfo et la section « persistance des valeurs DateTime » dans la rubrique DateTime.For more information see the "Dynamic culture data" section in the CultureInfo topic and the "Persisting DateTime values" section in the DateTime topic.

Analyse et éléments de styleParsing and style elements

Toutes les surcharges Parse ignorent les espaces blancs de début, internes ou de fin dans la chaîne d’entrée (représentée par s dans le tableau suivant).All Parse overloads ignore leading, inner, or trailing white-space characters in the input string (which is represented by s in the following table). La date et l’heure peuvent être placées entre des signes dièse (« # », U + 0023) et un ou plusieurs caractères NULL (U + 0000) peuvent être placés entre crochets.The date and time can be bracketed with a pair of leading and trailing NUMBER SIGN characters ("#", U+0023), and can be trailed with one or more NULL characters (U+0000).

En outre, la surcharge Parse(String, IFormatProvider, DateTimeStyles) a un paramètre styles qui se compose d’un ou de plusieurs membres de l’énumération DateTimeStyles.In addition, the Parse(String, IFormatProvider, DateTimeStyles) overload has a styles parameter that consists of one or more members of the DateTimeStyles enumeration. Ce paramètre définit comment s doit être interprété et comment l’opération d’analyse doit convertir s en une date et une heure.This parameter defines how s should be interpreted and how the parse operation should convert s to a date and time. Le tableau suivant décrit l’effet de chaque membre DateTimeStyles sur l’opération d’analyse.The following table describes the effect of each DateTimeStyles member on the parse operation.

Membre DateTimeStylesDateTimeStyles member Effet lors de la conversionEffect on conversion
AdjustToUniversal Analyse s et, si nécessaire, le convertit en heure UTC, comme suit :Parses s and, if necessary, converts it to UTC, as follows:

-Si s inclut un décalage de fuseau horaire, ou si s ne contient aucune information de fuseau horaire, mais que styles inclut l’indicateur AssumeLocal, la méthode analyse la chaîne, appelle ToUniversalTime pour convertir la valeur DateTime retournée en heure UTC et définit la propriété Kind sur DateTimeKind.Utc.- If s includes a time zone offset, or if s contains no time zone information but styles includes the AssumeLocal flag, the method parses the string, calls ToUniversalTime to convert the returned DateTime value to UTC, and sets the Kind property to DateTimeKind.Utc.
-Si s indique qu’il représente l’heure UTC, ou si s ne contient pas d’informations de fuseau horaire mais que styles comprend l’indicateur AssumeUniversal, la méthode analyse la chaîne, n’effectue aucune conversion de fuseau horaire sur la valeur DateTime retournée et définit la Kind propriété à DateTimeKind.Utc.- If s indicates that it represents UTC, or if s does not contain time zone information but styles includes the AssumeUniversal flag, the method parses the string, performs no time zone conversion on the returned DateTime value, and sets the Kind property to DateTimeKind.Utc.
-Dans tous les autres cas, l’indicateur n’a aucun effet.- In all other cases, the flag has no effect.
AllowInnerWhite Cette valeur est ignorée.This value is ignored. L’espace blanc interne est toujours autorisé dans les éléments de date et d’heure de s.Inner white space is always permitted in the date and time elements of s.
AllowLeadingWhite Cette valeur est ignorée.This value is ignored. L’espace blanc de début est toujours autorisé dans les éléments de date et d’heure de s.Leading white space is always permitted in the date and time elements of s.
AllowTrailingWhite Cette valeur est ignorée.This value is ignored. Les espaces de fin sont toujours autorisés dans les éléments de date et d’heure de s.Trailing white space is always permitted in the date and time elements of s.
AllowWhiteSpaces Spécifie que s peut contenir des espaces blancs de début, internes et de fin.Specifies that s may contain leading, inner, and trailing white spaces. Il s'agit du comportement par défaut.This is the default behavior. Il ne peut pas être substitué en fournissant une valeur d’énumération DateTimeStyles plus restrictive comme None.It cannot be overridden by supplying a more restrictive DateTimeStyles enumeration value such as None.
AssumeLocal Spécifie que si s ne dispose d’aucune information de fuseau horaire, l’heure locale est utilisée par défaut.Specifies that if s lacks any time zone information, local time is assumed. À moins que l’indicateur AdjustToUniversal soit présent, la propriété Kind de la valeur DateTime retournée est définie sur DateTimeKind.Local.Unless the AdjustToUniversal flag is present, the Kind property of the returned DateTime value is set to DateTimeKind.Local.
AssumeUniversal Spécifie que si s ne dispose d’aucune information de fuseau horaire, l’heure UTC est supposée.Specifies that if s lacks any time zone information, UTC is assumed. À moins que l’indicateur AdjustToUniversal soit présent, la méthode convertit la valeur DateTime retournée de l’heure UTC en heure locale et définit sa propriété Kind sur DateTimeKind.Local.Unless the AdjustToUniversal flag is present, the method converts the returned DateTime value from UTC to local time and sets its Kind property to DateTimeKind.Local.
None Bien que valide, cette valeur est ignorée.Although valid, this value is ignored.
RoundtripKind Pour les chaînes qui contiennent des informations de fuseau horaire, tente d’empêcher la conversion d’une chaîne de date et d’heure en une valeur DateTime qui représente une heure locale avec sa propriété Kind définie sur DateTimeKind.Local.For strings that contain time zone information, tries to prevent the conversion of a date and time string to a DateTime value that represents a local time with its Kind property set to DateTimeKind.Local. En général, une telle chaîne est créée en appelant la méthode DateTime.ToString(String) et en utilisant le spécificateur de format standard « o », « r » ou « u ».Typically, such a string is created by calling the DateTime.ToString(String) method and by using the "o", "r", or "u" standard format specifier.

La valeur de retour et DateTime. KindThe return value and DateTime.Kind

Les surcharges DateTime.Parse retournent une valeur DateTime dont la propriété Kind comprend des informations sur les fuseaux horaires.The DateTime.Parse overloads return a DateTime value whose Kind property includes time zone information. Il peut indiquer que l’heure est :It can indicate that the time is:

En règle générale, la méthode Parse retourne un objet DateTime dont la propriété Kind est DateTimeKind.Unspecified.Generally, the Parse method returns a DateTime object whose Kind property is DateTimeKind.Unspecified. Toutefois, la méthode Parse peut également effectuer une conversion de fuseau horaire et définir différemment la valeur de la propriété Kind, selon les valeurs des paramètres s et styles :However, the Parse method may also perform time zone conversion and set the value of the Kind property differently, depending on the values of the s and styles parameters:

IfIf Conversion de fuseau horaireTime zone conversion Kind, propriétéKind property
s contient des informations sur les fuseaux horaires.s contains time zone information. La date et l’heure sont converties en heure du fuseau horaire local.The date and time is converted to the time in the local time zone. DateTimeKind.Local
s contient des informations sur les fuseaux horaires, et styles inclut l’indicateur AdjustToUniversal.s contains time zone information, and styles includes the AdjustToUniversal flag. La date et l’heure sont converties en temps universel coordonné (UTC).The date and time is converted to Coordinated Universal Time (UTC). DateTimeKind.Utc
s contient l’indicateur de fuseau horaire Z ou GMT, et styles inclut l’indicateur RoundtripKind.s contains the Z or GMT time zone designator, and styles includes the RoundtripKind flag. La date et l’heure sont interprétées en tant que temps universel coordonné (UTC).The date and time are interpreted as UTC. DateTimeKind.Utc

L’exemple suivant convertit les chaînes de date qui contiennent les informations de fuseau horaire en heure dans le fuseau horaire local :The following example converts date strings that contain time zone information to the time in the local time zone:

using System;

public class Example
{
   public static void Main()
   {
      string[] dateStrings = {"2008-05-01T07:34:42-5:00", 
                              "2008-05-01 7:34:42Z", 
                              "Thu, 01 May 2008 07:34:42 GMT"};
      foreach (string dateString in dateStrings)
      {
         DateTime convertedDate = DateTime.Parse(dateString);
         Console.WriteLine($"Converted {dateString} to {convertedDate.Kind} time {convertedDate}");
      }                              
   }
}
// These calls to the DateTime.Parse method display the following output:
//  Converted 2008-05-01T07:34:42-5:00 to Local time 5/1/2008 5:34:42 AM
//  Converted 2008-05-01 7:34:42Z to Local time 5/1/2008 12:34:42 AM
//  Converted Thu, 01 May 2008 07:34:42 GMT to Local time 5/1/2008 12:34:42 AM                                             
Module Example
   Public Sub Main()
      Dim dateStrings() As String = {"2008-05-01T07:34:42-5:00", 
                                     "2008-05-01 7:34:42Z", 
                                     "Thu, 01 May 2008 07:34:42 GMT"}
      
      For Each dateStr In dateStrings
         Dim convertedDate As Date = Date.Parse(dateStr)
         Console.WriteLine($"Converted {dateStr} to {convertedDate.Kind} time {convertedDate}")
      Next 
   End Sub
End Module
' These calls to the DateTime.Parse method display the following output:
'   Converted 2008-05-01T07:34:42-5:00 to Local time 5/1/2008 5:34:42 AM
'   Converted 2008-05-01 7:34:42Z to Local time 5/1/2008 12:34:42 AM
'   Converted Thu, 01 May 2008 07:34:42 GMT to Local time 5/1/2008 12:34:42 AM                                             

Vous pouvez également conserver la valeur de la propriété Kind d’une date et d’une heure au cours d’une opération de mise en forme et d’analyse à l’aide de l’indicateur DateTimeStyles.RoundtripKind.You can also preserve the value of a date and time's Kind property during a formatting and parsing operation by using the DateTimeStyles.RoundtripKind flag. L’exemple suivant montre comment l’indicateur RoundtripKind affecte l’opération d’analyse sur les valeurs DateTime qui sont converties en chaînes à l’aide du spécificateur de format "o", "r" ou "u".The following example illustrates how the RoundtripKind flag affects the parsing operation on DateTime values that are converted to strings by using the "o", "r", or "u" format specifier.

   string[] formattedDates = { "2008-09-15T09:30:41.7752486-07:00", 
                               "2008-09-15T09:30:41.7752486Z",  
                               "2008-09-15T09:30:41.7752486",  
                               "2008-09-15T09:30:41.7752486-04:00", 
                               "Mon, 15 Sep 2008 09:30:41 GMT" };
   foreach (string formattedDate in formattedDates)
   {
      Console.WriteLine(formattedDate);
      DateTime roundtripDate = DateTime.Parse(formattedDate, null, 
                                              DateTimeStyles.RoundtripKind);                        
      Console.WriteLine($"   With RoundtripKind flag: {roundtripDate} {roundtripDate.Kind} time.");
   
      DateTime noRoundtripDate = DateTime.Parse(formattedDate, null, 
                                                DateTimeStyles.None);
      Console.WriteLine($"   Without RoundtripKind flag: {noRoundtripDate} {noRoundtripDate.Kind} time.");
   }         
// The example displays the following output:
//       2008-09-15T09:30:41.7752486-07:00
//          With RoundtripKind flag: 9/15/2008 9:30:41 AM Local time.
//          Without RoundtripKind flag: 9/15/2008 9:30:41 AM Local time.
//       2008-09-15T09:30:41.7752486Z
//          With RoundtripKind flag: 9/15/2008 9:30:41 AM Utc time.
//          Without RoundtripKind flag: 9/15/2008 2:30:41 AM Local time.
//       2008-09-15T09:30:41.7752486
//          With RoundtripKind flag: 9/15/2008 9:30:41 AM Unspecified time.
//          Without RoundtripKind flag: 9/15/2008 9:30:41 AM Unspecified time.
//       2008-09-15T09:30:41.7752486-04:00
//          With RoundtripKind flag: 9/15/2008 6:30:41 AM Local time.
//          Without RoundtripKind flag: 9/15/2008 6:30:41 AM Local time.
//       Mon, 15 Sep 2008 09:30:41 GMT
//          With RoundtripKind flag: 9/15/2008 9:30:41 AM Utc time.
//          Without RoundtripKind flag: 9/15/2008 2:30:41 AM Local time.      
Dim formattedDates() = { "2008-09-15T09:30:41.7752486-07:00", 
                           "2008-09-15T09:30:41.7752486Z",  
                           "2008-09-15T09:30:41.7752486",  
                           "2008-09-15T09:30:41.7752486-04:00", 
                           "Mon, 15 Sep 2008 09:30:41 GMT" }
For Each formattedDate In formattedDates
   Console.WriteLine(formattedDate)
   Dim roundtripDate = DateTime.Parse(formattedDate, Nothing,  
                                      DateTimeStyles.RoundtripKind)                        
   Console.WriteLine($"   With RoundtripKind flag: {roundtripDate} {roundtripDate.Kind} time.")                                          
   Dim noRoundtripDate = DateTime.Parse(formattedDate, Nothing,                                                                                                  DateTimeStyles.None)
   Console.WriteLine($"   Without RoundtripKind flag: {noRoundtripDate} {noRoundtripDate.Kind} time.")
Next         
' The example displays the following output:
'       2008-09-15T09:30:41.7752486-07:00
'          With RoundtripKind flag: 9/15/2008 9:30:41 AM Local time.
'          Without RoundtripKind flag: 9/15/2008 9:30:41 AM Local time.
'       2008-09-15T09:30:41.7752486Z
'          With RoundtripKind flag: 9/15/2008 9:30:41 AM Utc time.
'          Without RoundtripKind flag: 9/15/2008 2:30:41 AM Local time.
'       2008-09-15T09:30:41.7752486
'          With RoundtripKind flag: 9/15/2008 9:30:41 AM Unspecified time.
'          Without RoundtripKind flag: 9/15/2008 9:30:41 AM Unspecified time.
'       2008-09-15T09:30:41.7752486-04:00
'          With RoundtripKind flag: 9/15/2008 6:30:41 AM Local time.
'          Without RoundtripKind flag: 9/15/2008 6:30:41 AM Local time.
'       Mon, 15 Sep 2008 09:30:41 GMT
'          With RoundtripKind flag: 9/15/2008 9:30:41 AM Utc time.
'          Without RoundtripKind flag: 9/15/2008 2:30:41 AM Local time.      

Parse(String)

Convertit la représentation sous forme de chaîne d’une date/heure en son équivalent DateTime en utilisant les conventions de la culture du thread actuel.Converts the string representation of a date and time to its DateTime equivalent by using the conventions of the current thread culture.

public:
 static DateTime Parse(System::String ^ s);
public static DateTime Parse (string s);
static member Parse : string -> DateTime
Public Shared Function Parse (s As String) As DateTime

Paramètres

s
String

Chaîne contenant une date et une heure à convertir.A string that contains a date and time to convert. Pour plus d’informations, consultez la chaîne à analyser.See The string to parse for more information.

Retours

Objet qui équivaut à la date et à l'heure figurant dans s.An object that is equivalent to the date and time contained in s.

Exceptions

s a la valeur null.s is null.

s ne contient pas de représentation sous forme de chaîne valide d’une date et heure.s does not contain a valid string representation of a date and time.

Remarques

Si s contient des informations de fuseau horaire, cette méthode retourne une valeur DateTime dont la propriété Kind est DateTimeKind.Local et convertit la date et l’heure de s en heure locale.If s contains time zone information, this method returns a DateTime value whose Kind property is DateTimeKind.Local and converts the date and time in s to local time. Dans le cas contraire, il n’effectue aucune conversion de fuseau horaire et retourne une valeur DateTime dont la propriété Kind est DateTimeKind.Unspecified.Otherwise, it performs no time zone conversion and returns a DateTime value whose Kind property is DateTimeKind.Unspecified.

Cette surcharge tente d’analyser s à l’aide des conventions de mise en forme de la culture actuelle.This overload attempts to parse s by using the formatting conventions of the current culture. La culture actuelle est indiquée par la propriété CurrentCulture.The current culture is indicated by the CurrentCulture property. Pour analyser une chaîne à l’aide des conventions de mise en forme d’une culture spécifique, appelez la Parse(String, IFormatProvider) ou les surcharges de Parse(String, IFormatProvider, DateTimeStyles).To parse a string using the formatting conventions of a specific culture, call the Parse(String, IFormatProvider) or the Parse(String, IFormatProvider, DateTimeStyles) overloads.

Cette surcharge tente d’analyser s en utilisant le style DateTimeStyles.AllowWhiteSpaces.This overload attempts to parse s by using DateTimeStyles.AllowWhiteSpaces style.

ExempleExample

L’exemple suivant analyse la représentation sous forme de chaîne de plusieurs valeurs de date et d’heure en :The following example parses the string representation of several date and time values by:

  • À l’aide du fournisseur de format par défaut, qui fournit les conventions de mise en forme de la culture de thread actuelle de l’ordinateur utilisé pour produire l’exemple de sortie.Using the default format provider, which provides the formatting conventions of the current thread culture of the computer used to produce the example output. La sortie de cet exemple reflète les conventions de mise en forme de la culture en-US.The output from this example reflects the formatting conventions of the en-US culture.

  • À l’aide de la valeur de style par défaut, qui est AllowWhiteSpaces.Using the default style value, which is AllowWhiteSpaces.

Il gère l’exception FormatException qui est levée lorsque la méthode tente d’analyser la représentation sous forme de chaîne d’une date et d’une heure en utilisant des conventions de mise en forme d’autres cultures.It handles the FormatException exception that is thrown when the method tries to parse the string representation of a date and time by using some other culture's formatting conventions. Il montre également comment analyser correctement une valeur de date et d’heure qui n’utilise pas les conventions de mise en forme de la culture de thread actuelle.It also shows how to successfully parse a date and time value that does not use the formatting conventions of the current thread culture.

using System;
using System.Globalization;

public class DateTimeParser
{
   public static void Main()
   {
      // Assume the current culture is en-US. 
      // The date is February 16, 2008, 12 hours, 15 minutes and 12 seconds.

      // Use standard en-US date and time value
      DateTime dateValue;
      string dateString = "2/16/2008 12:15:12 PM";
      try {
         dateValue = DateTime.Parse(dateString);
         Console.WriteLine("'{0}' converted to {1}.", dateString, dateValue);
      }   
      catch (FormatException) {
         Console.WriteLine("Unable to convert '{0}'.", dateString);
      }
            
      // Reverse month and day to conform to the fr-FR culture.
      // The date is February 16, 2008, 12 hours, 15 minutes and 12 seconds.
      dateString = "16/02/2008 12:15:12";
      try {
         dateValue = DateTime.Parse(dateString);
         Console.WriteLine("'{0}' converted to {1}.", dateString, dateValue);
      }   
      catch (FormatException) {
         Console.WriteLine("Unable to convert '{0}'.", dateString);
      }

      // Call another overload of Parse to successfully convert string
      // formatted according to conventions of fr-FR culture.      
      try {
         dateValue = DateTime.Parse(dateString, new CultureInfo("fr-FR", false));
         Console.WriteLine("'{0}' converted to {1}.", dateString, dateValue);
      }   
      catch (FormatException) {
         Console.WriteLine("Unable to convert '{0}'.", dateString);
      }
      
      // Parse string with date but no time component.
      dateString = "2/16/2008";
      try {
         dateValue = DateTime.Parse(dateString);
         Console.WriteLine("'{0}' converted to {1}.", dateString, dateValue);
      }   
      catch (FormatException) {
         Console.WriteLine("Unable to convert '{0}'.", dateString);
      }   
   }
}
// The example displays the following output to the console:
//       '2/16/2008 12:15:12 PM' converted to 2/16/2008 12:15:12 PM.
//       Unable to convert '16/02/2008 12:15:12'.
//       '16/02/2008 12:15:12' converted to 2/16/2008 12:15:12 PM.
//       '2/16/2008' converted to 2/16/2008 12:00:00 AM.
Imports System.Globalization

Class DateTimeParser
   Public Shared Sub Main()
      ' Assume the current culture is en-US. 
      ' The date is February 16, 2008, 12 hours, 15 minutes and 12 seconds.

      ' Use standard en-US date and time value
      Dim dateValue As Date
      Dim dateString As String = "2/16/2008 12:15:12 PM"
      Try
         dateValue = Date.Parse(dateString)
         Console.WriteLine("'{0}' converted to {1}.", dateString, dateValue)
      Catch e As FormatException
         Console.WriteLine("Unable to convert '{0}'.", dateString)
      End Try
            
      ' Reverse month and day to conform to the fr-FR culture.
      ' The date is February 16, 2008, 12 hours, 15 minutes and 12 seconds.
      dateString = "16/02/2008 12:15:12"
      Try
         dateValue = Date.Parse(dateString)
         Console.WriteLine("'{0}' converted to {1}.", dateString, dateValue)
      Catch e As FormatException
         Console.WriteLine("Unable to convert '{0}'.", dateString)
      End Try

      ' Call another overload of Parse to successfully convert string
      ' formatted according to conventions of fr-FR culture.      
      Try
         dateValue = Date.Parse(dateString, New CultureInfo("fr-FR", False))
         Console.WriteLine("'{0}' converted to {1}.", dateString, dateValue)
      Catch e As FormatException
         Console.WriteLine("Unable to convert '{0}'.", dateString)
      End Try
      
      ' Parse string with date but no time component.
      dateString = "2/16/2008"
      Try
         dateValue = Date.Parse(dateString)
         Console.WriteLine("'{0}' converted to {1}.", dateString, dateValue)
      Catch e As FormatException
         Console.WriteLine("Unable to convert '{0}'.", dateString)
      End Try
   End Sub 
End Class 
' The example displays the following output to the console:
'       '2/16/2008 12:15:12 PM' converted to 2/16/2008 12:15:12 PM.
'       Unable to convert '16/02/2008 12:15:12'.
'       '16/02/2008 12:15:12' converted to 2/16/2008 12:15:12 PM.
'       '2/16/2008' converted to 2/16/2008 12:00:00 AM.

Voir aussi

Parse(String, IFormatProvider)

Convertit la représentation sous forme de chaîne d'une date et d'une heure en DateTime équivalent à l'aide des informations de format propres à la culture.Converts the string representation of a date and time to its DateTime equivalent by using culture-specific format information.

public:
 static DateTime Parse(System::String ^ s, IFormatProvider ^ provider);
public static DateTime Parse (string s, IFormatProvider provider);
static member Parse : string * IFormatProvider -> DateTime
Public Shared Function Parse (s As String, provider As IFormatProvider) As DateTime

Paramètres

s
String

Chaîne contenant une date et une heure à convertir.A string that contains a date and time to convert. Pour plus d’informations, consultez la chaîne à analyser.See The string to parse for more information.

provider
IFormatProvider

Objet qui fournit des informations de format spécifiques à la culture sur s.An object that supplies culture-specific format information about s. Consultez Analyse et conventions culturellesSee Parsing and cultural conventions

Retours

Objet qui équivaut à la date et à l'heure figurant dans s, comme spécifié par provider.An object that is equivalent to the date and time contained in s as specified by provider.

Exceptions

s a la valeur null.s is null.

s ne contient pas de représentation sous forme de chaîne valide d’une date et heure.s does not contain a valid string representation of a date and time.

Remarques

Si s contient des informations de fuseau horaire, cette méthode retourne une valeur DateTime dont la propriété Kind est DateTimeKind.Local et convertit la date et l’heure de s en heure locale.If s contains time zone information, this method returns a DateTime value whose Kind property is DateTimeKind.Local and converts the date and time in s to local time. Dans le cas contraire, il n’effectue aucune conversion de fuseau horaire et retourne une valeur DateTime dont la propriété Kind est DateTimeKind.Unspecified.Otherwise, it performs no time zone conversion and returns a DateTime value whose Kind property is DateTimeKind.Unspecified.

Cette surcharge tente d’analyser s à l’aide du style DateTimeStyles.AllowWhiteSpaces.This overload attempts to parse s by using the DateTimeStyles.AllowWhiteSpaces style.

ExempleExample

L’exemple suivant analyse un tableau de chaînes de date à l’aide des conventions des cultures en-US, fr-FR et de-DE.The following example parses an array of date strings by using the conventions of the en-US, fr-FR, and de-DE cultures. Il montre que les représentations sous forme de chaîne d’une date unique peuvent être interprétées différemment entre différentes cultures.It demonstrates that the string representations of a single date can be interpreted differently across different cultures.

using System;
using System.Globalization;

public class ParseDate
{
   public static void Main()
   {
      // Define cultures to be used to parse dates.
      CultureInfo[] cultures = {CultureInfo.CreateSpecificCulture("en-US"), 
                                CultureInfo.CreateSpecificCulture("fr-FR"), 
                                CultureInfo.CreateSpecificCulture("de-DE")};
      // Define string representations of a date to be parsed.
      string[] dateStrings = {"01/10/2009 7:34 PM", 
                              "10.01.2009 19:34", 
                              "10-1-2009 19:34" };
      // Parse dates using each culture.
      foreach (CultureInfo culture in cultures)
      {
         DateTime dateValue;
         Console.WriteLine("Attempted conversions using {0} culture.", 
                           culture.Name);
         foreach (string dateString in dateStrings)
         {
            try {
               dateValue = DateTime.Parse(dateString, culture);
               Console.WriteLine("   Converted '{0}' to {1}.",
                                 dateString, dateValue.ToString("f", culture));
            }
            catch (FormatException) {
               Console.WriteLine("   Unable to convert '{0}' for culture {1}.", 
                                 dateString, culture.Name);
            }
         }
         Console.WriteLine();
      }                                                                                     
   }
}
// The example displays the following output to the console:
//       Attempted conversions using en-US culture.
//          Converted '01/10/2009 7:34 PM' to Saturday, January 10, 2009 7:34 PM.
//          Converted '10.01.2009 19:34' to Thursday, October 01, 2009 7:34 PM.
//          Converted '10-1-2009 19:34' to Thursday, October 01, 2009 7:34 PM.
//       
//       Attempted conversions using fr-FR culture.
//          Converted '01/10/2009 7:34 PM' to jeudi 1 octobre 2009 19:34.
//          Converted '10.01.2009 19:34' to samedi 10 janvier 2009 19:34.
//          Converted '10-1-2009 19:34' to samedi 10 janvier 2009 19:34.
//       
//       Attempted conversions using de-DE culture.
//          Converted '01/10/2009 7:34 PM' to Donnerstag, 1. Oktober 2009 19:34.
//          Converted '10.01.2009 19:34' to Samstag, 10. Januar 2009 19:34.
//          Converted '10-1-2009 19:34' to Samstag, 10. Januar 2009 19:34.
Imports System.Globalization

Module ParseDate
   Public Sub Main()
      ' Define cultures to be used to parse dates.
      Dim cultures() As CultureInfo = {CultureInfo.CreateSpecificCulture("en-US"), _
                                       CultureInfo.CreateSpecificCulture("fr-FR"), _
                                       CultureInfo.CreateSpecificCulture("de-DE")}
      ' Define string representations of a date to be parsed.
      Dim dateStrings() As String = {"01/10/2009 7:34 PM", _
                                     "10.01.2009 19:34", _
                                     "10-1-2009 19:34" }
      ' Parse dates using each culture.
      For Each culture In cultures
         Dim dateValue As Date
         Console.WriteLine("Attempted conversions using {0} culture.", culture.Name)
         For Each dateString As String In dateStrings
            Try
               dateValue = Date.Parse(dateString, culture)
               Console.WriteLine("   Converted '{0}' to {1}.", _
                                 dateString, dateValue.ToString("f", culture))
            Catch e As FormatException
               Console.WriteLine("   Unable to convert '{0}' for culture {1}.", _
                                 dateString, culture.Name)
            End Try                                                
         Next
         Console.WriteLine()
      Next                                                                                     
   End Sub
End Module
' The example displays the following output to the console:
'       Attempted conversions using en-US culture.
'          Converted '01/10/2009 7:34 PM' to Saturday, January 10, 2009 7:34 PM.
'          Converted '10.01.2009 19:34' to Thursday, October 01, 2009 7:34 PM.
'          Converted '10-1-2009 19:34' to Thursday, October 01, 2009 7:34 PM.
'       
'       Attempted conversions using fr-FR culture.
'          Converted '01/10/2009 7:34 PM' to jeudi 1 octobre 2009 19:34.
'          Converted '10.01.2009 19:34' to samedi 10 janvier 2009 19:34.
'          Converted '10-1-2009 19:34' to samedi 10 janvier 2009 19:34.
'       
'       Attempted conversions using de-DE culture.
'          Converted '01/10/2009 7:34 PM' to Donnerstag, 1. Oktober 2009 19:34.
'          Converted '10.01.2009 19:34' to Samstag, 10. Januar 2009 19:34.
'          Converted '10-1-2009 19:34' to Samstag, 10. Januar 2009 19:34.

Voir aussi

Parse(ReadOnlySpan<Char>, IFormatProvider, DateTimeStyles)

Convertit une étendue de mémoire contenant la représentation sous forme de chaîne d’une date/heure en son équivalent DateTime en utilisant les informations de format propres à la culture et un style de mise en forme.Converts a memory span that contains string representation of a date and time to its DateTime equivalent by using culture-specific format information and a formatting style.

public static DateTime Parse (ReadOnlySpan<char> s, IFormatProvider provider = null, System.Globalization.DateTimeStyles styles = System.Globalization.DateTimeStyles.None);
static member Parse : ReadOnlySpan<char> * IFormatProvider * System.Globalization.DateTimeStyles -> DateTime
Public Shared Function Parse (s As ReadOnlySpan(Of Char), Optional provider As IFormatProvider = null, Optional styles As DateTimeStyles = System.Globalization.DateTimeStyles.None) As DateTime

Paramètres

s
ReadOnlySpan<Char>

Étendue de mémoire contenant la chaîne à analyser.The memory span that contains the string to parse. Pour plus d’informations, consultez la chaîne à analyser.See The string to parse for more information.

provider
IFormatProvider

Objet qui fournit des informations de format spécifiques à la culture sur s.An object that supplies culture-specific format information about s. Consultez Analyse et conventions culturellesSee Parsing and cultural conventions

styles
DateTimeStyles

Combinaison d'opérations de bits des valeurs d'énumération qui indique les éléments de style pouvant être présents dans s pour la réussite de l'opération d'analyse et qui définit comment interpréter la date analysée par rapport au fuseau horaire actuel ou à la date actuelle.A bitwise combination of the enumeration values that indicates the style elements that can be present in s for the parse operation to succeed, and that defines how to interpret the parsed date in relation to the current time zone or the current date. Une valeur typique à spécifier est None.A typical value to specify is None.

Retours

Objet qui équivaut à la date et à l'heure figurant dans s, comme spécifié par provider et styles.An object that is equivalent to the date and time contained in s, as specified by provider and styles.

Exceptions

s ne contient pas de représentation sous forme de chaîne valide d’une date et heure.s does not contain a valid string representation of a date and time.

styles contient une combinaison non valide de valeurs DateTimeStyles.styles contains an invalid combination of DateTimeStyles values. Par exemple, AssumeLocal et AssumeUniversal.For example, both AssumeLocal and AssumeUniversal.

Parse(String, IFormatProvider, DateTimeStyles)

Convertit la représentation sous forme de chaîne d’une date/heure en son équivalent DateTime en utilisant les informations de format propres à la culture et un style de mise en forme.Converts the string representation of a date and time to its DateTime equivalent by using culture-specific format information and a formatting style.

public:
 static DateTime Parse(System::String ^ s, IFormatProvider ^ provider, System::Globalization::DateTimeStyles styles);
public static DateTime Parse (string s, IFormatProvider provider, System.Globalization.DateTimeStyles styles);
static member Parse : string * IFormatProvider * System.Globalization.DateTimeStyles -> DateTime
Public Shared Function Parse (s As String, provider As IFormatProvider, styles As DateTimeStyles) As DateTime

Paramètres

s
String

Chaîne contenant une date et une heure à convertir.A string that contains a date and time to convert. Pour plus d’informations, consultez la chaîne à analyser.See The string to parse for more information.

provider
IFormatProvider

Objet qui fournit des informations de mise en forme propres à la culture sur s.An object that supplies culture-specific formatting information about s. Consultez Analyse et conventions culturellesSee Parsing and cultural conventions

styles
DateTimeStyles

Combinaison d'opérations de bits des valeurs d'énumération qui indique les éléments de style pouvant être présents dans s pour la réussite de l'opération d'analyse et qui définit comment interpréter la date analysée par rapport au fuseau horaire actuel ou à la date actuelle.A bitwise combination of the enumeration values that indicates the style elements that can be present in s for the parse operation to succeed, and that defines how to interpret the parsed date in relation to the current time zone or the current date. Une valeur typique à spécifier est None.A typical value to specify is None.

Retours

Objet qui équivaut à la date et à l'heure figurant dans s, comme spécifié par provider et styles.An object that is equivalent to the date and time contained in s, as specified by provider and styles.

Exceptions

s a la valeur null.s is null.

s ne contient pas de représentation sous forme de chaîne valide d’une date et heure.s does not contain a valid string representation of a date and time.

styles contient une combinaison non valide de valeurs DateTimeStyles.styles contains an invalid combination of DateTimeStyles values. Par exemple, AssumeLocal et AssumeUniversal.For example, both AssumeLocal and AssumeUniversal.

Remarques

Cette surcharge de méthode convertit la date et l’heure dans s et définit la propriété Kind de la valeur DateTime retournée comme suit :This method overload converts the date and time in s and sets the Kind property of the returned DateTime value as follows:

IfIf Conversion de fuseau horaireTime zone conversion Kind, propriétéKind property
s ne contient aucune information sur les fuseaux horaires.s contains no time zone information. Aucun.None. DateTimeKind.Unspecified
s contient des informations sur les fuseaux horaires.s contains time zone information. À l’heure du fuseau horaire localTo the time in the local time zone DateTimeKind.Local
s contient des informations sur les fuseaux horaires, et styles inclut l’indicateur DateTimeStyles.AdjustToUniversal.s contains time zone information, and styles includes the DateTimeStyles.AdjustToUniversal flag. En temps universel coordonné (UTC)To Coordinated Universal Time (UTC) DateTimeKind.Utc
s contient l’indicateur de fuseau horaire Z ou GMT, et styles inclut le DateTimeStyles.RoundtripKind.s contains the Z or GMT time zone designator, and styles includes the DateTimeStyles.RoundtripKind. Aucun.None. DateTimeKind.Utc

ExempleExample

L’exemple suivant illustre la méthode Parse(String, IFormatProvider, DateTimeStyles) et affiche la valeur de la propriété Kind des valeurs DateTime résultantes.The following example demonstrates the Parse(String, IFormatProvider, DateTimeStyles) method and displays the value of the Kind property of the resulting DateTime values.

using System;
using System.Globalization;

public class ParseDateExample
{
   public static void Main()
   {
      string dateString;
      CultureInfo culture ;
      DateTimeStyles styles;
      DateTime result;
      
      // Parse a date and time with no styles.
      dateString = "03/01/2009 10:00 AM";
      culture = CultureInfo.CreateSpecificCulture("en-US");
      styles = DateTimeStyles.None;
      try {
         result = DateTime.Parse(dateString, culture, styles);
         Console.WriteLine("{0} converted to {1} {2}.", 
                           dateString, result, result.Kind.ToString());
      }
      catch (FormatException) {
         Console.WriteLine("Unable to convert {0} to a date and time.", 
                           dateString);
      }      
      
      // Parse the same date and time with the AssumeLocal style.
      styles = DateTimeStyles.AssumeLocal;
      try {
         result = DateTime.Parse(dateString, culture, styles);
         Console.WriteLine("{0} converted to {1} {2}.", 
                           dateString, result, result.Kind.ToString());
      }
      catch (FormatException) {
         Console.WriteLine("Unable to convert {0} to a date and time.", dateString);
      }      
      
      // Parse a date and time that is assumed to be local.
      // This time is five hours behind UTC. The local system's time zone is 
      // eight hours behind UTC.
      dateString = "2009/03/01T10:00:00-5:00";
      styles = DateTimeStyles.AssumeLocal;
      try {
         result = DateTime.Parse(dateString, culture, styles);
         Console.WriteLine("{0} converted to {1} {2}.", 
                           dateString, result, result.Kind.ToString());
      }
      catch (FormatException) {
         Console.WriteLine("Unable to convert {0} to a date and time.", dateString);
      }      
      
      // Attempt to convert a string in improper ISO 8601 format.
      dateString = "03/01/2009T10:00:00-5:00";
      try {
         result = DateTime.Parse(dateString, culture, styles);
         Console.WriteLine("{0} converted to {1} {2}.", 
                           dateString, result, result.Kind.ToString());
      }                     
      catch (FormatException) {
         Console.WriteLine("Unable to convert {0} to a date and time.", dateString);
      }      

      // Assume a date and time string formatted for the fr-FR culture is the local 
      // time and convert it to UTC.
      dateString = "2008-03-01 10:00";
      culture = CultureInfo.CreateSpecificCulture("fr-FR");
      styles = DateTimeStyles.AdjustToUniversal | DateTimeStyles.AssumeLocal;
      try {
         result = DateTime.Parse(dateString, culture, styles);
         Console.WriteLine("{0} converted to {1} {2}.", 
                           dateString, result, result.Kind.ToString());
      }
      catch (FormatException) {
         Console.WriteLine("Unable to convert {0} to a date and time.", dateString);
      }      
   }
}
// The example displays the following output to the console:
//       03/01/2009 10:00 AM converted to 3/1/2009 10:00:00 AM Unspecified.
//       03/01/2009 10:00 AM converted to 3/1/2009 10:00:00 AM Local.
//       2009/03/01T10:00:00-5:00 converted to 3/1/2009 7:00:00 AM Local.
//       Unable to convert 03/01/2009T10:00:00-5:00 to a date and time.
//       2008-03-01 10:00 converted to 3/1/2008 6:00:00 PM Utc.
Imports System.Globalization

Module ParseDateExample
   Public Sub Main()
      Dim dateString As String  
      Dim culture As CultureInfo
      Dim styles As DateTimeStyles 
      Dim result As DateTime
      
      ' Parse a date and time with no styles.
      dateString = "03/01/2009 10:00 AM"
      culture = CultureInfo.CreateSpecificCulture("en-US")
      styles = DateTimeStyles.None
      Try
         result = DateTime.Parse(dateString, culture, styles)
         Console.WriteLine("{0} converted to {1} {2}.", _
                           dateString, result, result.Kind.ToString())
      Catch e As FormatException
         Console.WriteLine("Unable to convert {0} to a date and time.", dateString)
      End Try      
      
      ' Parse the same date and time with the AssumeLocal style.
      styles = DateTimeStyles.AssumeLocal
      Try
         result = DateTime.Parse(dateString, culture, styles)
         Console.WriteLine("{0} converted to {1} {2}.", _
                           dateString, result, result.Kind.ToString())
      Catch e As FormatException
         Console.WriteLine("Unable to convert {0} to a date and time.", dateString)
      End Try      
      
      ' Parse a date and time that is assumed to be local.
      ' This time is five hours behind UTC. The local system's time zone is 
      ' eight hours behind UTC.
      dateString = "2009/03/01T10:00:00-5:00"
      styles = DateTimeStyles.AssumeLocal
      Try
         result = DateTime.Parse(dateString, culture, styles)
         Console.WriteLine("{0} converted to {1} {2}.", _
                           dateString, result, result.Kind.ToString())
      Catch e As FormatException
         Console.WriteLine("Unable to convert {0} to a date and time.", dateString)
      End Try      
      
      ' Attempt to convert a string in improper ISO 8601 format.
      dateString = "03/01/2009T10:00:00-5:00"
      Try
         result = DateTime.Parse(dateString, culture, styles)
         Console.WriteLine("{0} converted to {1} {2}.", _
                           dateString, result, result.Kind.ToString())
      Catch e As FormatException
         Console.WriteLine("Unable to convert {0} to a date and time.", dateString)
      End Try      

      ' Assume a date and time string formatted for the fr-FR culture is the local 
      ' time and convert it to UTC.
      dateString = "2008-03-01 10:00"
      culture = CultureInfo.CreateSpecificCulture("fr-FR")
      styles = DateTimeStyles.AdjustToUniversal Or DateTimeStyles.AssumeLocal
      Try
         result = DateTime.Parse(dateString, culture, styles)
         Console.WriteLine("{0} converted to {1} {2}.", _
                           dateString, result, result.Kind.ToString())
      Catch e As FormatException
         Console.WriteLine("Unable to convert {0} to a date and time.", dateString)
      End Try      
   End Sub
End Module
'
' The example displays the following output to the console:
'       03/01/2009 10:00 AM converted to 3/1/2009 10:00:00 AM Unspecified.
'       03/01/2009 10:00 AM converted to 3/1/2009 10:00:00 AM Local.
'       2009/03/01T10:00:00-5:00 converted to 3/1/2009 7:00:00 AM Local.
'       Unable to convert 03/01/2009T10:00:00-5:00 to a date and time.
'       2008-03-01 10:00 converted to 3/1/2008 6:00:00 PM Utc.

Voir aussi

S’applique à