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 heure en son équivalent DateTimeOffset à l'aide du tableau de formats, des informations et du style de format propres à la culture 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 DateTimeOffset équivalent à l’aide des informations et du style de format propres à la culture spécifiés. Le format de la représentation de la date et de l’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 plage de caractères en DateTimeOffset équivalent à l’aide des informations et du style de format propres à la culture spécifiés. Le format de la représentation de la date et de l’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 DateTimeOffset équivalent à l'aide des informations et du style de format propres à la culture spécifiés. 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 heure en son équivalent DateTimeOffset à l'aide du tableau de formats, des informations et du style de format propres à la culture 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 contenant 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 propres à la culture sur input.

styles: DateTimeStyles

Combinaison de bits de valeurs d'énumération qui indique le format autorisé de l'entrée. Une valeur typique à spécifier est None.

result: DateTimeOffset

Lorsque la méthode retourne, contient l’équivalent DateTimeOffset de la date et de l’heure de input, si la conversion a réussi, ou DateTimeOffset.MinValue, si la conversion a échoué. La conversion échoue si input ne contient pas de représentation sous forme de chaîne valide d’une date et d’une heure ou si elle ne contient pas la date et l’heure au format attendu défini par format, ou si formats a la valeur null. Ce paramètre est passé sans être initialisé.

Retours

Boolean

true si la conversion du paramètre input a réussi ; 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 DateTimeStyles qui s’excluent mutuellement.

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 passe la chaîne entrée par l’utilisateur à la TryParseExact(String, String[], IFormatProvider, DateTimeStyles, DateTimeOffset) méthode .

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 TryParseExact(String, String[], IFormatProvider, DateTimeStyles, DateTimeOffset) méthode analyse la représentation sous forme de chaîne d’une date qui correspond à l’un des modèles attribués au formats tableau. Si la input chaîne ne correspond à aucun de ces modèles avec des variantes définies par le styles paramètre, l’opération d’analyse échoue et la méthode retourne false. Outre la comparaison input à plusieurs chaînes qui contiennent des spécificateurs de format, cette surcharge se comporte de manière identique à la DateTimeOffset.ParseExact(String, String[], IFormatProvider, DateTimeStyles) méthode .

Le formats paramètre 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 les zspécificateurs de format personnalisé , zzou zzz 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 formats paramètre de cette surcharge pour spécifier plusieurs formats peut aider à 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 des représentations de date et d’heure qui peuvent inclure ou manquer des zéros de début en mois, jours, heures, minutes et secondes. L’exemple en fournit une illustration.

Si l’élément mis en correspondance dans formats requiert qu’il input contienne une date, mais pas une heure, l’objet résultant DateTimeOffset se voit attribuer une 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 résultant DateTimeOffset se voit attribuer la date actuelle sur le système local. Si l’élément mis en correspondance dans formats n’exige pas qu’il input contienne un décalage, le décalage de l’objet résultant DateTimeOffset dépend de la valeur du styles paramètre. 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 formatProvider paramètre . Il en va de même pour le modèle précis de si l’élément input correspondant de est une chaîne de spécificateur de formats format standard. Le formatProvider paramètre peut être l’un des éléments suivants :

Objet CultureInfo qui représente la culture en fonction de laquelle input est interprétée. L’objet DateTimeFormatInfo retourné par la CultureInfo.DateTimeFormat propriété 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 styles paramètre 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 sont pris en charge, à l’exception DateTimeStyles NoCurrentDateDefaultde . Le tableau suivant répertorie l’effet de chaque membre pris en charge.

Membre`DateTimeStyles`	Comportement
AdjustToUniversal	`input` Analyse et, si nécessaire, le convertit en UTC. Cela équivaut à analyser une chaîne, puis à appeler la DateTimeOffset.ToUniversalTime méthode de l’objet retourné DateTimeOffset .
AssumeLocal	Si l’élément mis en correspondance dans `formats` n’exige pas qu’il `input` contienne une valeur de décalage, l’objet retourné DateTimeOffset 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` n’exige pas qu’il `input` contienne une valeur de décalage, l’objet retourné DateTimeOffset reçoit le décalage UTC (+00:00).
AllowInnerWhite	Permet `input` d’inclure des espaces blancs internes non spécifiés par les éléments dans `formats`. Des espaces blancs supplémentaires peuvent apparaître entre les composants de date et d’heure et dans des composants individuels (à l’exception du décalage) et sont ignorés 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`. Ils sont ignorés 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`. Ils sont ignorés lors de l’analyse de la chaîne.
AllowWhiteSpaces	Permet `input` d’inclure des espaces de début, de fin et intérieurs 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 des espaces blancs supplémentaires ne sont pas autorisés dans `input`. Les espaces blancs doivent apparaître exactement comme spécifié dans un élément particulier dans `formats` pour qu’une correspondance aboutisse. Il s'agit du comportement par défaut.
RoundtripKind	N’a aucun effet, car la DateTimeOffset structure n’inclut pas de `Kind` propriété.

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 les versions antérieures, le désignateur 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 DateTimeOffset équivalent à l’aide des informations et du style de format propres à la culture spécifiés. Le format de la représentation de la date et de l’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 définissant le format requis de input.

formatProvider: IFormatProvider

Objet qui fournit des informations de mise en forme propres à la culture sur input.

styles: DateTimeStyles

Combinaison d'opérations de bits de valeurs d'énumération qui indique le format autorisé du paramètre input. Une valeur typique à spécifier est None.

result: DateTimeOffset

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

Retours

Boolean

true si la conversion du paramètre input a réussi ; 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 DateTimeStyles qui s’excluent mutuellement.

Remarques

Cette surcharge est semblable à la DateTimeOffset.ParseExact(ReadOnlySpan<Char>, ReadOnlySpan<Char>, IFormatProvider, DateTimeStyles) méthode, 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 format paramètre. Si input ne correspond pas à ce modèle, avec certaines variations possibles d’espace blanc définies par le styles paramètre, l’opération d’analyse échoue et la méthode retourne false.

Le format paramètre 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 les zspécificateurs de format personnalisé , zzou zzz 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 nécessite que input contiennent une date, mais pas une heure, l’objet résultant DateTimeOffset se voit attribuer une heure de minuit (0:00:00). Si format nécessite que contiennent input une heure, mais pas une date, la date actuelle est attribuée à l’objet résultant DateTimeOffset sur le système local. S’il format n’est pas nécessaire de input contenir un décalage, le décalage de l’objet résultant DateTimeOffset dépend de la valeur du styles paramètre. 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 formatProvider paramètre . Il en va de même pour le modèle précis de si format est une chaîne de input spécificateur de format standard. Le formatProvider paramètre peut être l’un des éléments suivants :

Objet CultureInfo qui représente la culture en fonction de laquelle input est interprétée. L’objet DateTimeFormatInfo retourné par la CultureInfo.DateTimeFormat propriété 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	`input` Analyse et, si nécessaire, le convertit en UTC. Cela équivaut à analyser une représentation de date et d’heure, puis à appeler la DateTimeOffset.ToUniversalTime méthode de l’objet retourné DateTimeOffset .
AssumeLocal	Si `format` ne nécessite pas de contenir `input` une valeur de décalage, l’objet retourné DateTimeOffset reçoit le décalage du fuseau horaire local. Il s'agit du comportement par défaut.
AssumeUniversal	S’il `format` n’est pas nécessaire de `input` contenir une valeur de décalage, l’objet retourné DateTimeOffset reçoit le décalage UTC (+00:00).
AllowInnerWhite	Permet `input` d’inclure des espaces blancs internes non spécifiés par le 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`. Ils sont ignorés lors de l’analyse de la chaîne.
AllowTrailingWhite	Permet `input` d’inclure des espaces de fin non spécifiés par `format`. Ils sont ignorés lors de l’analyse de la chaîne.
AllowWhiteSpaces	Permet `input` d’inclure les espaces de début, de fin et intérieurs 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 des espaces blancs supplémentaires ne sont pas autorisés dans `input`. Les espaces blancs doivent apparaître exactement comme spécifié dans `format`. Il s'agit du comportement par défaut.
RoundtripKind	N’a aucun effet, car la DateTimeOffset structure n’inclut pas de `Kind` propriété.

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 plage de caractères en DateTimeOffset équivalent à l’aide des informations et du style de format propres à la culture spécifiés. Le format de la représentation de la date et de l’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éfinit les formats acceptables de input.

formatProvider: IFormatProvider

Objet qui fournit des informations de mise en forme propres à la culture sur input.

styles: DateTimeStyles

Combinaison d'opérations de bits de valeurs d'énumération qui indique le format autorisé du paramètre input. Une valeur typique à spécifier est None.

result: DateTimeOffset

Retours

Boolean

true si la conversion du paramètre input a réussi ; 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 DateTimeStyles qui s’excluent mutuellement.

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 formats tableau. Si input ne correspond à aucun de ces modèles avec des variantes définies par le styles paramètre, l’opération d’analyse échoue et la méthode retourne false. Outre la comparaison input à plusieurs chaînes qui contiennent des spécificateurs de format, cette surcharge se comporte de manière identique à la DateTimeOffset.ParseExact(ReadOnlySpan<Char>, String[], IFormatProvider, DateTimeStyles) méthode .

Important

Si l’élément mis en correspondance dans formats requiert qu’il input contienne une date, mais pas une heure, l’objet résultant DateTimeOffset se voit attribuer une 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 résultant DateTimeOffset se voit attribuer la date actuelle sur le système local. Si l’élément mis en correspondance dans formats n’exige pas qu’il input contienne un décalage, le décalage de l’objet résultant DateTimeOffset dépend de la valeur du styles paramètre. 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 formatProvider paramètre . Il en va de même pour le modèle précis de si l’élément input correspondant de est une chaîne de spécificateur de formats format standard. Le formatProvider paramètre peut être l’un des éléments suivants :

Objet CultureInfo qui représente la culture en fonction de laquelle input est interprétée. L’objet DateTimeFormatInfo retourné par la CultureInfo.DateTimeFormat propriété 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	`input` Analyse et, si nécessaire, le convertit en UTC. Cela équivaut à analyser une chaîne, puis à appeler la DateTimeOffset.ToUniversalTime méthode de l’objet retourné DateTimeOffset .
AssumeLocal	Si l’élément mis en correspondance dans `formats` n’exige pas qu’il `input` contienne une valeur de décalage, l’objet retourné DateTimeOffset 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` n’exige pas qu’il `input` contienne une valeur de décalage, l’objet retourné DateTimeOffset reçoit le décalage UTC (+00:00).
AllowInnerWhite	Permet `input` d’inclure des espaces blancs internes non spécifiés par les éléments dans `formats`. Des espaces blancs supplémentaires peuvent apparaître entre les composants de date et d’heure et dans des composants individuels (à l’exception du décalage) et sont ignorés 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`. Ils sont ignorés 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`. Ils sont ignorés lors de l’analyse de la chaîne.
AllowWhiteSpaces	Permet `input` d’inclure des espaces de début, de fin et intérieurs 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 des espaces blancs supplémentaires ne sont pas autorisés dans `input`. Les espaces blancs doivent apparaître exactement comme spécifié dans un élément particulier dans `formats` pour qu’une correspondance aboutisse. Il s'agit du comportement par défaut.
RoundtripKind	N’a aucun effet, car la DateTimeOffset structure n’inclut pas de `Kind` propriété.

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 DateTimeOffset équivalent à l'aide des informations et du style de format propres à la culture spécifiés. 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 contenant une date et une heure à convertir.

format: String

Spécificateur de format définissant le format requis de input.

formatProvider: IFormatProvider

Objet qui fournit des informations de mise en forme propres à la culture sur input.

styles: DateTimeStyles

Combinaison de bits de valeurs d'énumération qui indique le format autorisé de l'entrée. Une valeur typique à spécifier est None.

result: DateTimeOffset

Lorsque la méthode retourne, contient l’équivalent DateTimeOffset de la date et de 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 a la valeur nullou si elle 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é sans être initialisé.

Retours

Boolean

true si la conversion du paramètre input a réussi ; 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 DateTimeStyles qui s’excluent mutuellement.

Exemples

L’exemple suivant utilise la TryParseExact(String, String, IFormatProvider, DateTimeStyles, DateTimeOffset) méthode avec des spécificateurs de format standard et personnalisés, la culture invariante et diverses DateTimeStyles valeurs 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 diverses DateTimeStyles valeurs pour analyser un tableau de chaînes qui sont censées être conformes à la norme ISO 8601. Comme le montre la sortie de l’exemple, les chaînes au format approprié ne peuvent pas être analysées si :

ils contiennent des espaces blancs et un indicateur approprié DateTimeStyles (tel que n’a DateTimeStyles.AllowWhiteSpaces pas été fourni dans l’appel de méthode.
ils contiennent des éléments de date et d’heure qui sont hors de portée.

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 de la zone d’heure 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 du temps universel coordonné.

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 TryParseExact(String, String, IFormatProvider, DateTimeStyles, DateTimeOffset) méthode est semblable à la DateTimeOffset.ParseExact(String, String, IFormatProvider, DateTimeStyles) méthode, 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 format paramètre. Si la input chaîne ne correspond pas à ce modèle, avec certaines variations possibles d’espace blanc définies par le styles paramètre, l’opération d’analyse échoue et la méthode retourne false.

Le format paramètre 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 les zspécificateurs de format personnalisé , zzou zzz 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ée. L’objet DateTimeFormatInfo retourné par la CultureInfo.DateTimeFormat propriété 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	`input` Analyse et, si nécessaire, le convertit en UTC. Cela équivaut à analyser une chaîne, puis à appeler la DateTimeOffset.ToUniversalTime méthode de l’objet retourné DateTimeOffset .
AssumeLocal	Si `format` ne nécessite pas de contenir `input` une valeur de décalage, l’objet retourné DateTimeOffset reçoit le décalage du fuseau horaire local. Il s'agit du comportement par défaut.
AssumeUniversal	S’il `format` n’est pas nécessaire de `input` contenir une valeur de décalage, l’objet retourné DateTimeOffset reçoit le décalage UTC (+00:00).
AllowInnerWhite	Permet `input` d’inclure des espaces blancs internes non spécifiés par le 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`. Ils sont ignorés lors de l’analyse de la chaîne.
AllowTrailingWhite	Permet `input` d’inclure des espaces de fin non spécifiés par `format`. Ils sont ignorés lors de l’analyse de la chaîne.
AllowWhiteSpaces	Permet `input` d’inclure les espaces de début, de fin et intérieurs 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 des espaces blancs supplémentaires ne sont pas autorisés dans `input`. Les espaces blancs doivent apparaître exactement comme spécifié dans `format`. Il s'agit du comportement par défaut.
RoundtripKind	N’a aucun effet, car la DateTimeOffset structure n’inclut pas de `Kind` propriété.

Notes pour les appelants

Voir aussi

ParseExact

S’applique à

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