DateTimeOffset.ParseExact 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

ParseExact(String, String[], IFormatProvider, DateTimeStyles)	Convertit la représentation sous forme de chaîne spécifiée d’une date et d’une heure dans son équivalent DateTimeOffset en utilisant le style, les informations de format propres à la culture et les formats spécifiés. Le format de la représentation sous forme de chaîne doit correspondre exactement à l'un des formats spécifiés.
ParseExact(String, String, IFormatProvider, DateTimeStyles)	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é.
ParseExact(String, String, IFormatProvider)	Convertit la représentation sous forme de chaîne spécifiée d'une date et d'une heure en son équivalent DateTimeOffset à l'aide des informations de format propres à la culture et au format spécifiés. Le format de la représentation sous forme de chaîne doit correspondre exactement au format spécifié.
ParseExact(ReadOnlySpan<Char>, ReadOnlySpan<Char>, IFormatProvider, DateTimeStyles)	Convertit une étendue de caractères qui représente une date et 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 de la date et de l’heure doit correspondre exactement au format spécifié.
ParseExact(ReadOnlySpan<Char>, String[], IFormatProvider, DateTimeStyles)	Convertit une étendue de caractères qui contient la représentation sous forme de chaîne d’une date et d’une heure en DateTimeOffset à l’aide du style, des informations de format propres à la culture et des formats 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.

ParseExact(String, String[], IFormatProvider, DateTimeStyles)

Convertit la représentation sous forme de chaîne spécifiée d’une date et d’une heure dans son équivalent DateTimeOffset en utilisant le style, les informations de format propres à la culture et les formats 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 DateTimeOffset ParseExact(System::String ^ input, cli::array <System::String ^> ^ formats, IFormatProvider ^ formatProvider, System::Globalization::DateTimeStyles styles);

public static DateTimeOffset ParseExact (string input, string[] formats, IFormatProvider formatProvider, System.Globalization.DateTimeStyles styles);

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

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

Public Shared Function ParseExact (input As String, formats As String(), formatProvider As IFormatProvider, styles As DateTimeStyles) As DateTimeOffset

Paramètres

input: String

Chaîne contenant une date et une heure à convertir.

formats: String[]

Tableau des spécificateurs de format qui définissent les formats attendus 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.

Retours

DateTimeOffset

Objet qui équivaut à la date et à l’heure figurant dans le paramètre input, comme spécifié par les paramètres formats, formatProvider et styles.

Exceptions

ArgumentException

Le décalage est supérieur à 14 heures ou inférieur à -14 heures.

ou -

styles contient une valeur non prise en charge.

ou -

Le paramètre styles contient des valeurs DateTimeStyles qui ne peuvent pas être utilisées ensemble.

ArgumentNullException

input a la valeur null.

FormatException

Le input est une chaîne vide ("").

ou -

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

ou -

Aucun élément de formats ne contient un spécificateur de format valide.

ou -

Le composant heure et l’indicateur AM/PM dans input ne correspondent pas.

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 DateTimeOffset.ParseExact(String, String[], IFormatProvider, DateTimeStyles) 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 = new 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();
   try
   {
      result = DateTimeOffset.ParseExact(input, formats, provider,
                                         DateTimeStyles.AllowWhiteSpaces);
      break;
   }
   catch (FormatException)
   {
      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 input = String.Empty
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

let mutable result = None
let mutable tries = 0
while tries < 3 && result.IsNone do
    printfn "Enter a date, time, and offset (MM/DD/YYYY HH:MM +/-HH:MM),"
    printf "Then press Enter: "
    let input = stdin.ReadLine()
    printfn ""
    try
        result <- 
            DateTimeOffset.ParseExact(input, formats, provider, DateTimeStyles.AllowWhiteSpaces) 
            |> Some
    with :? FormatException ->
        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() 
    Try
       result = DateTimeOffset.ParseExact(input, formats, provider, _
                                          DateTimeStyles.AllowWhiteSpaces)
       Exit Do
    Catch e As FormatException
       Console.WriteLine("Unable to parse {0}.", input)      
       tries += 1
    End Try
 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 DateTimeOffset.ParseExact(String, String[], IFormatProvider, DateTimeStyles) 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 paramètre. Si la input chaîne ne correspond à aucun de ces modèles avec l’une des variantes définies par le styles paramètre, la méthode lève un FormatException. En plus de comparer input à plusieurs modèles de mise en forme, 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 du input paramètre. Lorsque la méthode est appelée, input doit correspondre à l’un de ces modèles. 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 formats correspondance inclut les zspécificateurs de format , zzou zzz personnalisés pour indiquer qu’un décalage doit être présent input, ce décalage doit inclure un signe négatif ou un signe positif. Si le signe est manquant, la méthode lève un FormatException.

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 les représentations de date et d’heure qui peuvent inclure ou manquent de zéros en début de mois, de jours, d’heures, de minutes et de secondes. L’exemple fournit une illustration de ceci.

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é à une heure de minuit (0:00:00). Si l’élément mis en formats correspondance nécessite qu’il input contienne une heure, mais pas une date, l’objet résultant DateTimeOffset est affecté à la date actuelle du système local. Si l’élément mis en correspondance dans formats 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 particuliers utilisés input sont définis par le formatProvider paramètre. La même valeur est vraie pour le format précis de input, si l’élément correspondant d’est formats 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	`input` Analyse et, si nécessaire, la convertit en UTC. Il é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 n’exige `formats` 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 n’exige `formats` pas qu’il `input` contienne une valeur de décalage, l’objet retourné DateTimeOffset est donné au décalage UTC (+00:00).
AllowInnerWhite	Permet `input` d’inclure l’espace blanc interne non spécifié par `format`. L’espace blanc supplémentaire peut apparaître entre les composants de date et d’heure et dans les composants individuels (sauf 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 `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 `formats`. 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 `formats`. Tous les espaces blancs supplémentaires non spécifiés dans l’élément mis en `formats` correspondance 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 d’une `formats` correspondance à produire. 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 ParseExact méthode lève une FormatException valeur si la chaîne à analyser contient un composant d’heure et un indicateur AM/PM qui ne sont pas en accord. Dans les versions .NET Framework 3.5 et antérieures, l’indicateur AM/PM est ignoré.

Voir aussi

S’applique à

ParseExact(String, String, IFormatProvider, DateTimeStyles)

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 DateTimeOffset ParseExact(System::String ^ input, System::String ^ format, IFormatProvider ^ formatProvider, System::Globalization::DateTimeStyles styles);

public static DateTimeOffset ParseExact (string input, string format, IFormatProvider formatProvider, System.Globalization.DateTimeStyles styles);

public static DateTimeOffset ParseExact (string input, string format, IFormatProvider? formatProvider, System.Globalization.DateTimeStyles styles);

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

Public Shared Function ParseExact (input As String, format As String, formatProvider As IFormatProvider, styles As DateTimeStyles) As DateTimeOffset

Paramètres

input: String

Chaîne contenant une date et une heure à convertir.

format: String

Spécificateur de format définissant le format attendu 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.

Retours

DateTimeOffset

Objet qui équivaut à la date et à l’heure figurant dans le paramètre input, comme spécifié par les paramètres format, formatProvider et styles.

Exceptions

ArgumentException

Le décalage est supérieur à 14 heures ou inférieur à -14 heures.

ou -

Le paramètre styles inclut une valeur non prise en charge.

ou -

Le paramètre styles contient des valeurs DateTimeStyles qui ne peuvent pas être utilisées ensemble.

ArgumentNullException

input a la valeur null.

-ou-

format a la valeur null.

FormatException

Le input est une chaîne vide ("").

ou -

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

ou -

format est une chaîne vide.

ou -

Le composant heure et l’indicateur AM/PM dans input ne correspondent pas.

Exemples

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

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

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

// Parse date-only value with leading white space.
// Should throw a FormatException because only trailing white space is
// specified in method call.
dateString = " 06/15/2008";
try
{
   result = DateTimeOffset.ParseExact(dateString, format, provider,
                                      DateTimeStyles.AllowTrailingWhite);
   Console.WriteLine("'{0}' converts to {1}.", dateString, result.ToString());
}
catch (FormatException)
{
   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";
try
{
   result = DateTimeOffset.ParseExact(dateString, format, provider,
                                      DateTimeStyles.AllowWhiteSpaces);
   Console.WriteLine("'{0}' converts to {1}.", dateString, result.ToString());
}
catch (FormatException)
{
   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";
try
{
   result = DateTimeOffset.ParseExact(dateString, format, provider,
                                      DateTimeStyles.AllowWhiteSpaces |
                                      DateTimeStyles.AdjustToUniversal);
   Console.WriteLine("'{0}' converts to {1}.", dateString, result.ToString());
}
catch (FormatException)
{
   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"
try
    let result = DateTimeOffset.ParseExact(dateString, format, provider, DateTimeStyles.AssumeUniversal)
    printfn $"'{dateString}' converts to {result}."
with :? FormatException ->
    printfn $"'{dateString}' is not in the correct format."

// Parse date-only value with leading white space.
// Should throw a FormatException because only trailing white space is
// specified in method call.
let dateString = " 06/15/2008"
try
    let result = DateTimeOffset.ParseExact(dateString, format, provider, DateTimeStyles.AllowTrailingWhite)
    printfn $"'{dateString}' converts to {result}."
with :? FormatException ->
    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"
try
    let result = DateTimeOffset.ParseExact(dateString, format, provider, DateTimeStyles.AllowWhiteSpaces)
    printfn $"'{dateString}' converts to {result}."
with :? FormatException ->
    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"
try
    let result = 
        DateTimeOffset.ParseExact(dateString, format, provider,
                                  DateTimeStyles.AllowWhiteSpaces |||
                                  DateTimeStyles.AdjustToUniversal)
    printfn $"'{dateString}' converts to {result}."
with :? FormatException ->
    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"
Try
   result = DateTimeOffset.ParseExact(dateString, format, provider, _
                                      DateTimeStyles.AssumeUniversal)
   Console.WriteLine("'{0}' converts to {1}.", dateString, result.ToString())
Catch e As FormatException
   Console.WriteLine("'{0}' is not in the correct format.", dateString)
End Try 

' Parse date-only value with leading white space.
' Should throw a FormatException because only trailing white space is  
' specified in method call.
dateString = " 06/15/2008"
Try
   result = DateTimeOffset.ParseExact(dateString, format, provider, _
                                      DateTimeStyles.AllowTrailingWhite)
   Console.WriteLine("'{0}' converts to {1}.", dateString, result.ToString())
Catch e As FormatException
   Console.WriteLine("'{0}' is not in the correct format.", dateString)
End Try 

' 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"
Try
   result = DateTimeOffset.ParseExact(dateString, format, provider, _
                                      DateTimeStyles.AllowWhiteSpaces)
   Console.WriteLine("'{0}' converts to {1}.", dateString, result.ToString())
Catch e As FormatException
   Console.WriteLine("'{0}' is not in the correct format.", dateString)
End Try 

' 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"       
Try
   result = DateTimeOffset.ParseExact(dateString, format, provider, _
                                      DateTimeStyles.AllowWhiteSpaces Or _
                                      DateTimeStyles.AdjustToUniversal)
   Console.WriteLine("'{0}' converts to {1}.", dateString, result.ToString())
Catch e As FormatException
   Console.WriteLine("'{0}' is not in the correct format.", dateString)
End Try 
' 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 censées être conformes à la norme ISO 8601. Comme le montre la sortie de l’exemple, les chaînes qui se trouvent dans le format approprié ne parviennent pas à analyser si :

ils contiennent des espaces blancs et un indicateur approprié DateTimeStyles (tel qu’il 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), 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.

module parseexact_iso8601_2

open System
open System.Globalization

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

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

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
//         FormatException: Unable to convert '2018/08/18T12:45:16.0000000Z'
//         FormatException: Unable to convert '2018-18-08T12:45:16.0000000Z'
//         2018-08-18T12:45:16.0000000         --> 2018-08-18 12:45:16 -07:00
//         FormatException: 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
//         FormatException: Unable to convert '2018/08/18T12:45:16.0000000Z'
//         FormatException: 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
//         FormatException: Unable to convert '2018/08/18T12:45:16.0000000Z'
//         FormatException: Unable to convert '2018-18-08T12:45:16.0000000Z'
//         2018-08-18T12:45:16.0000000         --> 2018-08-18 19:45:16 +00:00
//         FormatException: 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
//         FormatException: Unable to convert '2018/08/18T12:45:16.0000000Z'
//         FormatException: Unable to convert '2018-18-08T12:45:16.0000000Z'
//         2018-08-18T12:45:16.0000000         --> 2018-08-18 12:45:16 -07:00
//         FormatException: 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
//         FormatException: Unable to convert '2018/08/18T12:45:16.0000000Z'
//         FormatException: Unable to convert '2018-18-08T12:45:16.0000000Z'
//         2018-08-18T12:45:16.0000000         --> 2018-08-18 12:45:16 +00:00
//         FormatException: 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}:");
      foreach (var dateString in dateStrings)
      {
         try {
            var date = DateTimeOffset.ParseExact(dateString, "O", null, styles);
            Console.WriteLine($"   {dateString,-35} --> {date:yyyy-MM-dd HH:mm:ss.FF zzz}");
         }
         catch (FormatException)
         {
            Console.WriteLine($"   FormatException: 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
//         FormatException: Unable to convert '2018/08/18T12:45:16.0000000Z'
//         FormatException: Unable to convert '2018-18-08T12:45:16.0000000Z'
//         2018-08-18T12:45:16.0000000         --> 2018-08-18 12:45:16 -07:00
//         FormatException: 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
//         FormatException: Unable to convert '2018/08/18T12:45:16.0000000Z'
//         FormatException: 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
//         FormatException: Unable to convert '2018/08/18T12:45:16.0000000Z'
//         FormatException: Unable to convert '2018-18-08T12:45:16.0000000Z'
//         2018-08-18T12:45:16.0000000         --> 2018-08-18 19:45:16 +00:00
//         FormatException: 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
//         FormatException: Unable to convert '2018/08/18T12:45:16.0000000Z'
//         FormatException: Unable to convert '2018-18-08T12:45:16.0000000Z'
//         2018-08-18T12:45:16.0000000         --> 2018-08-18 12:45:16 -07:00
//         FormatException: 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
//         FormatException: Unable to convert '2018/08/18T12:45:16.0000000Z'
//         FormatException: Unable to convert '2018-18-08T12:45:16.0000000Z'
//         2018-08-18T12:45:16.0000000         --> 2018-08-18 12:45:16 +00:00
//         FormatException: 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}:")
      For Each dateStr In dateStrings
         Try 
            Dim dat = DateTimeOffset.ParseExact(dateString, "O", Nothing, styles)
            Console.WriteLine($"   {dateString,-35} --> {dat:yyyy-MM-dd HH:mm:ss.FF zzz}")
         catch e As FormatException
            Console.WriteLine($"   FormatException: Unable to convert '{dateString}'")
         End Try   
      Next 
   End Sub
End Module
' The example displays the following output:
'      Parsing with None:
'         FormatException: Unable to convert '07-30-2018'
'         FormatException: Unable to convert '07-30-2018'
'         FormatException: Unable to convert '07-30-2018'
'         FormatException: Unable to convert '07-30-2018'
'         FormatException: Unable to convert '07-30-2018'
'         FormatException: Unable to convert '07-30-2018'
'         FormatException: Unable to convert '07-30-2018'
'
'      -----
'
'      Parsing with AllowWhiteSpaces:
'         FormatException: Unable to convert '07-30-2018'
'         FormatException: Unable to convert '07-30-2018'
'         FormatException: Unable to convert '07-30-2018'
'         FormatException: Unable to convert '07-30-2018'
'         FormatException: Unable to convert '07-30-2018'
'         FormatException: Unable to convert '07-30-2018'
'         FormatException: Unable to convert '07-30-2018'
'
'      -----
'
'      Parsing with AdjustToUniversal:
'         FormatException: Unable to convert '07-30-2018'
'         FormatException: Unable to convert '07-30-2018'
'         FormatException: Unable to convert '07-30-2018'
'         FormatException: Unable to convert '07-30-2018'
'         FormatException: Unable to convert '07-30-2018'
'         FormatException: Unable to convert '07-30-2018'
'         FormatException: Unable to convert '07-30-2018'
'
'      -----
'
'      Parsing with AssumeLocal:
'         FormatException: Unable to convert '07-30-2018'
'         FormatException: Unable to convert '07-30-2018'
'         FormatException: Unable to convert '07-30-2018'
'         FormatException: Unable to convert '07-30-2018'
'         FormatException: Unable to convert '07-30-2018'
'         FormatException: Unable to convert '07-30-2018'
'         FormatException: Unable to convert '07-30-2018'
'
'      -----
'
'      Parsing with AssumeUniversal:
'         FormatException: Unable to convert '07-30-2018'
'         FormatException: Unable to convert '07-30-2018'
'         FormatException: Unable to convert '07-30-2018'
'         FormatException: Unable to convert '07-30-2018'
'         FormatException: Unable to convert '07-30-2018'
'         FormatException: Unable to convert '07-30-2018'
'         FormatException: Unable to convert '07-30-2018'

Remarques

La DateTimeOffset.ParseExact(String, String, IFormatProvider, DateTimeStyles) méthode analyse la représentation sous forme de chaîne d’une date, qui doit être au format défini par le format paramètre. Elle exige également que les <Date>éléments , <Time>et <Offset> les éléments de la représentation sous forme de chaîne d’une date et d’une heure apparaissent dans l’ordre spécifié par format. Si la input chaîne ne correspond pas au modèle du format paramètre, avec toutes les variantes définies par le styles paramètre, la méthode lève un FormatException. En revanche, la DateTimeOffset.Parse(String, IFormatProvider, DateTimeStyles) méthode analyse la représentation sous forme de chaîne d’une date dans l’un des formats reconnus par l’objet du fournisseur de DateTimeFormatInfo formats. Parsepermet également aux <Date>éléments et <Time><Offset> aux éléments de la représentation sous forme de chaîne d’une date et d’une heure d’apparaître dans n’importe quel ordre.

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 du input paramètre. 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, inputce décalage doit inclure un signe négatif ou un signe positif. Si le signe est manquant, la méthode lève un FormatException.

Si format cela nécessite 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 format cela nécessite une input heure, mais pas une date, l’objet résultant DateTimeOffset est affecté à la date actuelle sur le système local. Si format cela 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 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 input sont définis par le formatProvider paramètre. Il en va de même pour le format précis , inputs’il s’agit format 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 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 le cas 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 DateTimeStyles sont pris en charge, sauf NoCurrentDateDefault. Le tableau suivant répertorie l’effet de chaque membre pris en charge.

Membre`DateTimeStyles`	Comportement
AdjustToUniversal	`input` Analyse et, si nécessaire, la 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` 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 `format` cela 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 `format`. Un espace blanc supplémentaire peut apparaître entre les composants de date et d’heure et dans des composants individuels, 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 les 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 `format` sont ignorés lors de l’analyse de la chaîne.
None	Indique que l’espace blanc supplémentaire n’est pas autorisé dans `input`. L’espace blanc doit apparaître exactement comme spécifié dans `format`. Il s'agit du comportement par défaut.
RoundtripKind	N’a aucun effet, car la DateTimeOffset structure n’inclut pas de `Kind` propriété.

Notes pour les appelants

Dans le .NET Framework 4, la ParseExact méthode lève une FormatException valeur 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

S’applique à

ParseExact(String, String, IFormatProvider)

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

public:
 static DateTimeOffset ParseExact(System::String ^ input, System::String ^ format, IFormatProvider ^ formatProvider);

public static DateTimeOffset ParseExact (string input, string format, IFormatProvider formatProvider);

public static DateTimeOffset ParseExact (string input, string format, IFormatProvider? formatProvider);

static member ParseExact : string * string * IFormatProvider -> DateTimeOffset

Public Shared Function ParseExact (input As String, format As String, formatProvider As IFormatProvider) As DateTimeOffset

Paramètres

input: String

Chaîne contenant une date et une heure à convertir.

format: String

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

formatProvider: IFormatProvider

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

Retours

DateTimeOffset

Objet qui équivaut à la date et à l’heure figurant dans input comme spécifié par format et formatProvider.

Exceptions

ArgumentException

Le décalage est supérieur à 14 heures ou inférieur à -14 heures.

ArgumentNullException

input a la valeur null.

-ou-

format a la valeur null.

FormatException

Le input est une chaîne vide ("").

ou -

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

ou -

format est une chaîne vide.

ou -

Le composant heure et l’indicateur AM/PM dans input ne correspondent pas.

Exemples

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

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

// Parse date-only value with invariant culture.
dateString = "06/15/2008";
format = "d";
try
{
   result = DateTimeOffset.ParseExact(dateString, format, provider);
   Console.WriteLine("{0} converts to {1}.", dateString, result.ToString());
}
catch (FormatException)
{
   Console.WriteLine("{0} is not in the correct format.", dateString);
}

// Parse date-only value without leading zero in month using "d" format.
// Should throw a FormatException because standard short date pattern of
// invariant culture requires two-digit month.
dateString = "6/15/2008";
try
{
   result = DateTimeOffset.ParseExact(dateString, format, provider);
   Console.WriteLine("{0} converts to {1}.", dateString, result.ToString());
}
catch (FormatException)
{
   Console.WriteLine("{0} is not in the correct format.", dateString);
}

// Parse date and time with custom specifier.
dateString = "Sun 15 Jun 2008 8:30 AM -06:00";
format = "ddd dd MMM yyyy h:mm tt zzz";
try
{
   result = DateTimeOffset.ParseExact(dateString, format, provider);
   Console.WriteLine("{0} converts to {1}.", dateString, result.ToString());
}
catch (FormatException)
{
   Console.WriteLine("{0} is not in the correct format.", dateString);
}

// Parse date and time with offset without offset//s minutes.
// Should throw a FormatException because "zzz" specifier requires leading
// zero in hours.
dateString = "Sun 15 Jun 2008 8:30 AM -06";
try
{
   result = DateTimeOffset.ParseExact(dateString, format, provider);
   Console.WriteLine("{0} converts to {1}.", dateString, result.ToString());
}
catch (FormatException)
{
   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 -07:00.
//    6/15/2008 is not in the correct format.
//    Sun 15 Jun 2008 8:30 AM -06:00 converts to 6/15/2008 8:30:00 AM -06:00.
//    Sun 15 Jun 2008 8:30 AM -06 is not in the correct format.

let provider = CultureInfo.InvariantCulture

// Parse date-only value with invariant culture.
let dateString = "06/15/2008"
let format = "d"
try
    let result = DateTimeOffset.ParseExact(dateString, format, provider)
    printfn $"{dateString} converts to {result}."
with :? FormatException ->
    printfn $"{dateString} is not in the correct format."

// Parse date-only value without leading zero in month using "d" format.
// Should throw a FormatException because standard short date pattern of
// invariant culture requires two-digit month.
let dateString = "6/15/2008"
try
    let result = DateTimeOffset.ParseExact(dateString, format, provider)
    printfn $"{dateString} converts to {result}."
with :? FormatException ->
    printfn $"{dateString} is not in the correct format."

// Parse date and time with custom specifier.
let dateString = "Sun 15 Jun 2008 8:30 AM -06:00"
let format = "ddd dd MMM yyyy h:mm tt zzz"
try
    let result = DateTimeOffset.ParseExact(dateString, format, provider)
    printfn $"{dateString} converts to {result}."
with :? FormatException ->
    printfn $"{dateString} is not in the correct format."

// Parse date and time with offset without offset//s minutes.
// Should throw a FormatException because "zzz" specifier requires leading
// zero in hours.
let dateString = "Sun 15 Jun 2008 8:30 AM -06"
try
    let result = DateTimeOffset.ParseExact(dateString, format, provider)
    printfn $"{dateString} converts to {result}."
with :? FormatException ->
    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 -07:00.
//    6/15/2008 is not in the correct format.
//    Sun 15 Jun 2008 8:30 AM -06:00 converts to 6/15/2008 8:30:00 AM -06:00.
//    Sun 15 Jun 2008 8:30 AM -06 is not in the correct format.

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

' Parse date-only value with invariant culture.
dateString = "06/15/2008"
format = "d"
Try
   result = DateTimeOffset.ParseExact(dateString, format, provider)
   Console.WriteLine("{0} converts to {1}.", dateString, result.ToString())
Catch e As FormatException
   Console.WriteLine("{0} is not in the correct format.", dateString)
End Try 

' Parse date-only value without leading zero in month using "d" format.
' Should throw a FormatException because standard short date pattern of 
' invariant culture requires two-digit month.
dateString = "6/15/2008"
Try
   result = DateTimeOffset.ParseExact(dateString, format, provider)
   Console.WriteLine("{0} converts to {1}.", dateString, result.ToString())
Catch e As FormatException
   Console.WriteLine("{0} is not in the correct format.", dateString)
End Try 

' Parse date and time with custom specifier.
dateString = "Sun 15 Jun 2008 8:30 AM -06:00"
format = "ddd dd MMM yyyy h:mm tt zzz"        
Try
   result = DateTimeOffset.ParseExact(dateString, format, provider)
   Console.WriteLine("{0} converts to {1}.", dateString, result.ToString())
Catch e As FormatException
   Console.WriteLine("{0} is not in the correct format.", dateString)
End Try 

' Parse date and time with offset without offset's minutes.
' Should throw a FormatException because "zzz" specifier requires leading  
' zero in hours.
dateString = "Sun 15 Jun 2008 8:30 AM -06"
Try
   result = DateTimeOffset.ParseExact(dateString, format, provider)
   Console.WriteLine("{0} converts to {1}.", dateString, result.ToString())
Catch e As FormatException
   Console.WriteLine("{0} is not in the correct format.", dateString)
End Try 
' The example displays the following output:
'    06/15/2008 converts to 6/15/2008 12:00:00 AM -07:00.
'    6/15/2008 is not in the correct format.
'    Sun 15 Jun 2008 8:30 AM -06:00 converts to 6/15/2008 8:30:00 AM -06:00.
'    Sun 15 Jun 2008 8:30 AM -06 is not in the correct format.

L’exemple suivant analyse un tableau de chaînes qui sont censés être conformes à ISO 8601. Comme le montre la sortie de l’exemple, les chaînes avec des espaces de début ou de fin échouent à analyser correctement, car les chaînes avec des éléments de date et d’heure hors plage ne sont pas analysés.

module parseexact_iso8601

open System

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.0000000Z "
      "2018-08-18T12:45:16.0000000+02:00"
      "2018-08-18T12:45:16.0000000-07:00" ]

for dateString in dateStrings do
    try
        let date =
            DateTimeOffset.ParseExact(dateString, "O", null)

        printfn $"""{dateString, -35} --> {date.ToString "yyyy-MM-dd HH:mm:ss.FF zzz"}"""
    with :? FormatException -> printfn $"FormatException: Unable to convert '{dateString}'"


// The example displays the following output:
//      2018-08-18T12:45:16.0000000Z        --> 2018-08-18 12:45:16 +00:00
//      FormatException: Unable to convert '2018/08/18T12:45:16.0000000Z'
//      FormatException: Unable to convert '2018-18-08T12:45:16.0000000Z'
//      FormatException: 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;

public class Example2
{
   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.0000000Z ",
                               "2018-08-18T12:45:16.0000000+02:00",
                               "2018-08-18T12:45:16.0000000-07:00" }; 
      
      foreach (var dateString in dateStrings)
      {
         try {
            var date = DateTimeOffset.ParseExact(dateString, "O", null);
            Console.WriteLine($"{dateString,-35} --> {date:yyyy-MM-dd HH:mm:ss.FF zzz}");
         }
         catch (FormatException)
         {
            Console.WriteLine($"FormatException: Unable to convert '{dateString}'");
         }   
      } 
   }
}
// The example displays the following output:
//      2018-08-18T12:45:16.0000000Z        --> 2018-08-18 12:45:16 +00:00
//      FormatException: Unable to convert '2018/08/18T12:45:16.0000000Z'
//      FormatException: Unable to convert '2018-18-08T12:45:16.0000000Z'
//      FormatException: 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

Public Module Example
   Public Sub Main()
      Dim dateStrings() As String = { "2018-08-18T12:45:16.0000000Z",
                                      "2018/08/18T12:45:16.0000000Z",
                                      "2018-18-08T12:45:16.0000000Z",
                                      " 2018-08-18T12:45:16.0000000Z ",
                                      "2018-08-18T12:45:16.0000000+02:00",
                                      "2018-08-18T12:45:16.0000000-07:00" } 
      
      For Each dateStr In dateStrings
         Try 
            Dim dat = DateTimeOffset.ParseExact(dateStr, "O", Nothing)
            Console.WriteLine($"{dateStr,-35} --> {dat:yyyy-MM-dd HH:mm:ss.FF zzz}")
         Catch  e As FormatException
            Console.WriteLine($"FormatException: Unable to convert '{dateStr}'")
         End Try   
      Next 
   End Sub
End Module
' The example displays the following output:
'      2018-08-18T12:45:16.0000000Z        --> 2018-08-18 12:45:16 +00:00
'      FormatException: Unable to convert '2018/08/18T12:45:16.0000000Z'
'      FormatException: Unable to convert '2018-18-08T12:45:16.0000000Z'
'      FormatException: 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

La ParseExact(String, String, IFormatProvider) méthode analyse la représentation sous forme de chaîne d’une date, qui doit être au format défini par le format paramètre. Elle exige également que les <Date>éléments , <Time>et <Offset> les éléments de la représentation sous forme de chaîne d’une date et d’une heure apparaissent dans l’ordre spécifié par format. Si la input chaîne ne correspond pas à ce format paramètre, la méthode lève un FormatException. En revanche, la DateTimeOffset.Parse(String, IFormatProvider) méthode analyse la représentation sous forme de chaîne d’une date dans l’un des formats reconnus par l’objet du fournisseur de DateTimeFormatInfo format. Parsepermet également aux <Date>éléments et <Time><Offset> aux éléments de la représentation sous forme de chaîne d’une date et d’une heure d’apparaître dans n’importe quel ordre.

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 format requis du input paramètre. 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 , zzou zzz personnalisés pour indiquer qu’un décalage doit être présent input, ce décalage doit inclure un signe négatif ou un signe positif. Si le signe est manquant, la méthode lève un FormatException.

Si format nécessaire qui input contient une date, mais pas une heure, l’objet résultant DateTimeOffset est affecté à l’heure de minuit (0:00:00). Si format nécessaire qui input contient une heure, mais pas une date, l’objet résultant DateTimeOffset est affecté à la date actuelle sur le système local. S’il format n’est pas nécessaire de input contenir un décalage, l’objet résultant DateTimeOffset est affecté au décalage de fuseau horaire du système local.

Les symboles et chaînes de date et d’heure particuliers utilisés sont input définis par le formatProvider paramètre, comme c’est le format précis de input s’il format 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 sa 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é.

Notes pour les appelants

Voir aussi

S’applique à

ParseExact(ReadOnlySpan<Char>, ReadOnlySpan<Char>, IFormatProvider, DateTimeStyles)

Convertit une étendue de caractères qui représente une date et 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 de la date et de l’heure doit correspondre exactement au format spécifié.

public static DateTimeOffset ParseExact (ReadOnlySpan<char> input, ReadOnlySpan<char> format, IFormatProvider? formatProvider, System.Globalization.DateTimeStyles styles = System.Globalization.DateTimeStyles.None);

public static DateTimeOffset ParseExact (ReadOnlySpan<char> input, ReadOnlySpan<char> format, IFormatProvider formatProvider, System.Globalization.DateTimeStyles styles = System.Globalization.DateTimeStyles.None);

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

Public Shared Function ParseExact (input As ReadOnlySpan(Of Char), format As ReadOnlySpan(Of Char), formatProvider As IFormatProvider, Optional styles As DateTimeStyles = System.Globalization.DateTimeStyles.None) As DateTimeOffset

Paramètres

input: ReadOnlySpan<Char>

Étendue de caractères qui représente une date et une heure.

format: ReadOnlySpan<Char>

Étendue de caractères qui contient un spécificateur de format définissant le format attendu de input.

formatProvider: IFormatProvider

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

styles: DateTimeStyles

Combinaison d'opérations de bits de valeurs d'énumération qui indique le format autorisé du paramètre input.

Retours

DateTimeOffset

Objet qui équivaut à la date et à l’heure figurant dans le paramètre input, comme spécifié par les paramètres format, formatProvider et styles.

Exceptions

ArgumentException

Le décalage est supérieur à 14 heures ou inférieur à -14 heures. -ou- Le styles paramètre inclut une valeur non prise en charge. -ou- Le styles paramètre contient des DateTimeStyles valeurs qui ne peuvent pas être utilisées ensemble.

FormatException

input est une étendue de caractères vide. -ou- input ne contient pas de représentation sous forme de chaîne valide d’une date et heure. -ou- format est une étendue de caractères vide. -ou- Le composant horaire et l’indicateur AM/PM dans input ne sont pas d’accord.

Remarques

Cette méthode analyse une étendue de caractères qui représente une date, qui doit être au format défini par le format paramètre. Il nécessite également que les éléments et <Time><Offset> les <Date>éléments de la représentation sous forme de chaîne d’une date et d’une heure apparaissent dans l’ordre spécifié par format. Si input elle ne correspond pas au format modèle, la méthode lève un FormatException. En revanche, la DateTimeOffset.Parse(ReadOnlySpan<Char>, IFormatProvider, DateTimeStyles) méthode analyse la représentation sous forme de chaîne d’une date dans l’un des formats reconnus par l’objet du fournisseur de DateTimeFormatInfo format. Parsepermet également aux <Date>éléments et <Time><Offset> aux éléments de la représentation sous forme de chaîne d’une date et d’une heure d’apparaître dans n’importe quel ordre.

Le format paramètre est une étendue de caractères qui contient un spécificateur de format standard à caractère unique ou un ou plusieurs spécificateurs de format personnalisés qui définissent le format requis du input paramètre. 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 , zzou zzz personnalisés pour indiquer qu’un décalage doit être présent input, ce décalage doit inclure un signe négatif ou un signe positif. Si le signe est manquant, la méthode lève un FormatException.

Les symboles et chaînes de date et d’heure particuliers utilisés input sont définis par le formatProvider paramètre, comme c’est le format précis de s’il s’agit format d’un spécificateur de input 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 sa 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é.

S’applique à

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

Convertit une étendue de caractères qui contient la représentation sous forme de chaîne d’une date et d’une heure en DateTimeOffset à l’aide du style, des informations de format propres à la culture et des formats 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 DateTimeOffset ParseExact (ReadOnlySpan<char> input, string[] formats, IFormatProvider? formatProvider, System.Globalization.DateTimeStyles styles = System.Globalization.DateTimeStyles.None);

public static DateTimeOffset ParseExact (ReadOnlySpan<char> input, string[] formats, IFormatProvider formatProvider, System.Globalization.DateTimeStyles styles = System.Globalization.DateTimeStyles.None);

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

Public Shared Function ParseExact (input As ReadOnlySpan(Of Char), formats As String(), formatProvider As IFormatProvider, Optional styles As DateTimeStyles = System.Globalization.DateTimeStyles.None) As DateTimeOffset

Paramètres

input: ReadOnlySpan<Char>

Étendue de caractères contenant une date et une heure à convertir.

formats: String[]

Tableau des spécificateurs de format qui définissent les formats attendus 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.

Retours

DateTimeOffset

Objet qui équivaut à la date et à l’heure figurant dans le paramètre input, comme spécifié par les paramètres formats, formatProvider et styles.

Exceptions

ArgumentException

Le décalage est supérieur à 14 heures ou inférieur à -14 heures. -ou- styles inclut une valeur non prise en charge. -ou- Le styles paramètre contient des DateTimeStyles valeurs qui ne peuvent pas être utilisées ensemble.

FormatException

input est une étendue de caractères vide. -ou- input ne contient pas de représentation sous forme de chaîne valide d’une date et heure. -ou- Aucun élément de contient un spécificateur de formats format valide. -ou- Le composant horaire et l’indicateur AM/PM dans input ne sont pas d’accord.

Remarques

Cette méthode analyse une étendue de caractères représentant une date qui correspond à l’un des modèles attribués au formats paramètre. S’il input ne correspond pas à l’un de ces modèles avec l’une des variantes définies par le styles paramètre, la méthode lève un FormatException. En plus de comparer input à plusieurs modèles de mise en forme, cette surcharge se comporte de manière identique à la DateTimeOffset.ParseExact(ReadOnlySpan<Char>, ReadOnlySpan<Char>, IFormatProvider, DateTimeStyles) méthode.

Important

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

Membre`DateTimeStyles`	Comportement
AdjustToUniversal	`input` Analyse et, si nécessaire, la 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 correspondance ne `formats` nécessite pas de valeur `input` 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 ne `formats` nécessite pas de valeur `input` 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 `format`. 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 `formats`. Elles sont ignorées lors de l’analyse de la chaîne.
AllowTrailingWhite	Permet `input` d’inclure les espaces de fin non spécifiés par `formats`. 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 `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 qu’une `formats` correspondance 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é.

S’applique à

Partager via

DateTimeOffset.ParseExact Méthode

Définition

Surcharges

ParseExact(String, String[], IFormatProvider, DateTimeStyles)

Paramètres

Retours

Exceptions

Exemples

Remarques

Notes pour les appelants

Voir aussi

S’applique à

ParseExact(String, String, IFormatProvider, DateTimeStyles)

Paramètres

Retours

Exceptions

Exemples

Remarques

Notes pour les appelants

Voir aussi

S’applique à

ParseExact(String, String, IFormatProvider)

Paramètres

Retours

Exceptions

Exemples

Remarques

Notes pour les appelants

Voir aussi

S’applique à

ParseExact(ReadOnlySpan<Char>, ReadOnlySpan<Char>, IFormatProvider, DateTimeStyles)

Paramètres

Retours

Exceptions

Remarques

S’applique à

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

Paramètres

Retours

Exceptions

Remarques

S’applique à

Ressources supplémentaires