DateTime.Parse DateTime.Parse DateTime.Parse DateTime.Parse Method

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) Parse(String) Parse(String) 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) Parse(String, IFormatProvider) Parse(String, IFormatProvider) 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) Parse(ReadOnlySpan<Char>, IFormatProvider, DateTimeStyles) 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) Parse(String, IFormatProvider, DateTimeStyles) Parse(String, IFormatProvider, DateTimeStyles) 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 DateTime.Parse la méthode sont intercalés dans la section Notes de cet article et dans la documentation pour DateTime.Parse les surcharges 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' DateTime.Parse exemples, qui sont inclus dans un projet .net Core 2,0 pour C# et un projet .net Core 2,0 pour Visual Basic, à partir du dépôt 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. Parse(String, IFormatProvider)surcharge (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" ToString(String) à la méthode, puis Parse(String, IFormatProvider, DateTimeStyles) appelez la surcharge avecDateTimeStyles.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. DateTime.ParseExactou DateTime.TryParseExact , méthodeDateTime.ParseExact or DateTime.TryParseExact method

Chaîne à analyserThe string to parse

La Parse méthode tente de convertir la représentation sous forme de chaîne d’une valeur de date DateTime et d’heure en son équivalent.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 FormatException d’exception.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 Parse , la méthode lève FormatExceptionune, tandis que falsela TryParse méthode retourne.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 Parse , vous devez utiliser 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. TryParseest 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 Calendar.TwoDigitYearMax le du calendrier actuel de la culture actuelle ou le 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 Parse(String, IFormatProvider, DateTimeStyles) la surcharge et DateTimeStyles.NoCurrentDateDefault que vous styles incluez dans l’argument, 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 Parse(String, IFormatProvider, DateTimeStyles) surcharge et inclure DateTimeStyles.NoCurrentDateDefault dans l' styles argument, 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), Parse la méthode 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 FormatExceptionlève une.If the input string represents a leap day in a non-leap year, the method throws a FormatException.

Étant donné Parse que la méthode 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 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 DateTime.ParseExact de la méthode 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 Parse la méthode sont dépendantes de la culture, à moins que la chaîne à analyser s (représentée par 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 DateTimeFormatInfo d’un objet dérivé de la façon suivante :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 (DateTimeFormatInfo.CurrentInfo propriété)The current thread culture (DateTimeFormatInfo.CurrentInfo property)
Parse(String, IFormatProvider) ou Parse(String, IFormatProvider, DateTimeStyles)Parse(String, IFormatProvider) or Parse(String, IFormatProvider, DateTimeStyles) DateTimeFormatInfo Objeta DateTimeFormatInfo object Objet spécifié DateTimeFormatInfoThe specified DateTimeFormatInfo object
Parse(String, IFormatProvider) ou Parse(String, IFormatProvider, DateTimeStyles)Parse(String, IFormatProvider) or Parse(String, IFormatProvider, DateTimeStyles) null Culture du thread actuel (DateTimeFormatInfo.CurrentInfo propriété)The current thread culture (DateTimeFormatInfo.CurrentInfo property)
Parse(String, IFormatProvider) ou Parse(String, IFormatProvider, DateTimeStyles)Parse(String, IFormatProvider) or Parse(String, IFormatProvider, DateTimeStyles) CultureInfo Objeta 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 DateTimeFormatInfo dérivées d' DateTimeFormatInfo.Calendar un objet, la propriété 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 DateTimeFormatInfo à l’aide d’un objet avec des paramètres personnalisés qui sont différents de ceux d' ParseExact une culture standard, Parse utilisez la méthode à la place de la méthode 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 Parse méthode 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 ParseExact méthode vous oblige à désigner explicitement un ou plusieurs modèles d’analyse exacts qui sont 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 DateTimeFormatInfo la rubrique.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 IFormatProvider qui spécifient un objet qui représente une culture autre que la culture dite indifférente peuvent échouer de manière 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 ParseExact la TryParseExact culture dite indifférente, ou vous pouvez appeler la méthode ou 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 DateTime et désérialiser la valeur 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 CultureInfo » dans la rubrique et la section « persistance des valeurs DateTime DateTime » dans la rubrique.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 Parse les surcharges 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 Parse(String, IFormatProvider, DateTimeStyles) surcharge possède un styles paramètre qui se compose d’un ou de plusieurs membres DateTimeStyles de l’énumération.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 s être convertie en date et 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 DateTimeStyles membre 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 s Analyse 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 s si ne contient pas d’informations styles de fuseau AssumeLocal horaire mais inclut l’indicateur, la méthode analyse la ToUniversalTime chaîne, appelle pour DateTime convertir la valeur retournée en UTC et affecte à la Kind propriété la DateTimeKind.Utcvaleur.- 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, s ou si ne contient pas d’informations styles sur les AssumeUniversal fuseaux horaires mais comprend l’indicateur, la méthode analyse la chaîne, n’effectue aucune DateTime conversion de fuseau horaire sur le retourné. et affecte à DateTimeKind.Utcla propriété Kind la valeur.- 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 sd’heure de.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 set d’heure de.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' sheure de.Trailing white space is always permitted in the date and time elements of s.
AllowWhiteSpaces Spécifie s que 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. Elle ne peut pas être substituée en fournissant une valeur DateTimeStyles d’énumération plus Nonerestrictive telle que.It cannot be overridden by supplying a more restrictive DateTimeStyles enumeration value such as None.
AssumeLocal Spécifie que s s’il manque des informations 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 AdjustToUniversal que l’indicateur ne soit Kind présent, la propriété DateTime de la valeur 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 s s’il manque des informations de fuseau horaire, l’heure UTC est supposée.Specifies that if s lacks any time zone information, UTC is assumed. À moins AdjustToUniversal que l’indicateur ne soit présent, la méthode convertit la valeur retournée DateTime de l’heure Kind UTC en DateTimeKind.Localheure locale et affecte à sa propriété la valeur.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 DateTime et d’heure en une valeur qui représente Kind une heure locale DateTimeKind.Localavec sa propriété définie sur.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 DateTime.ToString(String) la méthode et à l’aide du 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 DateTime.Parse surcharges retournent une Kind DateTime valeur dont la propriété contient 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 Parse , la méthode retourne un Kind objet dont DateTimeKind.Unspecifiedla propriété a la DateTime valeur.Generally, the Parse method returns a DateTime object whose Kind property is DateTimeKind.Unspecified. Toutefois, la Parse méthode peut également effectuer une conversion de fuseau horaire et définir différemment la Kind valeur de la propriété, en fonction des valeurs des s paramètres styles et :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
scontient 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
scontient des informations sur les fuseaux horaires AdjustToUniversal et styles inclut l’indicateur.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
scontient l’indicateur de fuseau horaire Z ou GMT et styles inclut l' RoundtripKind indicateur.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 d’une propriété de date et Kind d’heure au cours d’une opération de mise en forme et DateTimeStyles.RoundtripKind d’analyse à l’aide de l’indicateur.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' RoundtripKind indicateur affecte l’opération d’analyse sur DateTime les valeurs 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) Parse(String) Parse(String) 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 String String 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 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 DateTime retourne une Kind valeur dont DateTimeKind.Local la propriété est et convertit la s date et l’heure 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 DateTime fuseau horaire Kind et retourne DateTimeKind.Unspecifiedune valeur dont la propriété est.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 CurrentCulture propriété.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 Parse(String, IFormatProvider) spécifique, Parse(String, IFormatProvider, DateTimeStyles) appelez la ou les surcharges.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 à l' DateTimeStyles.AllowWhiteSpaces aide de style.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 AllowWhiteSpacespar défaut, qui est.Using the default style value, which is AllowWhiteSpaces.

Il gère l' FormatException exception 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) Parse(String, IFormatProvider) Parse(String, IFormatProvider) 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 String String 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 IFormatProvider IFormatProvider 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 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 DateTime retourne une Kind valeur dont DateTimeKind.Local la propriété est et convertit la s date et l’heure 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 DateTime fuseau horaire Kind et retourne DateTimeKind.Unspecifiedune valeur dont la propriété est.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 DateTimeStyles.AllowWhiteSpaces du style.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) Parse(ReadOnlySpan<Char>, IFormatProvider, DateTimeStyles) 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 IFormatProvider IFormatProvider 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 DateTimeStyles DateTimeStyles 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) Parse(String, IFormatProvider, DateTimeStyles) Parse(String, IFormatProvider, DateTimeStyles) 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 String String 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 IFormatProvider IFormatProvider 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 DateTimeStyles DateTimeStyles 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.

Remarques

Cette surcharge de méthode convertit la date et s l’heure dans Kind et définit la propriété DateTime de la valeur 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
sne contient aucune information de fuseau horaire.s contains no time zone information. Aucun.None. DateTimeKind.Unspecified
scontient 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
scontient des informations sur les fuseaux horaires et les DateTimeStyles.AdjustToUniversal styles incluent l’indicateur.s contains time zone information, and `styles includes the DateTimeStyles.AdjustToUniversal flag. En temps universel coordonné (UTC)To Coordinated Universal Time (UTC) DateTimeKind.Utc
scontient 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. Utc

ExempleExample

L’exemple suivant illustre la Parse(String, IFormatProvider, DateTimeStyles) méthode et affiche la valeur de la Kind propriété des valeurs résultantes DateTime .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 à