DateTime.Parse Méthode

Définition

Espace de noms:

System

Assembly:

System.Runtime.dll

Convertit la représentation sous forme de chaîne d’une date et d’une heure en son équivalent DateTime.

Surcharges

Parse(String)	Convertit la représentation sous forme de chaîne d’une date et d’une heure en son DateTime équivalent à l’aide des conventions de la culture actuelle.
Parse(ReadOnlySpan<Char>, IFormatProvider)	Analyse une étendue de caractères en une valeur.
Parse(String, IFormatProvider)	Convertit la représentation sous forme de chaîne d’une date et d’une heure en son DateTime équivalent à l’aide d’informations de format propres à la culture.
Parse(ReadOnlySpan<Char>, IFormatProvider, DateTimeStyles)	Convertit une étendue de mémoire qui contient une représentation sous forme de chaîne d’une date et d’une heure en son équivalent DateTime en utilisant des informations de format propres à la culture et un style de mise en forme.
Parse(String, IFormatProvider, DateTimeStyles)	Convertit la représentation sous forme de chaîne d’une date et d’une heure en son équivalent DateTime à l’aide d’informations de format propres à la culture et d’un style de mise en forme.

Exemples

De nombreux exemples qui appellent la méthode DateTime.Parse sont interpersés dans la section Remarques de cet article et dans la documentation relative aux surcharges individuelles DateTime.Parse.

Note

Certains exemples C# de cet article s’exécutent dans le Try.NET exécuteur de code inline et le terrain de jeu. Sélectionnez Exécuter pour exécuter un exemple dans une fenêtre interactive. Une fois que vous avez exécuté le code, vous pouvez le modifier et l’exécuter en sélectionnant Réexécuter. Le 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#.

Le fuseau horaire local de l’exécuteur de code inline Try.NET et le terrain de jeu est temps universel coordonné ou UTC. Cela peut affecter le comportement et la sortie d’exemples qui illustrent les DateTime, DateTimeOffsetet TimeZoneInfo types et leurs membres.

Vous pouvez également télécharger un ensemble complet d’exemples DateTime.Parse inclus dans un projet .NET Core pour C#.

Remarques

Dans cette section :

• Quelle méthode dois-je appeler ?
• Chaîne à analyser
• conventions d’analyse et de culture
• l’analyse et les éléments de style
• Valeur de retour et DateTime.Kind

Quelle méthode dois-je appeler ?

À	Appeler
Analysez une chaîne de date et d’heure à l’aide des conventions de la culture actuelle.	surcharge de Parse(String)
Analysez une chaîne de date et d’heure à l’aide des conventions d’une culture spécifique.	surcharge Parse(String, IFormatProvider) (voir Analyse et Conventions culturelles)
Analysez une chaîne de date et d’heure avec des éléments de style spéciaux (par exemple, un espace blanc ou aucun espace blanc).	surcharge de Parse(String, IFormatProvider, DateTimeStyles)
Analysez une chaîne de date et d’heure qui doit être dans un format particulier.	DateTime.ParseExact ou DateTime.TryParseExact
Analysez une chaîne de date et d’heure et effectuez une conversion en heure UTC ou locale.	surcharge de Parse(String, IFormatProvider, DateTimeStyles)
Analysez une chaîne de date et d’heure sans gérer les exceptions.	méthode DateTime.TryParse
Restaurez (aller-retour) une valeur de date et d’heure créée par une opération de mise en forme.	Passez la chaîne de format standard « o » ou « r » à la méthode ToString(String) et appelez la surcharge de Parse(String, IFormatProvider, DateTimeStyles) avec DateTimeStyles.RoundtripKind
Analysez une chaîne de date et d’heure dans un format fixe entre les limites de machine (et éventuellement culturelle).	méthode DateTime.ParseExact ou DateTime.TryParseExact

Chaîne à analyser

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. Il tente d’analyser complètement la chaîne d’entrée sans lever une exception FormatException.

Important

Si l’opération d’analyse échoue en raison d’un format de chaîne non reconnu, la méthode Parse lève un FormatException, tandis que la méthode TryParse retourne false. Étant donné que la gestion des exceptions peut être coûteuse, vous devez utiliser Parse lorsque l’opération d’analyse est censée réussir, car la source d’entrée est approuvée. 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 pour remplacer les chaînes qui n’analysent pas correctement.

La chaîne à analyser peut prendre l’une des formes suivantes :

• Chaîne avec une date et un composant d’heure.

• Chaîne avec une date mais aucun composant d’heure. Si le composant de temps est absent, la méthode suppose 12:00 minuit. Si le composant date a une année à deux chiffres, il est converti en année en fonction de l'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 de provider non null).

• Chaîne avec un composant de date qui inclut uniquement le mois et l’année, mais aucun composant jour. La méthode suppose le premier jour du mois.

• Chaîne avec un composant de date qui inclut uniquement le mois et le jour, mais pas le composant année. La méthode part du principe que l’année en cours.

• Chaîne avec une heure mais aucun composant de date. La méthode suppose la date actuelle, sauf si vous appelez la surcharge de Parse(String, IFormatProvider, DateTimeStyles) et incluez DateTimeStyles.NoCurrentDateDefault dans l’argument styles, auquel cas la méthode suppose une date du 1er janvier 0001.

• Chaîne avec un composant d’heure qui inclut uniquement l’heure et un indicateur AM/PM, sans composant de date. La méthode suppose la date actuelle et une heure sans minutes et sans secondes. Vous pouvez modifier ce comportement en appelant la surcharge de Parse(String, IFormatProvider, DateTimeStyles) et en incluant DateTimeStyles.NoCurrentDateDefault dans l’argument styles, auquel cas la méthode suppose une date du 1er janvier 0001.

• Chaîne qui inclut des informations de fuseau horaire et qui est conforme à la norme ISO 8601. Dans les exemples suivants, la première chaîne désigne le temps universel coordonné (UTC), et la seconde désigne l’heure dans un fuseau horaire qui est de sept heures antérieures à UTC :

  « 2008-11-01T19:35:00.000000Z » « 2008-11-01T19:35:00.000000-07:000 »

• Chaîne qui inclut le désignateur GMT et qui est conforme au format de temps RFC 1123 ; par exemple:

  « Sat, 01 Novembre 2008 19:35:00 GMT »

• Chaîne qui inclut la date et l’heure ainsi que les informations de décalage de fuseau horaire ; par exemple:

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

L’exemple suivant analyse les 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 :

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

module Parse6

open System

let  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" ]

printfn $"Today is {DateTime.Now:d}\n"

for dateAsString, description in dateInfo do
    printfn $"""{description + ":",-52} '{dateAsString}' --> {DateTime.Parse(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 bissextile dans un an bissextile dans le calendrier utilisé par la méthode d’analyse (voir Conventions d’analyse et de culture), la méthode Parse analyse correctement la chaîne. Si la chaîne d’entrée représente un jour bissextile dans une année non bissextile, la méthode lève une 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 spécifiée, la tentative d’analyse d’une chaîne sur différentes cultures peut échouer. 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.

Analyse et conventions culturelles

Toutes les surcharges de la méthode Parse respectent la culture, sauf si la chaîne à analyser (qui est représentée par s dans le tableau suivant) est conforme au modèle ISO 8601. L’opération d’analyse utilise les informations de mise en forme dans un objet DateTimeFormatInfo dérivé comme suit :

Important

Les ères dans les calendriers japonais sont basées sur le règne de l’empereur et sont donc censées changer. Par exemple, le 1er mai 2019 marque le début de l’ère Reiwa dans les JapaneseCalendar et JapaneseLunisolarCalendar. Ce changement d’ère affecte toutes les applications qui utilisent ces calendriers. Pour plus d’informations et pour déterminer si vos applications sont affectées, consultez Gestion d’une nouvelle ère dans le calendrier japonais dans .NET. Pour plus d’informations sur le test de vos applications sur les systèmes Windows afin de garantir leur préparation au changement d’ère, consultez Préparer votre application pour la modification de l’ère japonaise. Pour les fonctionnalités de .NET qui prennent en charge les calendriers avec plusieurs ères et pour les meilleures pratiques lors de l’utilisation de calendriers qui prennent en charge plusieurs ères, consultez Utilisation des ères.

Si vous appelez	Et provider est	Les informations de mise en forme sont dérivées de
Parse(String)	-	Culture actuelle (propriétéDateTimeFormatInfo.CurrentInfo)
Parse(String, IFormatProvider) ou Parse(String, IFormatProvider, DateTimeStyles)	un objet DateTimeFormatInfo	Objet DateTimeFormatInfo spécifié
Parse(String, IFormatProvider) ou Parse(String, IFormatProvider, DateTimeStyles)	null	Culture actuelle (propriétéDateTimeFormatInfo.CurrentInfo)
Parse(String, IFormatProvider) ou Parse(String, IFormatProvider, DateTimeStyles)	un objet CultureInfo	Propriété CultureInfo.DateTimeFormat
Parse(String, IFormatProvider) ou Parse(String, IFormatProvider, DateTimeStyles)	Implémentation de IFormatProvider personnalisée	Méthode IFormatProvider.GetFormat

Lorsque des 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.

Si vous analysez une chaîne de date et d’heure à l’aide d’un objet DateTimeFormatInfo avec des paramètres personnalisés 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 d’une conversion réussie. Une chaîne de date et d’heure non standard peut être complexe et difficile à analyser. La méthode Parse tente d’analyser une chaîne avec plusieurs modèles d’analyse implicites, qui peuvent échouer. En revanche, la méthode ParseExact vous oblige à désigner explicitement un ou plusieurs modèles d’analyse exacts susceptibles de réussir. Pour plus d’informations, consultez la section « DateTimeFormatInfo et Dynamic Data » dans la rubrique DateTimeFormatInfo.

Important

Notez que les conventions de mise en forme d’une culture particulière sont dynamiques et peuvent être modifiées. 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 qui représente une culture autre que la culture invariante peut échouer de façon inattendue si l’une des opérations suivantes se produit :

• 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 vers la version existante du .NET Framework.
• Les données propres à la culture reflètent les préférences de l’utilisateur, qui peuvent varier d’un ordinateur à l’autre ou d’une session à l’autre.
• 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.

Pour éviter les difficultés liées à l’analyse des données et des chaînes d’heure 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 invariante, ou vous pouvez appeler la méthode ParseExact ou TryParseExact et spécifier le format exact de la chaîne à analyser. Si vous sérialisez et désérialisez les données de date et d’heure, vous pouvez utiliser les conventions de mise en forme de la culture invariante, ou vous pouvez sérialiser et désérialiser la valeur DateTime dans un format binaire.

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.

Analyse et éléments de style

Toutes les surcharges Parse ignorent les caractères d’espace blanc de début, d’intérieur ou de fin dans la chaîne d’entrée (qui est représentée par s dans le tableau suivant). La date et l’heure peuvent être entre crochets avec une paire de caractères NUMÉRO DE DÉBUT et de fin (« # », U+0023) et peuvent être suivis avec un ou plusieurs caractères NULL (U+0000).

En outre, la surcharge Parse(String, IFormatProvider, DateTimeStyles) a un paramètre styles qui se compose d’un ou plusieurs membres de l’énumération DateTimeStyles. Ce paramètre définit comment s doit être interprété et comment l’opération d’analyse doit convertir s en date et heure. Le tableau suivant décrit l’effet de chaque membre DateTimeStyles sur l’opération d’analyse.

Membre DateTimeStyles	Effet sur la conversion
AdjustToUniversal	Analyse s et, si nécessaire, la convertit en UTC, comme suit : - Si s inclut un décalage de fuseau horaire, ou si s ne contient aucune information de fuseau horaire, mais styles inclut l’indicateur AssumeLocal, la méthode analyse la chaîne, appelle ToUniversalTime pour convertir la valeur de DateTime retournée en UTC et définit la propriété Kind sur DateTimeKind.Utc. - Si s indique qu’il représente UTC, ou si s ne contient pas d’informations de fuseau horaire, mais styles inclut l’indicateur AssumeUniversal, la méthode analyse la chaîne, n’effectue aucune conversion de fuseau horaire sur la valeur de DateTime retournée et définit la propriété Kind sur DateTimeKind.Utc. - Dans tous les autres cas, l’indicateur n’a aucun effet.
AllowInnerWhite	Cette valeur est ignorée. L’espace blanc interne est toujours autorisé dans les éléments de date et d’heure de s.
AllowLeadingWhite	Cette valeur est ignorée. L’espace blanc de début est toujours autorisé dans les éléments de date et d’heure de s.
AllowTrailingWhite	Cette valeur est ignorée. L’espace blanc de fin est toujours autorisé dans les éléments de date et d’heure de s.
AllowWhiteSpaces	Spécifie que s peut contenir des espaces blancs de début, internes et de fin. Il s’agit du comportement par défaut. Il ne peut pas être substitué en fournissant une valeur d’énumération DateTimeStyles plus restrictive telle que None.
AssumeLocal	Spécifie que si s n’a pas d’informations de fuseau horaire, l’heure locale est supposée. Sauf si l’indicateur AdjustToUniversal est présent, la propriété Kind de la valeur de DateTime retournée est définie sur DateTimeKind.Local.
AssumeUniversal	Spécifie que si s n’a pas d’informations de fuseau horaire, UTC est supposé. Sauf si l’indicateur AdjustToUniversal est présent, la méthode convertit la valeur de DateTime retournée de l’heure UTC en heure locale et définit sa propriété Kind sur DateTimeKind.Local.
None	Bien que valide, cette valeur est ignorée.
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 valeur DateTime qui représente une heure locale avec sa propriété Kind définie sur DateTimeKind.Local. En règle générale, 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 ».

Valeur de retour et DateTime.Kind

Les surcharges DateTime.Parse retournent une valeur DateTime dont la propriété Kind inclut des informations de fuseau horaire. Il peut indiquer que l’heure est la suivante :

• Temps universel coordonné (System.DateTimeKind.Utc).
• Heure dans le fuseau horaire local (System.DateTimeKind.Local).
• Heure dans un fuseau horaire inconnu (System.DateTimeKind.Unspecified).

En règle générale, la méthode Parse retourne un objet DateTime dont la propriété Kind est DateTimeKind.Unspecified. Toutefois, la méthode Parse peut également effectuer une conversion de fuseau horaire et définir la valeur de la propriété Kind différemment, en fonction des valeurs des paramètres s et styles :

Si	Conversion de fuseau horaire	Kind, propriété
s contient des informations de fuseau horaire.	La date et l’heure sont converties en heure dans le fuseau horaire local.	DateTimeKind.Local
s contient des informations de fuseau horaire et styles inclut l’indicateur de AdjustToUniversal.	La date et l’heure sont converties en heure universelle coordonnée (UTC).	DateTimeKind.Utc
s contient l’indicateur de fuseau horaire Z ou GMT, et styles inclut l’indicateur de RoundtripKind.	La date et l’heure sont interprétées comme UTC.	DateTimeKind.Utc

L’exemple suivant convertit les chaînes de date qui contiennent des informations de fuseau horaire en heure dans le fuseau horaire local :

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

open System

let dateStrings = 
    [ "2008-05-01T07:34:42-5:00"
      "2008-05-01 7:34:42Z"
      "Thu, 01 May 2008 07:34:42 GMT" ]

for dateString in dateStrings do
    let convertedDate = DateTime.Parse dateString
    printfn $"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é Kind de date et d’heure pendant une opération de mise en forme et d’analyse à l’aide de l’indicateur de DateTimeStyles.RoundtripKind. L’exemple suivant montre comment l’indicateur de RoundtripKind affecte l’opération d’analyse sur DateTime valeurs converties en chaînes à l’aide du spécificateur de format « o », « r » ou « u ».

   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.

let 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 formattedDate in formattedDates do
    printfn $"{formattedDate}"
    let roundtripDate = DateTime.Parse(formattedDate, null, DateTimeStyles.RoundtripKind)
    printfn $"   With RoundtripKind flag: {roundtripDate} {roundtripDate.Kind} time."

    let noRoundtripDate = DateTime.Parse(formattedDate, null, DateTimeStyles.None)
    printfn $"   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)

Source:

DateTime.cs

Convertit la représentation sous forme de chaîne d’une date et d’une heure en son DateTime équivalent à l’aide des conventions de la culture actuelle.

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 qui contient une date et une heure à convertir. Pour plus d’informations, consultez La chaîne à analyser.

Retours

DateTime

Objet équivalent à la date et à l’heure contenues dans s.

Exceptions

ArgumentNullException

s est null.

FormatException

s ne contient pas de représentation sous forme de chaîne valide d’une date et d’une heure.

Exemples

L’exemple suivant analyse la représentation sous forme de chaîne de plusieurs valeurs de date et d’heure par :

• À l’aide du fournisseur de format par défaut, qui fournit les conventions de mise en forme de la culture actuelle de l’ordinateur utilisé pour produire l’exemple de sortie. La sortie de cet exemple reflète les conventions de mise en forme de la culture en-US.

• Utilisation de la valeur de style par défaut, qui est AllowWhiteSpaces.

Il gère l’exception FormatException levée lorsque la méthode tente d’analyser la représentation sous forme de chaîne d’une date et d’une heure à l’aide de conventions de mise en forme d’une autre culture. Il montre également comment analyser avec succès une valeur de date et d’heure qui n’utilise pas les conventions de mise en forme de la culture actuelle.

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.

open System
open System.Globalization

[<EntryPoint>]
let 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
    let dateString = "2/16/2008 12:15:12 PM"
    try
        let dateValue = DateTime.Parse dateString
        printfn $"'{dateString}' converted to {dateValue}."
    with :? FormatException ->
        printfn $"Unable to convert '{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.
    let dateString = "16/02/2008 12:15:12"
    try
        let dateValue = DateTime.Parse dateString
        printfn $"'{dateString}' converted to {dateValue}."
    with :? 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
        let dateValue = DateTime.Parse(dateString, CultureInfo("fr-FR", false))
        printfn $"'{dateString}' converted to {dateValue}."
    with :? FormatException ->
        printfn $"Unable to convert '{dateString}'."

    // Parse string with date but no time component.
    let dateString = "2/16/2008"
    try
        let dateValue = DateTime.Parse dateString
        printfn $"'{dateString}' converted to {dateValue}."
    with :? FormatException ->
        printfn $"Unable to convert '{dateString}'."

    0

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

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 dans s en heure locale. Sinon, il n’effectue aucune conversion de fuseau horaire et retourne une valeur DateTime dont la propriété Kind est DateTimeKind.Unspecified.

Cette surcharge tente d’analyser s à l’aide des conventions de mise en forme de la culture actuelle. La culture actuelle est indiquée par la propriété CurrentCulture. 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 Parse(String, IFormatProvider, DateTimeStyles).

Cette surcharge tente d’analyser s en utilisant DateTimeStyles.AllowWhiteSpaces style.

Voir aussi

• TryParse
• CultureInfo
• DateTimeFormatInfo
• analyse des chaînes de date et d’heure dans le .NET Framework
• chaînes de format de date et d’heure standard
• chaînes de format de date et d’heure personnalisées

Parse(ReadOnlySpan<Char>, IFormatProvider)

Source:

DateTime.cs

Analyse une étendue de caractères en une valeur.

public:
 static DateTime Parse(ReadOnlySpan<char> s, IFormatProvider ^ provider) = ISpanParsable<DateTime>::Parse;

public static DateTime Parse (ReadOnlySpan<char> s, IFormatProvider? provider);

static member Parse : ReadOnlySpan<char> * IFormatProvider -> DateTime

Public Shared Function Parse (s As ReadOnlySpan(Of Char), provider As IFormatProvider) As DateTime

Paramètres

s

ReadOnlySpan<Char>

Étendue de caractères à analyser.

provider

IFormatProvider

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

Retours

DateTime

Résultat de l’analyse s.

Implémente

Parse(ReadOnlySpan<Char>, IFormatProvider)

Parse(String, IFormatProvider)

Source:

DateTime.cs

Convertit la représentation sous forme de chaîne d’une date et d’une heure en son DateTime équivalent à l’aide d’informations de format propres à la culture.

public:
 static DateTime Parse(System::String ^ s, IFormatProvider ^ provider) = IParsable<DateTime>::Parse;

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 qui contient une date et une heure à convertir. Pour plus d’informations, consultez La chaîne à analyser.

provider

IFormatProvider

Objet qui fournit des informations de format spécifiques à la culture sur s. Consultez conventions d’analyse et de culture

Retours

DateTime

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

Implémente

Parse(String, IFormatProvider)

Exceptions

ArgumentNullException

s est null.

FormatException

s ne contient pas de représentation sous forme de chaîne valide d’une date et d’une heure.

Exemples

L’exemple suivant analyse un tableau de chaînes de date à l’aide des conventions des cultures en-US, fr-FRet de-DE. 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.

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.

open System
open System.Globalization

// Define cultures to be used to parse dates.
let cultures = 
    [ CultureInfo.CreateSpecificCulture "en-US"
      CultureInfo.CreateSpecificCulture "fr-FR"
      CultureInfo.CreateSpecificCulture "de-DE" ]

// Define string representations of a date to be parsed.
let dateStrings = 
    [ "01/10/2009 7:34 PM"
      "10.01.2009 19:34"
      "10-1-2009 19:34" ]

// Parse dates using each culture.
for culture in cultures do
    printfn $"Attempted conversions using {culture.Name} culture."
    for dateString in dateStrings do
        try
            let dateValue = DateTime.Parse(dateString, culture)
            printfn $"""   Converted '{dateString}' to {dateValue.ToString("f", culture)}."""
        with :? FormatException ->
            printfn $"   Unable to convert '{dateString}' for culture {culture.Name}." 
    printfn ""


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

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 dans s en heure locale. Sinon, il n’effectue aucune conversion de fuseau horaire et retourne une valeur DateTime dont la propriété Kind est DateTimeKind.Unspecified.

Cette surcharge tente d’analyser s à l’aide du style DateTimeStyles.AllowWhiteSpaces.

Voir aussi

• TryParse
• CultureInfo
• DateTimeFormatInfo
• analyse des chaînes de date et d’heure dans le .NET Framework
• chaînes de format de date et d’heure standard
• chaînes de format de date et d’heure personnalisées

Parse(ReadOnlySpan<Char>, IFormatProvider, DateTimeStyles)

Source:

DateTime.cs

Convertit une étendue de mémoire qui contient une représentation sous forme de chaîne d’une date et d’une heure en son équivalent DateTime en utilisant des informations de format propres à la culture et un style de mise en forme.

public static DateTime Parse (ReadOnlySpan<char> s, IFormatProvider? provider = default, 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 = Nothing, Optional styles As DateTimeStyles = System.Globalization.DateTimeStyles.None) As DateTime

Paramètres

s

ReadOnlySpan<Char>

Étendue de mémoire qui contient la chaîne à analyser. Pour plus d’informations, consultez La chaîne à analyser.

provider

IFormatProvider

Objet qui fournit des informations de format spécifiques à la culture sur s. Consultez conventions d’analyse et de culture

styles

DateTimeStyles

Combinaison de bits des valeurs d’énumération qui indique les éléments de style qui peuvent être présents dans s pour que l’opération d’analyse réussisse, et qui définit comment interpréter la date analysée par rapport au fuseau horaire actuel ou à la date actuelle. Une valeur classique à spécifier est None.

Retours

DateTime

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

Exceptions

FormatException

s ne contient pas de représentation sous forme de chaîne valide d’une date et d’une heure.

ArgumentException

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

Parse(String, IFormatProvider, DateTimeStyles)

Source:

DateTime.cs

Convertit la représentation sous forme de chaîne d’une date et d’une heure en son équivalent DateTime à l’aide d’informations de format propres à la culture et d’un style de mise en forme.

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 qui contient une date et une heure à convertir. Pour plus d’informations, consultez La chaîne à analyser.

provider

IFormatProvider

Objet qui fournit des informations de mise en forme spécifiques à la culture sur s. Consultez conventions d’analyse et de culture

styles

DateTimeStyles

Combinaison de bits des valeurs d’énumération qui indique les éléments de style qui peuvent être présents dans s pour que l’opération d’analyse réussisse, et qui définit comment interpréter la date analysée par rapport au fuseau horaire actuel ou à la date actuelle. Une valeur classique à spécifier est None.

Retours

DateTime

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

Exceptions

ArgumentNullException

s est null.

FormatException

s ne contient pas de représentation sous forme de chaîne valide d’une date et d’une heure.

ArgumentException

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

Exemples

L’exemple suivant illustre la méthode Parse(String, IFormatProvider, DateTimeStyles) et affiche la valeur de la propriété Kind des valeurs de DateTime résultantes.

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.

open System
open System.Globalization

[<EntryPoint>]
let main _ =
    // Parse a date and time with no styles.
    let dateString = "03/01/2009 10:00 AM"
    let culture = CultureInfo.CreateSpecificCulture "en-US"
    let styles = DateTimeStyles.None
    try
        let result = DateTime.Parse(dateString, culture, styles)
        printfn $"{dateString} converted to {result} {result.Kind}."
    with :? FormatException ->
        printfn $"Unable to convert {dateString} to a date and time."

    // Parse the same date and time with the AssumeLocal style.
    let styles = DateTimeStyles.AssumeLocal
    try
        let result = DateTime.Parse(dateString, culture, styles)
        printfn $"{dateString} converted to {result} {result.Kind}."
    with :? FormatException ->
        printfn $"Unable to convert {dateString} to a date and time."

    // 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.
    let dateString = "2009/03/01T10:00:00-5:00"
    let styles = DateTimeStyles.AssumeLocal
    try
        let result = DateTime.Parse(dateString, culture, styles)
        printfn $"{dateString} converted to {result} {result.Kind}."
    with :? FormatException ->
        printfn $"Unable to convert {dateString} to a date and time."

    // Attempt to convert a string in improper ISO 8601 format.
    let dateString = "03/01/2009T10:00:00-5:00"
    try
        let result = DateTime.Parse(dateString, culture, styles)
        printfn $"{dateString} converted to {result} {result.Kind}."
    with :? FormatException ->
        printfn $"Unable to convert {dateString} to a date and time."

    // Assume a date and time string formatted for the fr-FR culture is the local
    // time and convert it to UTC.
    let dateString = "2008-03-01 10:00"
    let culture = CultureInfo.CreateSpecificCulture "fr-FR"
    let styles = DateTimeStyles.AdjustToUniversal ||| DateTimeStyles.AssumeLocal
    try
        let result = DateTime.Parse(dateString, culture, styles)
        printfn $"{dateString} converted to {result} {result.Kind}."
    with :? FormatException ->
        printfn $"Unable to convert {dateString} to a date and time."

    0

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

Remarques

Cette surcharge de méthode convertit la date et l’heure dans s et définit la propriété Kind de la valeur de DateTime retournée comme suit :

Si	Conversion de fuseau horaire	Kind, propriété
s ne contient aucune information de fuseau horaire.	Aucun.	DateTimeKind.Unspecified
s contient des informations de fuseau horaire.	À l’heure dans le fuseau horaire local	DateTimeKind.Local
s contient des informations de fuseau horaire et styles inclut l’indicateur de DateTimeStyles.AdjustToUniversal.	À temps universel coordonné (UTC)	DateTimeKind.Utc
s contient l’indicateur de fuseau horaire Z ou GMT, et styles inclut le DateTimeStyles.RoundtripKind.	Aucun.	DateTimeKind.Utc

Voir aussi

• TryParse
• CultureInfo
• DateTimeFormatInfo
• analyse des chaînes de date et d’heure dans le .NET Framework
• chaînes de format de date et d’heure standard
• chaînes de format de date et d’heure personnalisées
• Comment : valeurs de date et d’heure aller-retour