DateTimeOffset.TryParseExact Méthode

Source:

DateTimeOffset.cs

Source:

DateTimeOffset.cs

Source:

DateTimeOffset.cs

Source:

DateTimeOffset.cs

Source:

DateTimeOffset.cs

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

Retours

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

Exceptions

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 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 façon 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 Les chaînes de format de date et d’heure standard et les chaînes de format de date et d’heure personnalisées. Si l’élément mis en formats correspondance inclut les zspécificateurs de format , zzou zzz personnalisés pour indiquer qu’un décalage doit être présent, inputce 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 l’élément mis en formats correspondance nécessite qu’il input contienne une date, mais pas une heure, l’objet résultant DateTimeOffset est affecté à l’heure de minuit (0:00:00). Si l’élément mis en formats correspondance nécessite que l’entrée contienne une heure, mais pas une date, l’objet résultant DateTimeOffset est affecté à la date actuelle sur le système local. Si l’élément mis en formats correspondance ne nécessite pas de input décalage, le décalage de l’objet résultant DateTimeOffset dépend de la valeur du styles paramètre. Si styles elle inclut AssumeLocal, le décalage du fuseau horaire local est affecté à l’objet DateTimeOffset . Si styles elle 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 sont input définis par le formatProvider paramètre. Il en va de même pour le modèle précis de input si l’élément correspondant d’un formats spécificateur de format standard est une chaîne de spécificateur de format standard. Le formatProvider paramètre peut être l’un des éléments suivants :

• Objet CultureInfo qui représente la culture basée sur 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 c’est nullle cas, 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 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, le convertit en UTC. Elle équivaut à analyser une chaîne, puis à appeler la DateTimeOffset.ToUniversalTime méthode de l’objet retourné DateTimeOffset .
AssumeLocal	Si l’élément mis en formats correspondance ne nécessite pas de input 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 formats correspondance ne nécessite pas de input valeur de décalage, l’objet retourné DateTimeOffset reçoit le décalage UTC (+00:00).
AllowInnerWhite	Permet input d’inclure l’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 formats correspondant 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 pour formats qu’une correspondance réussie se produise. 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, la TryParseExact valeur 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é.

Source:

DateTimeOffset.cs

Source:

DateTimeOffset.cs

Source:

DateTimeOffset.cs

Source:

DateTimeOffset.cs

Source:

DateTimeOffset.cs

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

Retours

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

Exceptions

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 elle ne correspond pas à ce modèle, avec certaines variations possibles de l’espace blanc défini 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 Les chaînes de format de date et d’heure standard et les chaînes de format de date et d’heure personnalisées. Si format inclut les zspécificateurs de format , zzou zzz personnalisés 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 vous devez input contenir une date, mais pas une heure, l’objet résultant DateTimeOffset est affecté à l’heure de minuit (0:00:00). Si format vous devez input contenir une heure, mais pas une date, l’objet résultant DateTimeOffset est affecté à la date actuelle sur le système local. S’il format ne nécessite pas de input décalage, le décalage de l’objet résultant DateTimeOffset dépend de la valeur du styles paramètre. Si styles elle inclut AssumeLocal, le décalage du fuseau horaire local est affecté à l’objet DateTimeOffset . Si styles elle 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 sont input définis par le formatProvider paramètre. Il en va de même pour le modèle précis de s’il inputformat s’agit d’une chaîne de spécificateur de format standard. Le formatProvider paramètre peut être l’un des éléments suivants :

• Objet CultureInfo qui représente la culture basée sur 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 c’est nullle cas, 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 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, le convertit en UTC. Elle équivaut à analyser une représentation de date et d’heure, puis à appeler la DateTimeOffset.ToUniversalTime méthode de l’objet retourné DateTimeOffset .
AssumeLocal	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 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 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 les 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 sont format 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 DateTimeOffset structure n’inclut pas de Kind propriété.

Source:

DateTimeOffset.cs

Source:

DateTimeOffset.cs

Source:

DateTimeOffset.cs

Source:

DateTimeOffset.cs

Source:

DateTimeOffset.cs

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

Retours

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

Exceptions

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 elle 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 façon identique à la DateTimeOffset.ParseExact(ReadOnlySpan<Char>, 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 Les chaînes de format de date et d’heure standard et les chaînes de format de date et d’heure personnalisées. Si l’élément mis en formats correspondance inclut les zspécificateurs de format , zzou zzz personnalisés pour indiquer qu’un décalage doit être présent, inputce 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 l’élément mis en formats correspondance nécessite qu’il input contienne une date, mais pas une heure, l’objet résultant DateTimeOffset est affecté à l’heure de minuit (0:00:00). Si l’élément mis en formats correspondance nécessite que l’entrée contienne une heure, mais pas une date, l’objet résultant DateTimeOffset est affecté à la date actuelle sur le système local. Si l’élément mis en formats correspondance ne nécessite pas de input décalage, le décalage de l’objet résultant DateTimeOffset dépend de la valeur du styles paramètre. Si styles elle inclut DateTimeStyles.AssumeLocal, le décalage du fuseau horaire local est affecté à l’objet DateTimeOffset . Si styles elle 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 spécifiques utilisés sont input définis par le formatProvider paramètre. Il en va de même pour le modèle précis de input si l’élément correspondant d’un formats spécificateur de format standard est une chaîne de spécificateur de format standard. Le formatProvider paramètre peut être l’un des éléments suivants :

• Objet CultureInfo qui représente la culture basée sur 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 c’est nullle cas, 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 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, le convertit en UTC. Elle équivaut à analyser une chaîne, puis à appeler la DateTimeOffset.ToUniversalTime méthode de l’objet retourné DateTimeOffset .
AssumeLocal	Si l’élément mis en formats correspondance ne nécessite pas de input 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 formats correspondance ne nécessite pas de input valeur de décalage, l’objet retourné DateTimeOffset reçoit le décalage UTC (+00:00).
AllowInnerWhite	Permet input d’inclure l’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 formats correspondant 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 pour formats qu’une correspondance réussie se produise. Il s’agit du comportement par défaut.
RoundtripKind	N’a aucun effet, car la DateTimeOffset structure n’inclut pas de Kind propriété.

Source:

DateTimeOffset.cs

Source:

DateTimeOffset.cs

Source:

DateTimeOffset.cs

Source:

DateTimeOffset.cs

Source:

DateTimeOffset.cs

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

Retours

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

Exceptions

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 différentes 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 une variété de 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 parviennent pas à analyser si :

• ils contiennent des espaces blancs et un indicateur approprié DateTimeStyles (comme 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 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 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 de l’espace blanc défini 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 Les chaînes de format de date et d’heure standard et les chaînes de format de date et d’heure personnalisées. Si format inclut les zspécificateurs de format , zzou zzz personnalisés 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 vous devez input contenir une date, mais pas une heure, l’objet résultant DateTimeOffset est affecté à l’heure de minuit (0:00:00). Si format vous devez input contenir une heure, mais pas une date, l’objet résultant DateTimeOffset est affecté à la date actuelle sur le système local. S’il format ne nécessite pas de input décalage, le décalage de l’objet résultant DateTimeOffset dépend de la valeur du styles paramètre. Si styles elle inclut AssumeLocal, le décalage du fuseau horaire local est affecté à l’objet DateTimeOffset . Si styles elle 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 sont input définis par le formatProvider paramètre. Il en va de même pour le modèle précis de s’il inputformat s’agit d’une chaîne de spécificateur de format standard. Le formatProvider paramètre peut être l’un des éléments suivants :

• Objet CultureInfo qui représente la culture basée sur 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 c’est nullle cas, 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 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, le convertit en UTC. Elle équivaut à analyser une chaîne, puis à appeler la DateTimeOffset.ToUniversalTime méthode de l’objet retourné DateTimeOffset .
AssumeLocal	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 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 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 les 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 sont format 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 DateTimeOffset structure n’inclut pas de Kind propriété.

Notes pour les appelants

Dans .NET Framework 4, la TryParseExact valeur 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é.

Voir aussi

• ParseExact