DateTimeOffset.TryParseExact Méthode

Référence

Définition

Espace de noms:: System

Assembly:: System.Runtime.dll

Assembly:: mscorlib.dll

Assembly:: netstandard.dll

Important

Certaines informations portent sur la préversion du produit qui est susceptible d’être en grande partie modifiée avant sa publication. Microsoft exclut toute garantie, expresse ou implicite, concernant les informations fournies ici.

Convertit la représentation sous forme de chaîne spécifiée d’une date et d’une heure en son équivalent DateTimeOffset. Le format de la représentation sous forme de chaîne doit correspondre exactement à un format spécifié.

Surcharges

TryParseExact(String, String[], IFormatProvider, DateTimeStyles, DateTimeOffset)	Convertit la représentation sous forme de chaîne spécifiée d’une date et d’une heure en son DateTimeOffset équivalent à l’aide du tableau de formats, des informations de format spécifiques à la culture et du style spécifiés. Le format de la représentation sous forme de chaîne doit correspondre exactement à l’un des formats spécifiés.
TryParseExact(ReadOnlySpan<Char>, ReadOnlySpan<Char>, IFormatProvider, DateTimeStyles, DateTimeOffset)	Convertit la représentation d’une date et d’une heure dans une étendue de caractères en son équivalent DateTimeOffset à l’aide des informations de format spécifiques à la culture et au format spécifiés. Le format de la représentation de date et d’heure doit correspondre exactement au format spécifié.
TryParseExact(ReadOnlySpan<Char>, String[], IFormatProvider, DateTimeStyles, DateTimeOffset)	Convertit la représentation d’une date et d’une heure dans une étendue de caractères en son équivalent DateTimeOffset à l’aide des formats spécifiés, des informations de format propres à la culture et du style. Le format de la représentation de date et d’heure doit correspondre exactement à l’un des formats spécifiés.
TryParseExact(String, String, IFormatProvider, DateTimeStyles, DateTimeOffset)	Convertit la représentation sous forme de chaîne spécifiée d’une date et d’une heure en son DateTimeOffset équivalent à l’aide du format spécifié, des informations de format propres à la culture et du style. Le format de la représentation sous forme de chaîne doit correspondre exactement au format spécifié.

TryParseExact(String, String[], IFormatProvider, DateTimeStyles, DateTimeOffset)

Source:: DateTimeOffset.cs

Source:: DateTimeOffset.cs

Source:: DateTimeOffset.cs

Convertit la représentation sous forme de chaîne spécifiée d’une date et d’une heure en son DateTimeOffset équivalent à l’aide du tableau de formats, des informations de format spécifiques à la culture et du style spécifiés. Le format de la représentation sous forme de chaîne doit correspondre exactement à l’un des formats spécifiés.

public:
 static bool TryParseExact(System::String ^ input, cli::array <System::String ^> ^ formats, IFormatProvider ^ formatProvider, System::Globalization::DateTimeStyles styles, [Runtime::InteropServices::Out] DateTimeOffset % result);

public static bool TryParseExact (string input, string[] formats, IFormatProvider formatProvider, System.Globalization.DateTimeStyles styles, out DateTimeOffset result);

public static bool TryParseExact (string? input, string?[]? formats, IFormatProvider? formatProvider, System.Globalization.DateTimeStyles styles, out DateTimeOffset result);

static member TryParseExact : string * string[] * IFormatProvider * System.Globalization.DateTimeStyles * DateTimeOffset -> bool

Public Shared Function TryParseExact (input As String, formats As String(), formatProvider As IFormatProvider, styles As DateTimeStyles, ByRef result As DateTimeOffset) As Boolean

Paramètres

input: String

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

formats: String[]

Tableau qui définit les formats attendus de input.

formatProvider: IFormatProvider

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

styles: DateTimeStyles

Combinaison de valeurs d’énumération au niveau du bit qui indique le format autorisé d’entrée. Une valeur classique à spécifier est None.

result: DateTimeOffset

Lorsque la méthode est retournée, contient le DateTimeOffset équivalent à la date et à l’heure de input, si la conversion a réussi ou DateTimeOffset.MinValue, si la conversion a échoué. La conversion échoue si l'input ne contient pas de représentation sous forme de chaîne valide d’une date et d’une heure, ou ne contient pas la date et l’heure dans le format attendu défini par formats, ou si formats est null. Ce paramètre est passé non initialisé.

Retours

Boolean

true si le paramètre input est correctement converti ; sinon, false.

Exceptions

ArgumentException

styles inclut une valeur DateTimeStyles non définie.

-ou-

NoCurrentDateDefault n’est pas pris en charge.

-ou-

styles inclut des valeurs de DateTimeStyles mutuellement exclusives.

Exemples

L’exemple suivant définit plusieurs formats d’entrée pour la représentation sous forme de chaîne d’une valeur de date et d’heure et de décalage, puis transmet la chaîne entrée par l’utilisateur à la méthode TryParseExact(String, String[], IFormatProvider, DateTimeStyles, DateTimeOffset).

TextReader conIn = Console.In;
TextWriter conOut = Console.Out;
int tries = 0;
string input = String.Empty;

string[] formats = new string[] {"M/dd/yyyy HH:m zzz", "MM/dd/yyyy HH:m zzz",
                                 "M/d/yyyy HH:m zzz", "MM/d/yyyy HH:m zzz",
                                 "M/dd/yy HH:m zzz", "MM/dd/yy HH:m zzz",
                                 "M/d/yy HH:m zzz", "MM/d/yy HH:m zzz",
                                 "M/dd/yyyy H:m zzz", "MM/dd/yyyy H:m zzz",
                                 "M/d/yyyy H:m zzz", "MM/d/yyyy H:m zzz",
                                 "M/dd/yy H:m zzz", "MM/dd/yy H:m zzz",
                                 "M/d/yy H:m zzz", "MM/d/yy H:m zzz",
                                 "M/dd/yyyy HH:mm zzz", "MM/dd/yyyy HH:mm zzz",
                                 "M/d/yyyy HH:mm zzz", "MM/d/yyyy HH:mm zzz",
                                 "M/dd/yy HH:mm zzz", "MM/dd/yy HH:mm zzz",
                                 "M/d/yy HH:mm zzz", "MM/d/yy HH:mm zzz",
                                 "M/dd/yyyy H:mm zzz", "MM/dd/yyyy H:mm zzz",
                                 "M/d/yyyy H:mm zzz", "MM/d/yyyy H:mm zzz",
                                 "M/dd/yy H:mm zzz", "MM/dd/yy H:mm zzz",
                                 "M/d/yy H:mm zzz", "MM/d/yy H:mm zzz"};
IFormatProvider provider = CultureInfo.InvariantCulture.DateTimeFormat;
DateTimeOffset result;

do {
   conOut.WriteLine("Enter a date, time, and offset (MM/DD/YYYY HH:MM +/-HH:MM),");
   conOut.Write("Then press Enter: ");
   input = conIn.ReadLine();
   conOut.WriteLine();
   if (DateTimeOffset.TryParseExact(input, formats, provider,
                                   DateTimeStyles.AllowWhiteSpaces,
                                   out result))
   {
      break;
   }
   else
   {
      Console.WriteLine("Unable to parse {0}.", input);
      tries++;
   }
} while (tries < 3);
if (tries >= 3)
   Console.WriteLine("Exiting application without parsing {0}", input);
else
   Console.WriteLine("{0} was converted to {1}", input, result.ToString());
// Some successful sample interactions with the user might appear as follows:
//    Enter a date, time, and offset (MM/DD/YYYY HH:MM +/-HH:MM),
//    Then press Enter: 12/08/2007 6:54 -6:00
//
//    12/08/2007 6:54 -6:00 was converted to 12/8/2007 6:54:00 AM -06:00
//
//    Enter a date, time, and offset (MM/DD/YYYY HH:MM +/-HH:MM),
//    Then press Enter: 12/8/2007 06:54 -06:00
//
//    12/8/2007 06:54 -06:00 was converted to 12/8/2007 6:54:00 AM -06:00
//
//    Enter a date, time, and offset (MM/DD/YYYY HH:MM +/-HH:MM),
//    Then press Enter: 12/5/07 6:54 -6:00
//
//    12/5/07 6:54 -6:00 was converted to 12/5/2007 6:54:00 AM -06:00

let mutable result = None    
let mutable tries = 0
let mutable input = ""

let formats = 
    [| "M/dd/yyyy HH:m zzz"; "MM/dd/yyyy HH:m zzz"
       "M/d/yyyy HH:m zzz"; "MM/d/yyyy HH:m zzz"
       "M/dd/yy HH:m zzz"; "MM/dd/yy HH:m zzz"
       "M/d/yy HH:m zzz"; "MM/d/yy HH:m zzz"
       "M/dd/yyyy H:m zzz"; "MM/dd/yyyy H:m zzz"
       "M/d/yyyy H:m zzz"; "MM/d/yyyy H:m zzz"
       "M/dd/yy H:m zzz"; "MM/dd/yy H:m zzz"
       "M/d/yy H:m zzz"; "MM/d/yy H:m zzz"
       "M/dd/yyyy HH:mm zzz"; "MM/dd/yyyy HH:mm zzz"
       "M/d/yyyy HH:mm zzz"; "MM/d/yyyy HH:mm zzz"
       "M/dd/yy HH:mm zzz"; "MM/dd/yy HH:mm zzz"
       "M/d/yy HH:mm zzz"; "MM/d/yy HH:mm zzz"
       "M/dd/yyyy H:mm zzz"; "MM/dd/yyyy H:mm zzz"
       "M/d/yyyy H:mm zzz"; "MM/d/yyyy H:mm zzz"
       "M/dd/yy H:mm zzz"; "MM/dd/yy H:mm zzz"
       "M/d/yy H:mm zzz"; "MM/d/yy H:mm zzz" |]
let provider = CultureInfo.InvariantCulture.DateTimeFormat

while tries < 3 && result.IsNone do
    printfn "Enter a date, time, and offset (MM/DD/YYYY HH:MM +/-HH:MM),"
    printf "Then press Enter: "
    input <- stdin.ReadLine()
    printfn ""
    match DateTimeOffset.TryParseExact(input, formats, provider, DateTimeStyles.AllowWhiteSpaces) with
    | true, dto ->
        result <- Some dto
    | _ ->
        printfn $"Unable to parse {input}."
    tries <- tries + 1

match result with
| Some result ->
    printfn $"{input} was converted to {result}"
| None ->
    printfn $"Exiting application without parsing {input}"

// Some successful sample interactions with the user might appear as follows:
//    Enter a date, time, and offset (MM/DD/YYYY HH:MM +/-HH:MM),
//    Then press Enter: 12/08/2007 6:54 -6:00
//
//    12/08/2007 6:54 -6:00 was converted to 12/8/2007 6:54:00 AM -06:00
//
//    Enter a date, time, and offset (MM/DD/YYYY HH:MM +/-HH:MM),
//    Then press Enter: 12/8/2007 06:54 -06:00
//
//    12/8/2007 06:54 -06:00 was converted to 12/8/2007 6:54:00 AM -06:00
//
//    Enter a date, time, and offset (MM/DD/YYYY HH:MM +/-HH:MM),
//    Then press Enter: 12/5/07 6:54 -6:00
//
//    12/5/07 6:54 -6:00 was converted to 12/5/2007 6:54:00 AM -06:00

 Dim conIn As TextReader = Console.In
 Dim conOut As TextWriter = Console.Out
 Dim tries As Integer = 0
 Dim input As String = String.Empty
 Dim formats() As String = {"M/dd/yyyy HH:m zzz", "MM/dd/yyyy HH:m zzz", _
                            "M/d/yyyy HH:m zzz", "MM/d/yyyy HH:m zzz", _
                            "M/dd/yy HH:m zzz", "MM/dd/yy HH:m zzz", _
                            "M/d/yy HH:m zzz", "MM/d/yy HH:m zzz", _                                 
                            "M/dd/yyyy H:m zzz", "MM/dd/yyyy H:m zzz", _
                            "M/d/yyyy H:m zzz", "MM/d/yyyy H:m zzz", _
                            "M/dd/yy H:m zzz", "MM/dd/yy H:m zzz", _
                            "M/d/yy H:m zzz", "MM/d/yy H:m zzz", _                               
                            "M/dd/yyyy HH:mm zzz", "MM/dd/yyyy HH:mm zzz", _
                            "M/d/yyyy HH:mm zzz", "MM/d/yyyy HH:mm zzz", _
                            "M/dd/yy HH:mm zzz", "MM/dd/yy HH:mm zzz", _
                            "M/d/yy HH:mm zzz", "MM/d/yy HH:mm zzz", _                                 
                            "M/dd/yyyy H:mm zzz", "MM/dd/yyyy H:mm zzz", _
                            "M/d/yyyy H:mm zzz", "MM/d/yyyy H:mm zzz", _
                            "M/dd/yy H:mm zzz", "MM/dd/yy H:mm zzz", _
                            "M/d/yy H:mm zzz", "MM/d/yy H:mm zzz"}   
 Dim provider As IFormatProvider = CultureInfo.InvariantCulture.DateTimeFormat
 Dim result As DateTimeOffset

 Do 
    conOut.WriteLine("Enter a date, time, and offset (MM/DD/YYYY HH:MM +/-HH:MM),")
    conOut.Write("Then press Enter: ")
    input = conIn.ReadLine()
    conOut.WriteLine() 
    If DateTimeOffset.TryParseExact(input, formats, provider, _
                                    DateTimeStyles.AllowWhiteSpaces, _
                                    result) Then
       Exit Do
    Else
       Console.WriteLine("Unable to parse {0}.", input)      
       tries += 1
    End If
 Loop While tries < 3
 If tries >= 3 Then
    Console.WriteLine("Exiting application without parsing {0}", input)
 Else
    Console.WriteLine("{0} was converted to {1}", input, result.ToString())                                                     
 End If 
 ' Some successful sample interactions with the user might appear as follows:
 '    Enter a date, time, and offset (MM/DD/YYYY HH:MM +/-HH:MM),
 '    Then press Enter: 12/08/2007 6:54 -6:00
 '    
 '    12/08/2007 6:54 -6:00 was converted to 12/8/2007 6:54:00 AM -06:00         
 '    
 '    Enter a date, time, and offset (MM/DD/YYYY HH:MM +/-HH:MM),
 '    Then press Enter: 12/8/2007 06:54 -06:00
 '    
 '    12/8/2007 06:54 -06:00 was converted to 12/8/2007 6:54:00 AM -06:00
 '    
 '    Enter a date, time, and offset (MM/DD/YYYY HH:MM +/-HH:MM),
 '    Then press Enter: 12/5/07 6:54 -6:00
 '    
 '    12/5/07 6:54 -6:00 was converted to 12/5/2007 6:54:00 AM -06:00

Remarques

La méthode TryParseExact(String, String[], IFormatProvider, DateTimeStyles, DateTimeOffset) analyse la représentation sous forme de chaîne d’une date qui correspond à l’un des modèles attribués au tableau formats. Si la chaîne input ne correspond à aucun de ces modèles avec des variantes définies par le paramètre styles, l’opération d’analyse échoue et la méthode retourne false. En plus de comparer input à plusieurs chaînes qui contiennent des spécificateurs de format, cette surcharge se comporte de la même façon que la méthode DateTimeOffset.ParseExact(String, String[], IFormatProvider, DateTimeStyles).

Le paramètre formats est un tableau de chaînes dont les éléments contiennent un spécificateur de format standard unique ou un ou plusieurs spécificateurs de format personnalisés qui définissent le modèle possible de input. Pour plus d’informations sur les codes de mise en forme valides, consultez chaînes de format de date et d’heure standard et chaînes de format de date et d’heure personnalisées. Si l’élément mis en correspondance dans formats inclut l'z, zzou zzz spécificateurs de format personnalisé pour indiquer qu’un décalage doit être présent dans input, ce décalage doit inclure un signe négatif ou un signe positif. Si le signe est manquant, l’opération d’analyse échoue et la méthode retourne false.

Important

L’utilisation du paramètre formats de cette surcharge pour spécifier plusieurs formats peut contribuer à réduire la frustration de nombreux utilisateurs lorsqu’ils entrent des dates et des heures. En particulier, la possibilité de définir plusieurs modèles d’entrée permet à une application de gérer les représentations de date et d’heure qui peuvent inclure ou manquer de zéros non significatifs en mois, jours, heures, minutes et secondes. L’exemple fournit une illustration de ceci.

Si l’élément mis en correspondance dans formats nécessite que input contiennent une date, mais pas une heure, l’objet DateTimeOffset résultant est affecté à l’heure de minuit (0:00:00). Si l’élément mis en correspondance dans formats nécessite que l’entrée contienne une heure, mais pas une date, l’objet DateTimeOffset résultant est affecté à la date actuelle sur le système local. Si l’élément mis en correspondance dans formats ne nécessite pas que input contiennent un décalage, le décalage de l’objet DateTimeOffset résultant dépend de la valeur du paramètre styles. Si styles inclut AssumeLocal, le décalage du fuseau horaire local est affecté à l’objet DateTimeOffset. Si styles inclut AssumeUniversal, le décalage UTC (Temps universel coordonné) ou +00:00 est affecté à l’objet DateTimeOffset. Si aucune valeur n’est spécifiée, le décalage du fuseau horaire local est utilisé.

Les symboles et chaînes de date et d’heure spécifiques utilisés dans input sont définis par le paramètre formatProvider. Il en va de même pour le modèle précis de input si l’élément correspondant de formats est une chaîne de spécificateur de format standard. Le paramètre formatProvider peut être l’un des éléments suivants :

Objet CultureInfo qui représente la culture en fonction de laquelle input est interprété. L’objet DateTimeFormatInfo retourné par la propriété CultureInfo.DateTimeFormat définit les symboles et la mise en forme dans input.
Objet DateTimeFormatInfo qui définit le format des données de date et d’heure.

Si formatprovider est null, l’objet CultureInfo qui correspond à la culture actuelle est utilisé.

Le paramètre styles définit si l’espace blanc est autorisé dans la chaîne d’entrée, indique comment les chaînes sans composant de décalage explicite sont analysées et prennent en charge la conversion UTC dans le cadre de l’opération d’analyse. Tous les membres de l’énumération DateTimeStyles sont pris en charge, sauf NoCurrentDateDefault. Le tableau suivant répertorie l’effet de chaque membre pris en charge.

membre `DateTimeStyles`	Comportement
AdjustToUniversal	Analyse `input` et, si nécessaire, la convertit en UTC. Il équivaut à analyser une chaîne, puis à appeler la méthode DateTimeOffset.ToUniversalTime de l’objet DateTimeOffset retourné.
AssumeLocal	Si l’élément mis en correspondance dans `formats` ne nécessite pas que `input` contiennent une valeur de décalage, l’objet DateTimeOffset retourné reçoit le décalage du fuseau horaire local. Il s’agit de la valeur par défaut.
AssumeUniversal	Si l’élément mis en correspondance dans `formats` ne nécessite pas que `input` contiennent une valeur de décalage, l’objet DateTimeOffset retourné reçoit le décalage UTC (+00:00).
AllowInnerWhite	Permet `input` d’inclure un espace blanc interne non spécifié par les éléments dans `formats`. Un espace blanc supplémentaire peut apparaître entre les composants de date et d’heure et dans des composants individuels (à l’exception du décalage) et est ignoré lors de l’analyse de la chaîne.
AllowLeadingWhite	Permet `input` d’inclure des espaces de début non spécifiés par les éléments dans `formats`. Elles sont ignorées lors de l’analyse de la chaîne.
AllowTrailingWhite	Permet `input` d’inclure des espaces de fin non spécifiés par les éléments dans `formats`. Elles sont ignorées lors de l’analyse de la chaîne.
AllowWhiteSpaces	Permet `input` d’inclure des espaces de début, de fin et d’intérieur non spécifiés par les éléments dans `formats`. Tous les espaces blancs supplémentaires non spécifiés dans l’élément correspondant dans `formats` sont ignorés lors de l’analyse de la chaîne.
None	Indique que l’espace blanc supplémentaire n’est pas autorisé dans `input`. L’espace blanc doit apparaître exactement comme spécifié dans un élément particulier dans `formats` pour qu’une correspondance réussie se produise. Il s’agit du comportement par défaut.
RoundtripKind	N’a aucun effet, car la structure DateTimeOffset n’inclut pas de propriété `Kind`.

Notes pour les appelants

Dans .NET Framework 4, le TryParseExact retourne false si la chaîne à analyser contient un composant d’heure et un indicateur AM/PM qui ne sont pas en accord. Dans .NET Framework 3.5 et versions antérieures, l’indicateur AM/PM est ignoré.

S’applique à

TryParseExact(ReadOnlySpan<Char>, ReadOnlySpan<Char>, IFormatProvider, DateTimeStyles, DateTimeOffset)

Source:: DateTimeOffset.cs

Source:: DateTimeOffset.cs

Source:: DateTimeOffset.cs

Convertit la représentation d’une date et d’une heure dans une étendue de caractères en son équivalent DateTimeOffset à l’aide des informations de format spécifiques à la culture et au format spécifiés. Le format de la représentation de date et d’heure doit correspondre exactement au format spécifié.

public:
 static bool TryParseExact(ReadOnlySpan<char> input, ReadOnlySpan<char> format, IFormatProvider ^ formatProvider, System::Globalization::DateTimeStyles styles, [Runtime::InteropServices::Out] DateTimeOffset % result);

public static bool TryParseExact (ReadOnlySpan<char> input, ReadOnlySpan<char> format, IFormatProvider? formatProvider, System.Globalization.DateTimeStyles styles, out DateTimeOffset result);

public static bool TryParseExact (ReadOnlySpan<char> input, ReadOnlySpan<char> format, IFormatProvider formatProvider, System.Globalization.DateTimeStyles styles, out DateTimeOffset result);

static member TryParseExact : ReadOnlySpan<char> * ReadOnlySpan<char> * IFormatProvider * System.Globalization.DateTimeStyles * DateTimeOffset -> bool

Public Shared Function TryParseExact (input As ReadOnlySpan(Of Char), format As ReadOnlySpan(Of Char), formatProvider As IFormatProvider, styles As DateTimeStyles, ByRef result As DateTimeOffset) As Boolean

Paramètres

input: ReadOnlySpan<Char>

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

format: ReadOnlySpan<Char>

Spécificateur de format qui définit le format requis de input.

formatProvider: IFormatProvider

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

styles: DateTimeStyles

Combinaison de valeurs d’énumération au niveau du bit qui indique le format autorisé de input. Une valeur classique à spécifier est None.

result: DateTimeOffset

Lorsque la méthode est retournée, contient le DateTimeOffset équivalent à la date et à l’heure de input, si la conversion a réussi ou DateTimeOffset.MinValue si la conversion a échoué. La conversion échoue si la

Retours

Boolean

true si le paramètre input est correctement converti ; sinon, false.

Exceptions

ArgumentException

styles inclut une valeur DateTimeStyles non définie. -ou- NoCurrentDateDefault n’est pas pris en charge. -ou- styles inclut des valeurs d'DateTimeStyles mutuellement exclusives.

Remarques

Cette surcharge est semblable à la méthode DateTimeOffset.ParseExact(ReadOnlySpan<Char>, ReadOnlySpan<Char>, IFormatProvider, DateTimeStyles), sauf que cette méthode ne lève pas d’exception si la conversion échoue. Il analyse la représentation d’une date et d’une heure qui doivent correspondre exactement au modèle spécifié par le paramètre format. Si input ne correspond pas à ce modèle, avec certaines variations possibles de l’espace blanc défini par le paramètre styles, l’opération d’analyse échoue et la méthode retourne false.

Le paramètre format est une étendue de caractères qui contient un spécificateur de format standard unique ou un ou plusieurs spécificateurs de format personnalisés qui définissent le modèle requis de input. Pour plus d’informations sur les codes de mise en forme valides, consultez chaînes de format de date et d’heure standard et chaînes de format de date et d’heure personnalisées. Si format inclut le z, zzou zzz spécificateurs de format personnalisé pour indiquer qu’un décalage doit être présent dans input, ce décalage doit inclure un signe négatif ou un signe positif. Si le signe est manquant, l’opération d’analyse échoue et la méthode retourne false.

Si format exige que input contiennent une date, mais pas une heure, l’objet DateTimeOffset résultant est affecté à l’heure de minuit (0:00:00). Si format exige que input contiennent une heure, mais pas une date, l’objet DateTimeOffset résultant est affecté à la date actuelle sur le système local. Si format ne nécessite pas que input contiennent un décalage, le décalage de l’objet DateTimeOffset résultant dépend de la valeur du paramètre styles. Si styles inclut AssumeLocal, le décalage du fuseau horaire local est affecté à l’objet DateTimeOffset. Si styles inclut AssumeUniversal, le décalage UTC (Temps universel coordonné) ou +00:00 est affecté à l’objet DateTimeOffset. Si aucune valeur n’est spécifiée, le décalage du fuseau horaire local est utilisé.

Les symboles et chaînes de date et d’heure spécifiques utilisés dans input sont définis par le paramètre formatProvider. Il en va de même pour le modèle précis de input si format est une chaîne de spécificateur de format standard. Le paramètre formatProvider peut être l’un des éléments suivants :

Objet CultureInfo qui représente la culture en fonction de laquelle input est interprété. L’objet DateTimeFormatInfo retourné par la propriété CultureInfo.DateTimeFormat définit les symboles et les formats standard autorisés dans input.
Objet DateTimeFormatInfo qui définit le format des données de date et d’heure.

Si formatprovider est null, l’objet CultureInfo qui correspond à la culture actuelle est utilisé.

Le paramètre styles définit si l’espace blanc est autorisé dans la chaîne d’entrée, indique comment les chaînes sans composant de décalage explicite sont analysées et prend en charge la conversion UTC dans le cadre de l’opération d’analyse. Tous les membres de l’énumération DateTimeStyles sont pris en charge, sauf NoCurrentDateDefault. Le tableau suivant répertorie l’effet de chaque membre pris en charge.

membre `DateTimeStyles`	Comportement
AdjustToUniversal	Analyse `input` et, si nécessaire, la convertit en UTC. Elle équivaut à analyser une représentation de date et d’heure, puis à appeler la méthode DateTimeOffset.ToUniversalTime de l’objet DateTimeOffset retourné.
AssumeLocal	Si `format` ne nécessite pas que `input` contiennent une valeur de décalage, l’objet DateTimeOffset retourné reçoit le décalage du fuseau horaire local. Il s’agit du comportement par défaut.
AssumeUniversal	Si `format` ne nécessite pas que `input` contiennent une valeur de décalage, l’objet DateTimeOffset retourné reçoit le décalage UTC (+00:00).
AllowInnerWhite	Permet `input` d’inclure un espace blanc interne non spécifié par format. Un espace blanc supplémentaire peut apparaître entre les composants de date et d’heure et dans des composants individuels, autres que le décalage, et est ignoré lors de l’analyse de la chaîne.
AllowLeadingWhite	Permet `input` d’inclure des espaces de début non spécifiés par `format`. Elles sont ignorées lors de l’analyse de la chaîne.
AllowTrailingWhite	Permet `input` d’inclure des espaces de fin non spécifiés par `format`. Elles sont ignorées lors de l’analyse de la chaîne.
AllowWhiteSpaces	Permet `input` d’inclure des espaces de début, de fin et d’intérieur non spécifiés par `format`. Tous les espaces blancs supplémentaires non spécifiés dans `format` sont ignorés lors de l’analyse de la chaîne.
None	Indique que l’espace blanc supplémentaire n’est pas autorisé dans `input`. L’espace blanc doit apparaître exactement comme spécifié dans `format`. Il s’agit du comportement par défaut.
RoundtripKind	N’a aucun effet, car la structure DateTimeOffset n’inclut pas de propriété `Kind`.

S’applique à

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

Source:: DateTimeOffset.cs

Source:: DateTimeOffset.cs

Source:: DateTimeOffset.cs

Convertit la représentation d’une date et d’une heure dans une étendue de caractères en son équivalent DateTimeOffset à l’aide des formats spécifiés, des informations de format propres à la culture et du style. Le format de la représentation de date et d’heure doit correspondre exactement à l’un des formats spécifiés.

public:
 static bool TryParseExact(ReadOnlySpan<char> input, cli::array <System::String ^> ^ formats, IFormatProvider ^ formatProvider, System::Globalization::DateTimeStyles styles, [Runtime::InteropServices::Out] DateTimeOffset % result);

public static bool TryParseExact (ReadOnlySpan<char> input, string?[]? formats, IFormatProvider? formatProvider, System.Globalization.DateTimeStyles styles, out DateTimeOffset result);

public static bool TryParseExact (ReadOnlySpan<char> input, string[] formats, IFormatProvider formatProvider, System.Globalization.DateTimeStyles styles, out DateTimeOffset result);

static member TryParseExact : ReadOnlySpan<char> * string[] * IFormatProvider * System.Globalization.DateTimeStyles * DateTimeOffset -> bool

Public Shared Function TryParseExact (input As ReadOnlySpan(Of Char), formats As String(), formatProvider As IFormatProvider, styles As DateTimeStyles, ByRef result As DateTimeOffset) As Boolean

Paramètres

input: ReadOnlySpan<Char>

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

formats: String[]

Tableau de chaînes de format standard ou personnalisées qui définissent les formats acceptables de input.

formatProvider: IFormatProvider

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

styles: DateTimeStyles

Combinaison de valeurs d’énumération au niveau du bit qui indique le format autorisé de input. Une valeur classique à spécifier est None.

result: DateTimeOffset

Retours

Boolean

true si le paramètre input est correctement converti ; sinon, false.

Exceptions

ArgumentException

styles inclut une valeur DateTimeStyles non définie. -ou- NoCurrentDateDefault n’est pas pris en charge. -ou- styles inclut des valeurs d'DateTimeStyles mutuellement exclusives.

Remarques

Cette méthode analyse la représentation sous forme de chaîne d’une date qui correspond à l’un des modèles attribués au tableau formats. Si input ne correspond pas à l’un de ces modèles avec des variantes définies par le paramètre styles, l’opération d’analyse échoue et la méthode retourne false. En plus de comparer input à plusieurs chaînes qui contiennent des spécificateurs de format, cette surcharge se comporte de la même façon que la méthode DateTimeOffset.ParseExact(ReadOnlySpan<Char>, String[], IFormatProvider, DateTimeStyles).

Important

Si l’élément mis en correspondance dans formats nécessite que input contiennent une date, mais pas une heure, l’objet DateTimeOffset résultant est affecté à l’heure de minuit (0:00:00). Si l’élément mis en correspondance dans formats nécessite que l’entrée contienne une heure, mais pas une date, l’objet DateTimeOffset résultant est affecté à la date actuelle sur le système local. Si l’élément mis en correspondance dans formats ne nécessite pas que input contiennent un décalage, le décalage de l’objet DateTimeOffset résultant dépend de la valeur du paramètre styles. Si styles inclut DateTimeStyles.AssumeLocal, le décalage du fuseau horaire local est affecté à l’objet DateTimeOffset. Si styles inclut DateTimeStyles.AssumeUniversal, le décalage UTC (Temps universel coordonné) ou +00:00 est affecté à l’objet DateTimeOffset. Si aucune valeur n’est spécifiée, le décalage du fuseau horaire local est utilisé.

Les symboles de date et d’heure particuliers utilisés dans input sont définis par le paramètre formatProvider. Il en va de même pour le modèle précis de input si l’élément correspondant de formats est une chaîne de spécificateur de format standard. Le paramètre formatProvider peut être l’un des éléments suivants :

Objet CultureInfo qui représente la culture en fonction de laquelle input est interprété. L’objet DateTimeFormatInfo retourné par la propriété CultureInfo.DateTimeFormat définit les symboles et la mise en forme dans input.
Objet DateTimeFormatInfo qui définit le format des données de date et d’heure.

Si formatprovider est null, l’objet CultureInfo qui correspond à la culture actuelle est utilisé.

membre `DateTimeStyles`	Comportement
AdjustToUniversal	Analyse `input` et, si nécessaire, la convertit en UTC. Il équivaut à analyser une chaîne, puis à appeler la méthode DateTimeOffset.ToUniversalTime de l’objet DateTimeOffset retourné.
AssumeLocal	Si l’élément mis en correspondance dans `formats` ne nécessite pas que `input` contiennent une valeur de décalage, l’objet DateTimeOffset retourné reçoit le décalage du fuseau horaire local. Il s’agit de la valeur par défaut.
AssumeUniversal	Si l’élément mis en correspondance dans `formats` ne nécessite pas que `input` contiennent une valeur de décalage, l’objet DateTimeOffset retourné reçoit le décalage UTC (+00:00).
AllowInnerWhite	Permet `input` d’inclure un espace blanc interne non spécifié par les éléments dans `formats`. Un espace blanc supplémentaire peut apparaître entre les composants de date et d’heure et dans des composants individuels (à l’exception du décalage) et est ignoré lors de l’analyse de la chaîne.
AllowLeadingWhite	Permet `input` d’inclure des espaces de début non spécifiés par les éléments dans `formats`. Elles sont ignorées lors de l’analyse de la chaîne.
AllowTrailingWhite	Permet `input` d’inclure des espaces de fin non spécifiés par les éléments dans `formats`. Elles sont ignorées lors de l’analyse de la chaîne.
AllowWhiteSpaces	Permet `input` d’inclure des espaces de début, de fin et d’intérieur non spécifiés par les éléments dans `formats`. Tous les espaces blancs supplémentaires non spécifiés dans l’élément correspondant dans `formats` sont ignorés lors de l’analyse de la chaîne.
None	Indique que l’espace blanc supplémentaire n’est pas autorisé dans `input`. L’espace blanc doit apparaître exactement comme spécifié dans un élément particulier dans `formats` pour qu’une correspondance réussie se produise. Il s’agit du comportement par défaut.
RoundtripKind	N’a aucun effet, car la structure DateTimeOffset n’inclut pas de propriété `Kind`.

S’applique à

TryParseExact(String, String, IFormatProvider, DateTimeStyles, DateTimeOffset)

Source:: DateTimeOffset.cs

Source:: DateTimeOffset.cs

Source:: DateTimeOffset.cs

Convertit la représentation sous forme de chaîne spécifiée d’une date et d’une heure en son DateTimeOffset équivalent à l’aide du format spécifié, des informations de format propres à la culture et du style. Le format de la représentation sous forme de chaîne doit correspondre exactement au format spécifié.

public:
 static bool TryParseExact(System::String ^ input, System::String ^ format, IFormatProvider ^ formatProvider, System::Globalization::DateTimeStyles styles, [Runtime::InteropServices::Out] DateTimeOffset % result);

public static bool TryParseExact (string input, string format, IFormatProvider formatProvider, System.Globalization.DateTimeStyles styles, out DateTimeOffset result);

public static bool TryParseExact (string? input, string? format, IFormatProvider? formatProvider, System.Globalization.DateTimeStyles styles, out DateTimeOffset result);

static member TryParseExact : string * string * IFormatProvider * System.Globalization.DateTimeStyles * DateTimeOffset -> bool

Public Shared Function TryParseExact (input As String, format As String, formatProvider As IFormatProvider, styles As DateTimeStyles, ByRef result As DateTimeOffset) As Boolean

Paramètres

input: String

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

format: String

Spécificateur de format qui définit le format requis de input.

formatProvider: IFormatProvider

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

styles: DateTimeStyles

Combinaison de valeurs d’énumération au niveau du bit qui indique le format autorisé d’entrée. Une valeur classique à spécifier est None.

result: DateTimeOffset

Lorsque la méthode est retournée, contient le DateTimeOffset équivalent à la date et à l’heure de input, si la conversion a réussi ou DateTimeOffset.MinValue, si la conversion a échoué. La conversion échoue si le paramètre input est nullou ne contient pas de représentation sous forme de chaîne valide d’une date et d’une heure au format attendu défini par format et provider. Ce paramètre est passé non initialisé.

Retours

Boolean

true si le paramètre input est correctement converti ; sinon, false.

Exceptions

ArgumentException

styles inclut une valeur DateTimeStyles non définie.

-ou-

NoCurrentDateDefault n’est pas pris en charge.

-ou-

styles inclut des valeurs de DateTimeStyles mutuellement exclusives.

Exemples

L’exemple suivant utilise la méthode TryParseExact(String, String, IFormatProvider, DateTimeStyles, DateTimeOffset) avec des spécificateurs de format standard et personnalisés, la culture invariante et diverses valeurs de DateTimeStyles pour analyser plusieurs chaînes de date et d’heure.

string dateString, format;
DateTimeOffset result;
IFormatProvider provider = CultureInfo.InvariantCulture;

// Parse date-only value with invariant culture and assume time is UTC.
dateString = "06/15/2008";
format = "d";
if (DateTimeOffset.TryParseExact(dateString, format, provider,
                                 DateTimeStyles.AssumeUniversal,
                                 out result))
   Console.WriteLine("'{0}' converts to {1}.", dateString, result.ToString());
else
   Console.WriteLine("'{0}' is not in the correct format.", dateString);

// Parse date-only value with leading white space.
// Should return False because only trailing white space is
// specified in method call.
dateString = " 06/15/2008";
if (DateTimeOffset.TryParseExact(dateString, format, provider,
                                 DateTimeStyles.AllowTrailingWhite,
                                 out result))
   Console.WriteLine("'{0}' converts to {1}.", dateString, result.ToString());
else
   Console.WriteLine("'{0}' is not in the correct format.", dateString);

// Parse date and time value, and allow all white space.
dateString = " 06/15/   2008  15:15    -05:00";
format = "MM/dd/yyyy H:mm zzz";
if (DateTimeOffset.TryParseExact(dateString, format, provider,
                                 DateTimeStyles.AllowWhiteSpaces,
                                 out result))
   Console.WriteLine("'{0}' converts to {1}.", dateString, result.ToString());
else
   Console.WriteLine("'{0}' is not in the correct format.", dateString);

// Parse date and time and convert to UTC.
dateString = "  06/15/2008 15:15:30 -05:00";
format = "MM/dd/yyyy H:mm:ss zzz";
if (DateTimeOffset.TryParseExact(dateString, format, provider,
                                DateTimeStyles.AllowWhiteSpaces |
                                DateTimeStyles.AdjustToUniversal,
                                out result))
   Console.WriteLine("'{0}' converts to {1}.", dateString, result.ToString());
else
   Console.WriteLine("'{0}' is not in the correct format.", dateString);
// The example displays the following output:
//    '06/15/2008' converts to 6/15/2008 12:00:00 AM +00:00.
//    ' 06/15/2008' is not in the correct format.
//    ' 06/15/   2008  15:15    -05:00' converts to 6/15/2008 3:15:00 PM -05:00.
//    '  06/15/2008 15:15:30 -05:00' converts to 6/15/2008 8:15:30 PM +00:00.

let provider = CultureInfo.InvariantCulture

// Parse date-only value with invariant culture and assume time is UTC.
let dateString = "06/15/2008"
let format = "d"
match DateTimeOffset.TryParseExact(dateString, format, provider, DateTimeStyles.AssumeUniversal) with
| true, result ->
    printfn $"'{dateString}' converts to {result}."
| _ ->
    printfn $"'{dateString}' is not in the correct format."

// Parse date-only value with leading white space.
// Should return False because only trailing white space is
// specified in method call.
let dateString = " 06/15/2008"
match DateTimeOffset.TryParseExact(dateString, format, provider, DateTimeStyles.AllowTrailingWhite) with
| true, result ->
    printfn $"'{dateString}' converts to {result}."
| _ ->
    printfn $"'{dateString}' is not in the correct format."

// Parse date and time value, and allow all white space.
let dateString = " 06/15/   2008  15:15    -05:00"
let format = "MM/dd/yyyy H:mm zzz"
match DateTimeOffset.TryParseExact(dateString, format, provider, DateTimeStyles.AllowWhiteSpaces) with
| true, result ->
    printfn $"'{dateString}' converts to {result}."
| _ ->
    printfn $"'{dateString}' is not in the correct format."

// Parse date and time and convert to UTC.
let dateString = "  06/15/2008 15:15:30 -05:00"
let format = "MM/dd/yyyy H:mm:ss zzz"
match DateTimeOffset.TryParseExact(dateString, format, provider, DateTimeStyles.AllowWhiteSpaces ||| DateTimeStyles.AdjustToUniversal) with
| true, result ->
    printfn $"'{dateString}' converts to {result}."
| _ ->
    printfn $"'{dateString}' is not in the correct format."

// The example displays the following output:
//    '06/15/2008' converts to 6/15/2008 12:00:00 AM +00:00.
//    ' 06/15/2008' is not in the correct format.
//    ' 06/15/   2008  15:15    -05:00' converts to 6/15/2008 3:15:00 PM -05:00.
//    '  06/15/2008 15:15:30 -05:00' converts to 6/15/2008 8:15:30 PM +00:00.

Dim dateString, format As String  
Dim result As DateTimeOffset
Dim provider As CultureInfo = CultureInfo.InvariantCulture

' Parse date-only value with invariant culture and assume time is UTC.
dateString = "06/15/2008"
format = "d"
If DateTimeOffset.TryParseExact(dateString, format, provider, _
                                   DateTimeStyles.AssumeUniversal, _
                                   result) Then
   Console.WriteLine("'{0}' converts to {1}.", dateString, result.ToString())
Else
   Console.WriteLine("'{0}' is not in the correct format.", dateString)
End If 

' Parse date-only value with leading white space.
' Should return False because only trailing white space is  
' specified in method call.
dateString = " 06/15/2008"
If DateTimeOffset.TryParseExact(dateString, format, provider, _
                                DateTimeStyles.AllowTrailingWhite, _
                                result) Then
   Console.WriteLine("'{0}' converts to {1}.", dateString, result.ToString())
Else
   Console.WriteLine("'{0}' is not in the correct format.", dateString)
End If 

' Parse date and time value, and allow all white space.
dateString = " 06/15/   2008  15:15    -05:00"
format = "MM/dd/yyyy H:mm zzz"
If DateTimeOffset.TryParseExact(dateString, format, provider, _
                                DateTimeStyles.AllowWhiteSpaces, _
                                result) Then
   Console.WriteLine("'{0}' converts to {1}.", dateString, result.ToString())
Else
   Console.WriteLine("'{0}' is not in the correct format.", dateString)
End If 

' Parse date and time and convert to UTC.
dateString = "  06/15/2008 15:15:30 -05:00"   
format = "MM/dd/yyyy H:mm:ss zzz"       
If DateTimeOffset.TryParseExact(dateString, format, provider, _
                                DateTimeStyles.AllowWhiteSpaces Or _
                                DateTimeStyles.AdjustToUniversal, _
                                result) Then
   Console.WriteLine("'{0}' converts to {1}.", dateString, result.ToString())
Else
   Console.WriteLine("'{0}' is not in the correct format.", dateString)
End If 
' The example displays the following output:
'    '06/15/2008' converts to 6/15/2008 12:00:00 AM +00:00.
'    ' 06/15/2008' is not in the correct format.
'    ' 06/15/   2008  15:15    -05:00' converts to 6/15/2008 3:15:00 PM -05:00.
'    '  06/15/2008 15:15:30 -05:00' converts to 6/15/2008 8:15:30 PM +00:00.

L’exemple suivant utilise une variété de valeurs DateTimeStyles pour analyser un tableau de chaînes qui sont censées être conformes à ISO 8601. Comme le montre la sortie de l’exemple, les chaînes au format approprié ne parviennent pas à analyser si :

ils contiennent un espace blanc et un indicateur de DateTimeStyles approprié (par exemple, DateTimeStyles.AllowWhiteSpaces n’a pas été fourni dans l’appel de méthode.
ils contiennent des éléments de date et d’heure hors limites.

Les chaînes qui ne spécifient pas de décalage UTC sont supposées avoir le décalage du fuseau horaire local (dans ce cas, -07:00, qui reflète le décalage du fuseau horaire d’été du Pacifique), sauf si l’indicateur DateTimeStyles.AssumeUniversal est fourni dans l’appel de méthode. Dans ce cas, elles sont supposées être un temps coordonné universel.

open System
open System.Globalization

let parseWithISO8601 dateStrings styles =
    printfn $"Parsing with {styles}:"
    for dateString in dateStrings do
        match DateTimeOffset.TryParseExact(dateString, "O", null, styles) with
        | true, date ->
            printfn $"""   {dateString,-35} --> {date.ToString "yyyy-MM-dd HH:mm:ss.FF zzz"}"""
        | _ ->
            printfn $"   Unable to convert '{dateString}'"

let dateStrings = 
    [ "2018-08-18T12:45:16.0000000Z"
      "2018/08/18T12:45:16.0000000Z"
      "2018-18-08T12:45:16.0000000Z"
      "2018-08-18T12:45:16.0000000"
      " 2018-08-18T12:45:16.0000000Z "
      "2018-08-18T12:45:16.0000000+02:00"
      "2018-08-18T12:45:16.0000000-07:00" ]

parseWithISO8601 dateStrings DateTimeStyles.None
printfn "\n-----\n"
parseWithISO8601 dateStrings DateTimeStyles.AllowWhiteSpaces
printfn "\n-----\n"
parseWithISO8601 dateStrings DateTimeStyles.AdjustToUniversal
printfn "\n-----\n"
parseWithISO8601 dateStrings DateTimeStyles.AssumeLocal
printfn "\n-----\n"
parseWithISO8601 dateStrings DateTimeStyles.AssumeUniversal

// The example displays the following output:
//      Parsing with None:
//         2018-08-18T12:45:16.0000000Z        --> 2018-08-18 12:45:16 +00:00
//         Unable to convert '2018/08/18T12:45:16.0000000Z'
//         Unable to convert '2018-18-08T12:45:16.0000000Z'
//         2018-08-18T12:45:16.0000000         --> 2018-08-18 12:45:16 -07:00
//         Unable to convert ' 2018-08-18T12:45:16.0000000Z '
//         2018-08-18T12:45:16.0000000+02:00   --> 2018-08-18 12:45:16 +02:00
//         2018-08-18T12:45:16.0000000-07:00   --> 2018-08-18 12:45:16 -07:00
//
//      -----
//
//      Parsing with AllowWhiteSpaces:
//         2018-08-18T12:45:16.0000000Z        --> 2018-08-18 12:45:16 +00:00
//         Unable to convert '2018/08/18T12:45:16.0000000Z'
//         Unable to convert '2018-18-08T12:45:16.0000000Z'
//         2018-08-18T12:45:16.0000000         --> 2018-08-18 12:45:16 -07:00
//          2018-08-18T12:45:16.0000000Z       --> 2018-08-18 12:45:16 +00:00
//         2018-08-18T12:45:16.0000000+02:00   --> 2018-08-18 12:45:16 +02:00
//         2018-08-18T12:45:16.0000000-07:00   --> 2018-08-18 12:45:16 -07:00
//
//      -----
//
//      Parsing with AdjustToUniversal:
//         2018-08-18T12:45:16.0000000Z        --> 2018-08-18 12:45:16 +00:00
//         Unable to convert '2018/08/18T12:45:16.0000000Z'
//         Unable to convert '2018-18-08T12:45:16.0000000Z'
//         2018-08-18T12:45:16.0000000         --> 2018-08-18 19:45:16 +00:00
//         Unable to convert ' 2018-08-18T12:45:16.0000000Z '
//         2018-08-18T12:45:16.0000000+02:00   --> 2018-08-18 10:45:16 +00:00
//         2018-08-18T12:45:16.0000000-07:00   --> 2018-08-18 19:45:16 +00:00
//
//      -----
//
//      Parsing with AssumeLocal:
//         2018-08-18T12:45:16.0000000Z        --> 2018-08-18 12:45:16 +00:00
//         Unable to convert '2018/08/18T12:45:16.0000000Z'
//         Unable to convert '2018-18-08T12:45:16.0000000Z'
//         2018-08-18T12:45:16.0000000         --> 2018-08-18 12:45:16 -07:00
//         Unable to convert ' 2018-08-18T12:45:16.0000000Z '
//         2018-08-18T12:45:16.0000000+02:00   --> 2018-08-18 12:45:16 +02:00
//         2018-08-18T12:45:16.0000000-07:00   --> 2018-08-18 12:45:16 -07:00
//
//      -----
//
//      Parsing with AssumeUniversal:
//         2018-08-18T12:45:16.0000000Z        --> 2018-08-18 12:45:16 +00:00
//         Unable to convert '2018/08/18T12:45:16.0000000Z'
//         Unable to convert '2018-18-08T12:45:16.0000000Z'
//         2018-08-18T12:45:16.0000000         --> 2018-08-18 12:45:16 +00:00
//         Unable to convert ' 2018-08-18T12:45:16.0000000Z '
//         2018-08-18T12:45:16.0000000+02:00   --> 2018-08-18 12:45:16 +02:00
//         2018-08-18T12:45:16.0000000-07:00   --> 2018-08-18 12:45:16 -07:00

using System;
using System.Globalization;

public class Example
{
   public static void Main()
   {
      string[] dateStrings = { "2018-08-18T12:45:16.0000000Z",
                               "2018/08/18T12:45:16.0000000Z",
                               "2018-18-08T12:45:16.0000000Z",
                               "2018-08-18T12:45:16.0000000",                               
                               " 2018-08-18T12:45:16.0000000Z ",
                               "2018-08-18T12:45:16.0000000+02:00",
                               "2018-08-18T12:45:16.0000000-07:00" }; 
      
      ParseWithISO8601(dateStrings, DateTimeStyles.None);
      Console.WriteLine("\n-----\n");
      ParseWithISO8601(dateStrings, DateTimeStyles.AllowWhiteSpaces);
      Console.WriteLine("\n-----\n");
      ParseWithISO8601(dateStrings, DateTimeStyles.AdjustToUniversal);
      Console.WriteLine("\n-----\n");
      ParseWithISO8601(dateStrings, DateTimeStyles.AssumeLocal);
      Console.WriteLine("\n-----\n");
      ParseWithISO8601(dateStrings, DateTimeStyles.AssumeUniversal);   }

   private static void ParseWithISO8601(string[] dateStrings, DateTimeStyles styles)
   {   
      Console.WriteLine($"Parsing with {styles}:");
      DateTimeOffset date;
      foreach (var dateString in dateStrings)
      {
         if (DateTimeOffset.TryParseExact(dateString, "O", null, styles, out date))
         {
            Console.WriteLine($"   {dateString,-35} --> {date:yyyy-MM-dd HH:mm:ss.FF zzz}");
         }
         else
         {
            Console.WriteLine($"   Unable to convert '{dateString}'");
         }   
      } 
   }
}
// The example displays the following output:
//      Parsing with None:
//         2018-08-18T12:45:16.0000000Z        --> 2018-08-18 12:45:16 +00:00
//         Unable to convert '2018/08/18T12:45:16.0000000Z'
//         Unable to convert '2018-18-08T12:45:16.0000000Z'
//         2018-08-18T12:45:16.0000000         --> 2018-08-18 12:45:16 -07:00
//         Unable to convert ' 2018-08-18T12:45:16.0000000Z '
//         2018-08-18T12:45:16.0000000+02:00   --> 2018-08-18 12:45:16 +02:00
//         2018-08-18T12:45:16.0000000-07:00   --> 2018-08-18 12:45:16 -07:00
//
//      -----
//
//      Parsing with AllowWhiteSpaces:
//         2018-08-18T12:45:16.0000000Z        --> 2018-08-18 12:45:16 +00:00
//         Unable to convert '2018/08/18T12:45:16.0000000Z'
//         Unable to convert '2018-18-08T12:45:16.0000000Z'
//         2018-08-18T12:45:16.0000000         --> 2018-08-18 12:45:16 -07:00
//          2018-08-18T12:45:16.0000000Z       --> 2018-08-18 12:45:16 +00:00
//         2018-08-18T12:45:16.0000000+02:00   --> 2018-08-18 12:45:16 +02:00
//         2018-08-18T12:45:16.0000000-07:00   --> 2018-08-18 12:45:16 -07:00
//
//      -----
//
//      Parsing with AdjustToUniversal:
//         2018-08-18T12:45:16.0000000Z        --> 2018-08-18 12:45:16 +00:00
//         Unable to convert '2018/08/18T12:45:16.0000000Z'
//         Unable to convert '2018-18-08T12:45:16.0000000Z'
//         2018-08-18T12:45:16.0000000         --> 2018-08-18 19:45:16 +00:00
//         Unable to convert ' 2018-08-18T12:45:16.0000000Z '
//         2018-08-18T12:45:16.0000000+02:00   --> 2018-08-18 10:45:16 +00:00
//         2018-08-18T12:45:16.0000000-07:00   --> 2018-08-18 19:45:16 +00:00
//
//      -----
//
//      Parsing with AssumeLocal:
//         2018-08-18T12:45:16.0000000Z        --> 2018-08-18 12:45:16 +00:00
//         Unable to convert '2018/08/18T12:45:16.0000000Z'
//         Unable to convert '2018-18-08T12:45:16.0000000Z'
//         2018-08-18T12:45:16.0000000         --> 2018-08-18 12:45:16 -07:00
//         Unable to convert ' 2018-08-18T12:45:16.0000000Z '
//         2018-08-18T12:45:16.0000000+02:00   --> 2018-08-18 12:45:16 +02:00
//         2018-08-18T12:45:16.0000000-07:00   --> 2018-08-18 12:45:16 -07:00
//
//      -----
//
//      Parsing with AssumeUniversal:
//         2018-08-18T12:45:16.0000000Z        --> 2018-08-18 12:45:16 +00:00
//         Unable to convert '2018/08/18T12:45:16.0000000Z'
//         Unable to convert '2018-18-08T12:45:16.0000000Z'
//         2018-08-18T12:45:16.0000000         --> 2018-08-18 12:45:16 +00:00
//         Unable to convert ' 2018-08-18T12:45:16.0000000Z '
//         2018-08-18T12:45:16.0000000+02:00   --> 2018-08-18 12:45:16 +02:00
//         2018-08-18T12:45:16.0000000-07:00   --> 2018-08-18 12:45:16 -07:00

Imports System.Globalization

Public Module Example
   Public Sub Main()
      Dim dateStrings() = { "2018-08-18T12:45:16.0000000Z",
                            "2018/08/18T12:45:16.0000000Z",
                            "2018-18-08T12:45:16.0000000Z",
                            "2018-08-18T12:45:16.0000000",                               
                            " 2018-08-18T12:45:16.0000000Z ",
                            "2018-08-18T12:45:16.0000000+02:00",
                            "2018-08-18T12:45:16.0000000-07:00" } 
      
      ParseWithISO8601(dateStrings, DateTimeStyles.None)
      Console.WriteLine($"{vbCrLf}-----{vbCrLf}")
      ParseWithISO8601(dateStrings, DateTimeStyles.AllowWhiteSpaces)
      Console.WriteLine($"{vbCrLf}-----{vbCrLf}")
      ParseWithISO8601(dateStrings, DateTimeStyles.AdjustToUniversal)
      Console.WriteLine($"{vbCrLf}-----{vbCrLf}")
      ParseWithISO8601(dateStrings, DateTimeStyles.AssumeLocal)
      Console.WriteLine($"{vbCrLf}-----{vbCrLf}")
      ParseWithISO8601(dateStrings, DateTimeStyles.AssumeUniversal)   
   End Sub

   Private Sub ParseWithISO8601(dateStrings() As String, styles As DateTimeStyles)
      Console.WriteLine($"Parsing with {styles}:")
      Dim dat As DateTimeOffset
      For Each dateStr In dateStrings
         If DateTimeOffset.TryParseExact(dateStr, "O", Nothing, styles, dat) Then
            Console.WriteLine($"   {dateStr,-35} --> {dat:yyyy-MM-dd HH:mm:ss.FF zzz}")
         Else
            Console.WriteLine($"   Unable to convert '{dateStr}'")
         End If   
      Next 
   End Sub
End Module
' The example displays the following output:
'      Parsing with None:
'         2018-08-18T12:45:16.0000000Z        --> 2018-08-18 12:45:16 +00:00
'         Unable to convert '2018/08/18T12:45:16.0000000Z'
'         Unable to convert '2018-18-08T12:45:16.0000000Z'
'         2018-08-18T12:45:16.0000000         --> 2018-08-18 12:45:16 -07:00
'         Unable to convert ' 2018-08-18T12:45:16.0000000Z '
'         2018-08-18T12:45:16.0000000+02:00   --> 2018-08-18 12:45:16 +02:00
'         2018-08-18T12:45:16.0000000-07:00   --> 2018-08-18 12:45:16 -07:00
'
'      -----
'
'      Parsing with AllowWhiteSpaces:
'         2018-08-18T12:45:16.0000000Z        --> 2018-08-18 12:45:16 +00:00
'         Unable to convert '2018/08/18T12:45:16.0000000Z'
'         Unable to convert '2018-18-08T12:45:16.0000000Z'
'         2018-08-18T12:45:16.0000000         --> 2018-08-18 12:45:16 -07:00
'          2018-08-18T12:45:16.0000000Z       --> 2018-08-18 12:45:16 +00:00
'         2018-08-18T12:45:16.0000000+02:00   --> 2018-08-18 12:45:16 +02:00
'         2018-08-18T12:45:16.0000000-07:00   --> 2018-08-18 12:45:16 -07:00
'
'      -----
'
'      Parsing with AdjustToUniversal:
'         2018-08-18T12:45:16.0000000Z        --> 2018-08-18 12:45:16 +00:00
'         Unable to convert '2018/08/18T12:45:16.0000000Z'
'         Unable to convert '2018-18-08T12:45:16.0000000Z'
'         2018-08-18T12:45:16.0000000         --> 2018-08-18 19:45:16 +00:00
'         Unable to convert ' 2018-08-18T12:45:16.0000000Z '
'         2018-08-18T12:45:16.0000000+02:00   --> 2018-08-18 10:45:16 +00:00
'         2018-08-18T12:45:16.0000000-07:00   --> 2018-08-18 19:45:16 +00:00
'
'      -----
'
'      Parsing with AssumeLocal:
'         2018-08-18T12:45:16.0000000Z        --> 2018-08-18 12:45:16 +00:00
'         Unable to convert '2018/08/18T12:45:16.0000000Z'
'         Unable to convert '2018-18-08T12:45:16.0000000Z'
'         2018-08-18T12:45:16.0000000         --> 2018-08-18 12:45:16 -07:00
'         Unable to convert ' 2018-08-18T12:45:16.0000000Z '
'         2018-08-18T12:45:16.0000000+02:00   --> 2018-08-18 12:45:16 +02:00
'         2018-08-18T12:45:16.0000000-07:00   --> 2018-08-18 12:45:16 -07:00
'
'      -----
'
'      Parsing with AssumeUniversal:
'         2018-08-18T12:45:16.0000000Z        --> 2018-08-18 12:45:16 +00:00
'         Unable to convert '2018/08/18T12:45:16.0000000Z'
'         Unable to convert '2018-18-08T12:45:16.0000000Z'
'         2018-08-18T12:45:16.0000000         --> 2018-08-18 12:45:16 +00:00
'         Unable to convert ' 2018-08-18T12:45:16.0000000Z '
'         2018-08-18T12:45:16.0000000+02:00   --> 2018-08-18 12:45:16 +02:00
'         2018-08-18T12:45:16.0000000-07:00   --> 2018-08-18 12:45:16 -07:00

Remarques

Cette surcharge de la méthode TryParseExact(String, String, IFormatProvider, DateTimeStyles, DateTimeOffset) est semblable à la méthode DateTimeOffset.ParseExact(String, String, IFormatProvider, DateTimeStyles), sauf que cette méthode ne lève pas d’exception si la conversion échoue. Il analyse la représentation sous forme de chaîne d’une date et d’une heure qui doivent correspondre exactement au modèle spécifié par le paramètre format. Si la chaîne input ne correspond pas à ce modèle, avec certaines variations possibles de l’espace blanc défini par le paramètre styles, l’opération d’analyse échoue et la méthode retourne false.

Le paramètre format est une chaîne qui contient un spécificateur de format standard unique ou un ou plusieurs spécificateurs de format personnalisés qui définissent le modèle requis de input. Pour plus d’informations sur les codes de mise en forme valides, consultez chaînes de format de date et d’heure standard et chaînes de format de date et d’heure personnalisées. Si format inclut le z, zzou zzz spécificateurs de format personnalisé pour indiquer qu’un décalage doit être présent dans input, ce décalage doit inclure un signe négatif ou un signe positif. Si le signe est manquant, l’opération d’analyse échoue et la méthode retourne false.

Objet CultureInfo qui représente la culture en fonction de laquelle input est interprété. L’objet DateTimeFormatInfo retourné par la propriété CultureInfo.DateTimeFormat définit les symboles et les formats standard autorisés dans input.
Objet DateTimeFormatInfo qui définit le format des données de date et d’heure.

Si formatprovider est null, l’objet CultureInfo qui correspond à la culture actuelle est utilisé.

membre `DateTimeStyles`	Comportement
AdjustToUniversal	Analyse `input` et, si nécessaire, la convertit en UTC. Il équivaut à analyser une chaîne, puis à appeler la méthode DateTimeOffset.ToUniversalTime de l’objet DateTimeOffset retourné.
AssumeLocal	Si `format` ne nécessite pas que `input` contiennent une valeur de décalage, l’objet DateTimeOffset retourné reçoit le décalage du fuseau horaire local. Il s’agit du comportement par défaut.
AssumeUniversal	Si `format` ne nécessite pas que `input` contiennent une valeur de décalage, l’objet DateTimeOffset retourné reçoit le décalage UTC (+00:00).
AllowInnerWhite	Permet `input` d’inclure un espace blanc interne non spécifié par format. Un espace blanc supplémentaire peut apparaître entre les composants de date et d’heure et dans des composants individuels, autres que le décalage, et est ignoré lors de l’analyse de la chaîne.
AllowLeadingWhite	Permet `input` d’inclure des espaces de début non spécifiés par `format`. Elles sont ignorées lors de l’analyse de la chaîne.
AllowTrailingWhite	Permet `input` d’inclure des espaces de fin non spécifiés par `format`. Elles sont ignorées lors de l’analyse de la chaîne.
AllowWhiteSpaces	Permet `input` d’inclure des espaces de début, de fin et d’intérieur non spécifiés par `format`. Tous les espaces blancs supplémentaires non spécifiés dans `format` sont ignorés lors de l’analyse de la chaîne.
None	Indique que l’espace blanc supplémentaire n’est pas autorisé dans `input`. L’espace blanc doit apparaître exactement comme spécifié dans `format`. Il s’agit du comportement par défaut.
RoundtripKind	N’a aucun effet, car la structure DateTimeOffset n’inclut pas de propriété `Kind`.

Notes pour les appelants

Voir aussi

ParseExact

S’applique à

Partage via

DateTimeOffset.TryParseExact Méthode

Définition

Surcharges

TryParseExact(String, String[], IFormatProvider, DateTimeStyles, DateTimeOffset)

Paramètres

Retours

Exceptions

Exemples

Remarques

Notes pour les appelants

S’applique à

TryParseExact(ReadOnlySpan<Char>, ReadOnlySpan<Char>, IFormatProvider, DateTimeStyles, DateTimeOffset)

Paramètres

Retours

Exceptions

Remarques

S’applique à

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

Paramètres

Retours

Exceptions

Remarques

S’applique à

TryParseExact(String, String, IFormatProvider, DateTimeStyles, DateTimeOffset)

Paramètres

Retours

Exceptions

Exemples

Remarques

Notes pour les appelants

Voir aussi

S’applique à

Commentaires

Ressources supplémentaires