DateTimeOffset.ParseExact Méthode

Définition

Convertit la représentation sous forme de chaîne spécifiée d'une date et d'une heure en son équivalent DateTimeOffset.Converts the specified string representation of a date and time to its DateTimeOffset equivalent. Le format de la représentation sous forme de chaîne doit correspondre exactement à un format spécifié.The format of the string representation must match a specified format exactly.

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.Converts the specified string representation of a date and time to its DateTimeOffset equivalent using the specified formats, culture-specific format information, and style. Le format de la représentation sous forme de chaîne doit correspondre exactement à l'un des formats spécifiés.The format of the string representation must match one of the specified formats exactly.

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.Converts the specified string representation of a date and time to its DateTimeOffset equivalent using the specified format, culture-specific format information, and style. Le format de la représentation sous forme de chaîne doit correspondre exactement au format spécifié.The format of the string representation must match the specified format exactly.

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.Converts a character span that represents a date and time to its DateTimeOffset equivalent using the specified format, culture-specific format information, and style. Le format de la représentation de la date et de l’heure doit correspondre exactement au format spécifié.The format of the date and time representation must match the specified format exactly.

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.Converts the specified string representation of a date and time to its DateTimeOffset equivalent using the specified format and culture-specific format information. Le format de la représentation sous forme de chaîne doit correspondre exactement au format spécifié.The format of the string representation must match the specified format exactly.

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.Converts a character span that contains the string representation of a date and time to its DateTimeOffset equivalent using the specified formats, culture-specific format information, and style. Le format de la représentation de la date et de l’heure doit correspondre exactement à l'un des formats spécifiés.The format of the date and time representation must match one of the specified formats exactly.

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.Converts the specified string representation of a date and time to its DateTimeOffset equivalent using the specified formats, culture-specific format information, and style. Le format de la représentation sous forme de chaîne doit correspondre exactement à l'un des formats spécifiés.The format of the string representation must match one of the specified formats exactly.

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);
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.A string that contains a date and time to convert.

formats
String[]

Tableau des spécificateurs de format qui définissent les formats attendus de input.An array of format specifiers that define the expected formats of input.

formatProvider
IFormatProvider

Objet qui fournit des informations de mise en forme propres à la culture sur input.An object that supplies culture-specific formatting information about input.

styles
DateTimeStyles

Combinaison d'opérations de bits de valeurs d'énumération qui indique le format autorisé du paramètre input.A bitwise combination of enumeration values that indicates the permitted format of input.

Retours

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.An object that is equivalent to the date and time that is contained in the input parameter, as specified by the formats, formatProvider, and styles parameters.

Exceptions

Le décalage est supérieur à 14 heures ou inférieur à -14 heures.The offset is greater than 14 hours or less than -14 hours.

- ou --or- styles contient une valeur non prise en charge.styles includes an unsupported value.

- ou --or- Le paramètre styles contient des valeurs DateTimeStyles qui ne peuvent pas être utilisées ensemble.The styles parameter contains DateTimeStyles values that cannot be used together.

input a la valeur null.input is null.

Le input est une chaîne vide ("").input is an empty string ("").

- ou --or- input ne contient pas de représentation sous forme de chaîne valide d’une date et d’une heure.input does not contain a valid string representation of a date and time.

- ou --or- Aucun élément de formats ne contient un spécificateur de format valide.No element of formats contains a valid format specifier.

- ou --or- Le composant heure et l’indicateur AM/PM dans input ne correspondent pas.The hour component and the AM/PM designator in input do not agree.

Exemples

L’exemple suivant définit plusieurs formats d’entrée pour la représentation sous forme de chaîne d’une valeur de date et d’heure et de décalage, puis passe la chaîne entrée par l’utilisateur à la méthode DateTimeOffset.ParseExact(String, String[], IFormatProvider, DateTimeStyles).The following example defines multiple input formats for the string representation of a date and time and offset value, and then passes the string that is entered by the user to the DateTimeOffset.ParseExact(String, String[], IFormatProvider, DateTimeStyles) method.

 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 
 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 méthode DateTimeOffset.ParseExact(String, String[], IFormatProvider, DateTimeStyles) analyse la représentation sous forme de chaîne d’une date qui correspond à l’un des modèles affectés au paramètre formats.The DateTimeOffset.ParseExact(String, String[], IFormatProvider, DateTimeStyles) method parses the string representation of a date that matches any one of the patterns assigned to the formats parameter. Si la chaîne de input ne correspond à aucun de ces modèles avec l’une des variations définies par le paramètre styles, la méthode lève une FormatException.If the input string does not match any one of these patterns with any of the variations defined by the styles parameter, the method throws a FormatException. Hormis la comparaison des input à plusieurs modèles de mise en forme, cette surcharge se comporte de la même façon que la méthode DateTimeOffset.ParseExact(String, String, IFormatProvider, DateTimeStyles).Aside from comparing input to multiple formatting patterns, this overload behaves identically to the DateTimeOffset.ParseExact(String, String, IFormatProvider, DateTimeStyles) method.

Le paramètre formats est un tableau de chaînes dont les éléments contiennent un spécificateur de format standard unique ou un ou plusieurs spécificateurs de format personnalisés qui définissent le modèle possible du paramètre input.The formats parameter is a string array whose elements contain either a single standard format specifier or one or more custom format specifiers that define the possible pattern of the input parameter. Lorsque la méthode est appelée, input doit correspondre à l’un de ces modèles.When the method is called, input must match one of these patterns. 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.For details about valid formatting codes, see Standard Date and Time Format Strings and Custom Date and Time Format Strings. Si l’élément correspondant dans formats inclut les spécificateurs de format personnalisés z, zzou zzz pour indiquer qu’un offset doit être présent dans input, cet offset doit inclure un signe négatif ou un signe positif.If the matched element in formats includes the z, zz, or zzz custom format specifiers to indicate that an offset must be present in input, that offset must include either a negative sign or a positive sign. Si le signe est manquant, la méthode lève une FormatException.If the sign is missing, the method throws a FormatException.

Important

L’utilisation du paramètre formats 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.Using the formats parameter of this overload to specify multiple formats can help reduce the frustration many users experience when they enter dates and times. En particulier, la possibilité de définir plusieurs modèles d’entrée permet à une application de gérer des représentations de date et d’heure qui peuvent inclure ou manquer des zéros non significatifs dans les mois, les jours, les heures, les minutes et les secondes.In particular, the ability to define multiple input patterns enables an application to handle date and time representations that can either include or lack leading zeros in months, days, hours, minutes, and seconds. L’exemple en fournit une illustration.The example provides an illustration of this.

Si l’élément correspondant dans formats requiert que input contiennent une date, mais pas une heure, l’objet DateTimeOffset résultant reçoit une heure de minuit (0:00:00).If the matched element in formats requires that input contain a date but not a time, the resulting DateTimeOffset object is assigned a time of midnight (0:00:00). Si l’élément correspondant dans formats requiert que input contiennent une heure mais pas une date, l’objet DateTimeOffset résultant reçoit la date actuelle sur le système local.If the matched element in formats requires that input contain a time but not a date, the resulting DateTimeOffset object is assigned the current date on the local system. Si l’élément correspondant dans formats ne requiert pas que input contiennent un offset, le décalage de l’objet DateTimeOffset résultant dépend de la valeur du paramètre styles.If the matched element in formats does not require that input contain an offset, the offset of the resulting DateTimeOffset object depends on the value of the styles parameter. Si styles contient des AssumeLocal, le décalage du fuseau horaire local est assigné à l’objet DateTimeOffset.If styles includes AssumeLocal, the offset of the local time zone is assigned to the DateTimeOffset object. Si styles comprend AssumeUniversal, l’offset de temps universel coordonné (UTC, Universal Time Coordinated), ou + 00:00, est assigné à l’objet DateTimeOffset.If styles includes AssumeUniversal, the Coordinated Universal Time (UTC) offset, or +00:00, is assigned to the DateTimeOffset object. Si aucune valeur n’est spécifiée, le décalage du fuseau horaire local est utilisé.If neither value is specified, the offset of the local time zone is used.

Les symboles et les chaînes de date et d’heure particuliers utilisés dans input sont définis par le paramètre formatProvider.The particular date and time symbols and strings used in input are defined by the formatProvider parameter. Il en va de même pour le format précis de input, si l’élément correspondant de formats est une chaîne de spécificateur de format standard.The same is true for the precise format of input, if the matching element of formats is a standard format specifier string. Le paramètre formatProvider peut être l’un des éléments suivants :The formatProvider parameter can be either of the following:

Si formatprovider est null, l’objet CultureInfo qui correspond à la culture actuelle est utilisé.If formatprovider is null, the CultureInfo object that corresponds to the current culture is used.

Le paramètre styles définit si l’espace blanc est autorisé dans la chaîne d’entrée, indique comment les chaînes sans composant de décalage explicite sont analysées et prend en charge la conversion UTC dans le cadre de l’opération d’analyse.The styles parameter defines whether white space is permitted in the input string, indicates how strings without an explicit offset component are parsed, and supports UTC conversion as part of the parsing operation. Tous les membres de l’énumération DateTimeStyles sont pris en charge à l’exception de NoCurrentDateDefault.All members of the DateTimeStyles enumeration are supported except NoCurrentDateDefault. Le tableau suivant répertorie les effets de chaque membre pris en charge.The following table lists the effect of each supported member.

MembreDateTimeStylesDateTimeStyles member ComportementBehavior
AdjustToUniversal Analyse input et, si nécessaire, le convertit en heure UTC.Parses input and, if necessary, converts it to UTC. Elle est équivalente à l’analyse d’une chaîne, puis à l’appel de la méthode DateTimeOffset.ToUniversalTime de l’objet DateTimeOffset retourné.It is equivalent to parsing a string, and then calling the DateTimeOffset.ToUniversalTime method of the returned DateTimeOffset object.
AssumeLocal Si l’élément correspondant dans formats ne requiert pas que input contiennent une valeur d’offset, l’objet DateTimeOffset retourné reçoit le décalage du fuseau horaire local.If the matched element in formats does not require that input contain an offset value, the returned DateTimeOffset object is given the offset of the local time zone. Valeur par défaut.This is the default value.
AssumeUniversal Si l’élément correspondant dans formats ne requiert pas que input contiennent une valeur de décalage, l’objet DateTimeOffset retourné reçoit le décalage UTC (+ 00:00).If the matched element in formats does not require that input contain an offset value, the returned DateTimeOffset object is given the UTC offset (+00:00).
AllowInnerWhite Autorise input à inclure un espace blanc interne non spécifié par format.Allows input to include inner white space not specified by format. Des espaces blancs supplémentaires peuvent apparaître entre les composants de date et d’heure et dans des composants individuels (à l’exception du décalage) et sont ignorés lors de l’analyse de la chaîne.Extra white space can appear between date and time components and within individual components (except the offset), and is ignored when parsing the string.
AllowLeadingWhite Permet à input d’inclure des espaces de début non spécifiés par formats.Allows input to include leading spaces not specified by formats. Elles sont ignorées lors de l’analyse de la chaîne.These are ignored when parsing the string.
AllowTrailingWhite Permet à input d’inclure des espaces de fin non spécifiés par formats.Allows input to include trailing spaces not specified by formats. Elles sont ignorées lors de l’analyse de la chaîne.These are ignored when parsing the string.
AllowWhiteSpaces Permet à input d’inclure des espaces de début, de fin et internes non spécifiés par formats.Allows input to include leading, trailing, and inner spaces not specified by formats. Tous les caractères d’espace blanc supplémentaires non spécifiés dans l’élément correspondant dans formats sont ignorés lors de l’analyse de la chaîne.All extra white-space characters not specified in the matched element in formats are ignored when parsing the string.
None Indique que des espaces blancs supplémentaires ne sont pas autorisés dans input.Indicates that additional white space is not permitted in input. L’espace blanc doit apparaître exactement comme spécifié dans un élément particulier de formats pour qu’une correspondance se produise.White space must appear exactly as specified in a particular element of formats for a match to occur. Il s'agit du comportement par défaut.This is the default behavior.
RoundtripKind N’a aucun effet, car la structure DateTimeOffset n’inclut pas de propriété Kind.Has no effect because the DateTimeOffset structure does not include a Kind property.

Notes pour les appelants

Dans le .NET Framework 4.NET Framework 4, la méthode ParseExact lève une FormatException si la chaîne à analyser contient un composant heure et un indicateur AM/PM qui ne sont pas en accord.In the .NET Framework 4.NET Framework 4, the ParseExact method throws a FormatException if the string to be parsed contains an hour component and an AM/PM designator that are not in agreement. Dans le .NET Framework 3.5.NET Framework 3.5 et les versions antérieures, l’indicateur AM/PM est ignoré.In the .NET Framework 3.5.NET Framework 3.5 and earlier versions, the AM/PM designator is ignored.

Voir aussi

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.Converts the specified string representation of a date and time to its DateTimeOffset equivalent using the specified format, culture-specific format information, and style. Le format de la représentation sous forme de chaîne doit correspondre exactement au format spécifié.The format of the string representation must match the specified format exactly.

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);
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.A string that contains a date and time to convert.

format
String

Spécificateur de format définissant le format attendu de input.A format specifier that defines the expected format of input.

formatProvider
IFormatProvider

Objet qui fournit des informations de mise en forme propres à la culture sur input.An object that supplies culture-specific formatting information about input.

styles
DateTimeStyles

Combinaison d'opérations de bits de valeurs d'énumération qui indique le format autorisé du paramètre input.A bitwise combination of enumeration values that indicates the permitted format of input.

Retours

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.An object that is equivalent to the date and time that is contained in the input parameter, as specified by the format, formatProvider, and styles parameters.

Exceptions

Le décalage est supérieur à 14 heures ou inférieur à -14 heures.The offset is greater than 14 hours or less than -14 hours.

- ou --or- Le paramètre styles inclut une valeur non prise en charge.The styles parameter includes an unsupported value.

- ou --or- Le paramètre styles contient des valeurs DateTimeStyles qui ne peuvent pas être utilisées ensemble.The styles parameter contains DateTimeStyles values that cannot be used together.

input a la valeur null.input is null.

- ou --or- format a la valeur null.format is null.

Le input est une chaîne vide ("").input is an empty string ("").

- ou --or- input ne contient pas de représentation sous forme de chaîne valide d’une date et d’une heure.input does not contain a valid string representation of a date and time.

- ou --or- format est une chaîne vide.format is an empty string.

- ou --or- Le composant heure et l’indicateur AM/PM dans input ne correspondent pas.The hour component and the AM/PM designator in input do not agree.

Exemples

L’exemple suivant utilise la méthode DateTimeOffset.ParseExact(String, String, IFormatProvider, DateTimeStyles) avec des spécificateurs de format standard et personnalisés, la culture dite indifférente et différentes valeurs DateTimeStyles pour analyser plusieurs chaînes de date et d’heure.The following example uses the DateTimeOffset.ParseExact(String, String, IFormatProvider, DateTimeStyles) method with standard and custom format specifiers, the invariant culture, and various DateTimeStyles values to parse several date and time strings.

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.
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 valeurs de DateTimeStyles pour analyser un tableau de chaînes qui sont censées être conformes à la norme ISO 8601.The following example uses a variety of DateTimeStyles values to parse an array of strings that are expected to conform to ISO 8601. Comme le montre la sortie de l’exemple, les chaînes qui se trouvent dans le format approprié ne peuvent pas être analysées si :As the output from the example shows, strings that are in the proper format fail to parse if:

  • ils contiennent des espaces blancs et un indicateur de DateTimeStyles approprié (par exemple, DateTimeStyles.AllowWhiteSpaces n’a pas été fourni dans l’appel de méthode.they contain white space, and an appropriate DateTimeStyles flag (such as DateTimeStyles.AllowWhiteSpaces has not been supplied in the method call.

  • ils contiennent des éléments de date et d’heure hors limites.they contain date and time elements that are out of range.

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.Strings that do not specify a UTC offset are assumed to have the offset of the local time zone (in this case, -07:00) unless the DateTimeStyles.AssumeUniversal flag is supplied in the method call. Dans ce cas, ils sont considérés comme étant du temps universel coordonné.In that case, they are assumed to be Universal Coordinated Time.

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 méthode DateTimeOffset.ParseExact(String, String, IFormatProvider, DateTimeStyles) analyse la représentation sous forme de chaîne d’une date, qui doit être au format défini par le paramètre format.The DateTimeOffset.ParseExact(String, String, IFormatProvider, DateTimeStyles) method parses the string representation of a date, which must be in the format defined by the format parameter. Elle exige également que les <Date >, <Time > et <offset > éléments de la représentation sous forme de chaîne d’une date et d’une heure s’affichent dans l’ordre spécifié par format.It also requires that the <Date>, <Time>, and <Offset> elements of the string representation of a date and time appear in the order specified by format. Si la chaîne de input ne correspond pas au modèle du paramètre format, avec les variations définies par le paramètre styles, la méthode lève une FormatException.If the input string does not match the pattern of the format parameter, with any variations defined by the styles parameter, the method throws a FormatException. En revanche, la méthode DateTimeOffset.Parse(String, IFormatProvider, DateTimeStyles) analyse la représentation sous forme de chaîne d’une date dans l’un des formats reconnus par l’objet DateTimeFormatInfo du fournisseur de format.In contrast, the DateTimeOffset.Parse(String, IFormatProvider, DateTimeStyles) method parses the string representation of a date in any one of the formats recognized by the format provider's DateTimeFormatInfo object. Parse permet également d’afficher dans n’importe quel ordre les <Date >, <Time > et <offset > éléments de la représentation sous forme de chaîne d’une date et d’une heure.Parse also allows the <Date>, <Time>, and <Offset> elements of the string representation of a date and time to appear in any order.

Le paramètre format est une chaîne qui contient soit un spécificateur de format standard unique, soit un ou plusieurs spécificateurs de format personnalisés qui définissent le modèle requis du paramètre input.The format parameter is a string that contains either a single standard format specifier or one or more custom format specifiers that define the required pattern of the input parameter. 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.For details about valid formatting codes, see Standard Date and Time Format Strings and Custom Date and Time Format Strings. Si format inclut les spécificateurs de format personnalisés z, zzou zzz pour indiquer qu’un offset doit être présent dans input, cet offset doit inclure un signe négatif ou un signe positif.If format includes the z, zz, or zzz custom format specifiers to indicate that an offset must be present in input, that offset must include either a negative sign or a positive sign. Si le signe est manquant, la méthode lève une FormatException.If the sign is missing, the method throws a FormatException.

Si format exige que les input contiennent une date mais pas une heure, l’objet DateTimeOffset résultant reçoit une heure de minuit (0:00:00).If format requires that input contain a date but not a time, the resulting DateTimeOffset object is assigned a time of midnight (0:00:00). Si format exige que les input contiennent une heure mais pas une date, l’objet DateTimeOffset résultant reçoit la date actuelle sur le système local.If format requires that input contain a time but not a date, the resulting DateTimeOffset object is assigned the current date on the local system. Si format ne requiert pas que input contiennent un décalage, le décalage de l’objet DateTimeOffset résultant dépend de la valeur du paramètre styles.If format does not require that input contain an offset, the offset of the resulting DateTimeOffset object depends on the value of the styles parameter. Si styles contient des AssumeLocal, le décalage du fuseau horaire local est assigné à l’objet DateTimeOffset.If styles includes AssumeLocal, the offset of the local time zone is assigned to the DateTimeOffset object. Si styles comprend AssumeUniversal, l’offset de temps universel coordonné (UTC, Universal Time Coordinated), ou + 00:00, est assigné à l’objet DateTimeOffset.If styles includes AssumeUniversal, the Coordinated Universal Time (UTC) offset, or +00:00, is assigned to the DateTimeOffset object. Si aucune valeur n’est spécifiée, le décalage du fuseau horaire local est utilisé.If neither value is specified, the offset of the local time zone is used.

Les symboles et les chaînes de date et d’heure particuliers utilisés dans input sont définis par le paramètre formatProvider.The particular date and time symbols and strings used in input are defined by the formatProvider parameter. Il en va de même pour le format précis de input, si format est une chaîne de spécificateur de format standard.The same is true for the precise format of input, if format is a standard format specifier string. Le paramètre formatProvider peut être l’un des éléments suivants :The formatProvider parameter can be either of the following:

Si formatprovider est null, l’objet CultureInfo qui correspond à la culture actuelle est utilisé.If formatprovider is null, the CultureInfo object that corresponds to the current culture is used.

Le paramètre styles définit si l’espace blanc est autorisé dans la chaîne d’entrée, indique comment les chaînes sans composant de décalage explicite sont analysées et prend en charge la conversion UTC dans le cadre de l’opération d’analyse.The styles parameter defines whether white space is allowed in the input string, indicates how strings without an explicit offset component are parsed, and supports UTC conversion as part of the parsing operation. Tous les membres de l’énumération DateTimeStyles sont pris en charge à l’exception de NoCurrentDateDefault.All members of the DateTimeStyles enumeration are supported except NoCurrentDateDefault. Le tableau suivant répertorie les effets de chaque membre pris en charge.The following table lists the effect of each supported member.

MembreDateTimeStylesDateTimeStyles member ComportementBehavior
AdjustToUniversal Analyse input et, si nécessaire, le convertit en heure UTC.Parses input and, if necessary, converts it to UTC. Elle est équivalente à l’analyse d’une chaîne, puis à l’appel de la méthode DateTimeOffset.ToUniversalTime de l’objet DateTimeOffset retourné.It is equivalent to parsing a string, and then calling the DateTimeOffset.ToUniversalTime method of the returned DateTimeOffset object.
AssumeLocal Si format ne requiert pas que input contient une valeur de décalage, l’offset du fuseau horaire local est attribué à l’objet DateTimeOffset retourné.If format does not require that input contain an offset value, the returned DateTimeOffset object is given the offset of the local time zone. Valeur par défaut.This is the default value.
AssumeUniversal Si format ne requiert pas que input contient une valeur de décalage, l’objet DateTimeOffset retourné reçoit le décalage UTC (+ 00:00).If format does not require that input contain an offset value, the returned DateTimeOffset object is given the UTC offset (+00:00).
AllowInnerWhite Autorise input à inclure un espace blanc interne non spécifié par format.Allows input to include inner white space not specified by format. Des espaces blancs supplémentaires peuvent 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.Extra white space can appear between date and time components and within individual components, and is ignored when parsing the string.
AllowLeadingWhite Permet à input d’inclure des espaces de début non spécifiés par format.Allows input to include leading spaces not specified by format. Elles sont ignorées lors de l’analyse de la chaîne.These are ignored when parsing the string.
AllowTrailingWhite Permet à input d’inclure des espaces de fin non spécifiés par format.Allows input to include trailing spaces not specified by format. Elles sont ignorées lors de l’analyse de la chaîne.These are ignored when parsing the string.
AllowWhiteSpaces Permet à input d’inclure des espaces de début, de fin et internes non spécifiés par format.Allows input to include leading, trailing, and inner spaces not specified by format. Tous les caractères d’espace blanc supplémentaires non spécifiés dans format sont ignorés lors de l’analyse de la chaîne.All extra white-space characters not specified in format are ignored when parsing the string.
None Indique que des espaces blancs supplémentaires ne sont pas autorisés dans input.Indicates that additional white space is not permitted in input. L’espace blanc doit apparaître exactement comme indiqué dans format.White space must appear exactly as specified in format. Il s'agit du comportement par défaut.This is the default behavior.
RoundtripKind N’a aucun effet, car la structure DateTimeOffset n’inclut pas de propriété Kind.Has no effect because the DateTimeOffset structure does not include a Kind property.

Notes pour les appelants

Dans le .NET Framework 4.NET Framework 4, la méthode ParseExact lève une FormatException si la chaîne à analyser contient un composant heure et un indicateur AM/PM qui ne sont pas en accord.In the .NET Framework 4.NET Framework 4, the ParseExact method throws a FormatException if the string to be parsed contains an hour component and an AM/PM designator that are not in agreement. Dans le .NET Framework 3.5.NET Framework 3.5 et les versions antérieures, l’indicateur AM/PM est ignoré.In the .NET Framework 3.5.NET Framework 3.5 and earlier versions, the AM/PM designator is ignored.

Voir aussi

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.Converts a character span that represents a date and time to its DateTimeOffset equivalent using the specified format, culture-specific format information, and style. Le format de la représentation de la date et de l’heure doit correspondre exactement au format spécifié.The format of the date and time representation must match the specified format exactly.

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.A character span that represents a date and time.

format
ReadOnlySpan<Char>

Étendue de caractères qui contient un spécificateur de format définissant le format attendu de input.A character span that contains a format specifier that defines the expected format of input.

formatProvider
IFormatProvider

Objet qui fournit des informations de mise en forme propres à la culture concernant input.An object that provides culture-specific formatting information about input.

styles
DateTimeStyles

Combinaison d'opérations de bits de valeurs d'énumération qui indique le format autorisé du paramètre input.A bitwise combination of enumeration values that indicates the permitted format of input.

Retours

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.An object that is equivalent to the date and time that is contained in the input parameter, as specified by the format, formatProvider, and styles parameters.

Exceptions

Le décalage est supérieur à 14 heures ou inférieur à -14 heures.The offset is greater than 14 hours or less than -14 hours.
- ou --or-
Le paramètre styles inclut une valeur non prise en charge.The styles parameter includes an unsupported value.
- ou --or-
Le paramètre styles contient des valeurs DateTimeStyles qui ne peuvent pas être utilisées ensemble.The styles parameter contains DateTimeStyles values that cannot be used together.

input est une étendue de caractères vide.input is an empty character span.
-ou- input ne contient pas de représentation sous forme de chaîne valide d’une date et heure.-or- input does not contain a valid string representation of a date and time.
-ou- format est une étendue de caractères vide.-or- format is an empty character span.
- ou --or-
Le composant heure et l’indicateur AM/PM dans input ne correspondent pas.The hour component and the AM/PM designator in input do not agree.

Remarques

Cette méthode analyse une plage de caractères qui représente une date, qui doit être au format défini par le paramètre format.This method parses a character span that represents a date, which must be in the format defined by the format parameter. Elle exige également que les <Date >, <Time > et <offset > éléments de la représentation sous forme de chaîne d’une date et d’une heure s’affichent dans l’ordre spécifié par format.It also requires that the <Date>, <Time>, and <Offset> elements of the string representation of a date and time appear in the order specified by format. Si input ne correspond pas au modèle de format, la méthode lève une FormatException.If input does not match the format pattern, the method throws a FormatException. En revanche, la méthode DateTimeOffset.Parse(ReadOnlySpan<Char>, IFormatProvider, DateTimeStyles) analyse la représentation sous forme de chaîne d’une date dans l’un des formats reconnus par l’objet DateTimeFormatInfo du fournisseur de format.In contrast, the DateTimeOffset.Parse(ReadOnlySpan<Char>, IFormatProvider, DateTimeStyles) method parses the string representation of a date in any one of the formats recognized by the format provider's DateTimeFormatInfo object. Parse permet également d’afficher dans n’importe quel ordre les <Date >, <Time > et <offset > éléments de la représentation sous forme de chaîne d’une date et d’une heure.Parse also allows the <Date>, <Time>, and <Offset> elements of the string representation of a date and time to appear in any order.

Le paramètre format est une plage de caractères qui contient un spécificateur de format standard à un seul caractère ou un ou plusieurs spécificateurs de format personnalisés qui définissent le format requis du paramètre input.The format parameter is a character span that contains either a single-character standard format specifier or one or more custom format specifiers that define the required format of the input parameter. 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.For details about valid formatting codes, see Standard Date and Time Format Strings and Custom Date and Time Format Strings. Si format inclut les spécificateurs de format personnalisés z, zzou zzz pour indiquer qu’un offset doit être présent dans input, cet offset doit inclure un signe négatif ou un signe positif.If format includes the z, zz, or zzz custom format specifiers to indicate that an offset must be present in input, that offset must include either a negative sign or a positive sign. Si le signe est manquant, la méthode lève une FormatException.If the sign is missing, the method throws a FormatException.

Si format exige que les input contiennent une date mais pas une heure, l’objet DateTimeOffset résultant reçoit une heure de minuit (0:00:00).If format requires that input contain a date but not a time, the resulting DateTimeOffset object is assigned a time of midnight (0:00:00). Si format exige que les input contiennent une heure mais pas une date, l’objet DateTimeOffset résultant reçoit la date actuelle sur le système local.If format requires that input contain a time but not a date, the resulting DateTimeOffset object is assigned the current date on the local system. Si format ne requiert pas que input contiennent un décalage, le décalage de fuseau horaire du système local est assigné à l’objet DateTimeOffset résultant.If format does not require that input contain an offset, the resulting DateTimeOffset object is assigned the time zone offset of the local system.

Les symboles et les chaînes de date et d’heure particuliers utilisés dans input sont définis par le paramètre formatProvider, tout comme le format précis de input si format est un spécificateur de format standard.The particular date and time symbols and strings used in input are defined by the formatProvider parameter, as is the precise format of input if format is a standard format specifier. Le paramètre formatProvider peut être l’un des éléments suivants :The formatProvider parameter can be either of the following:

Si formatprovider est null, l’objet CultureInfo qui correspond à la culture actuelle est utilisé.If formatprovider is null, the CultureInfo object that corresponds to the current culture is used.

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.Converts the specified string representation of a date and time to its DateTimeOffset equivalent using the specified format and culture-specific format information. Le format de la représentation sous forme de chaîne doit correspondre exactement au format spécifié.The format of the string representation must match the specified format exactly.

public:
 static DateTimeOffset ParseExact(System::String ^ input, System::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.A string that contains a date and time to convert.

format
String

Spécificateur de format définissant le format attendu de input.A format specifier that defines the expected format of input.

formatProvider
IFormatProvider

Objet qui fournit des informations de mise en forme propres à la culture sur input.An object that supplies culture-specific formatting information about input.

Retours

Objet qui équivaut à la date et à l’heure figurant dans input comme spécifié par format et formatProvider.An object that is equivalent to the date and time that is contained in input as specified by format and formatProvider.

Exceptions

Le décalage est supérieur à 14 heures ou inférieur à -14 heures.The offset is greater than 14 hours or less than -14 hours.

input a la valeur null.input is null.

- ou --or- format est null.format is null.

Le input est une chaîne vide ("").input is an empty string ("").

- ou --or- input ne contient pas de représentation sous forme de chaîne valide d’une date et d’une heure.input does not contain a valid string representation of a date and time.

- ou --or- format est une chaîne vide.format is an empty string.

- ou --or- Le composant heure et l’indicateur AM/PM dans input ne correspondent pas.The hour component and the AM/PM designator in input do not agree.

Exemples

L’exemple suivant utilise la méthode DateTimeOffset.ParseExact(String, String, IFormatProvider) avec des spécificateurs de format standard et personnalisés, ainsi que la culture dite indifférente pour analyser plusieurs chaînes de date et d’heure.The following example uses the DateTimeOffset.ParseExact(String, String, IFormatProvider) method with standard and custom format specifiers and the invariant culture to parse several date and time strings.

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.                     
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ées être conformes à la norme ISO 8601.The following example parses an array of strings that are expected to conform to ISO 8601. Comme le montre la sortie de l’exemple, les chaînes avec des espaces de début ou de fin ne peuvent pas être analysées correctement, de même que les chaînes avec des éléments de date et d’heure hors limites.As the output from the example shows, strings with leading or trailing spaces fail to parse successfully, as do strings with date and time elements that are out of range.

using System;

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.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 méthode ParseExact(String, String, IFormatProvider) analyse la représentation sous forme de chaîne d’une date, qui doit être au format défini par le paramètre format.The ParseExact(String, String, IFormatProvider) method parses the string representation of a date, which must be in the format defined by the format parameter. Elle exige également que les <Date >, <Time > et <offset > éléments de la représentation sous forme de chaîne d’une date et d’une heure s’affichent dans l’ordre spécifié par format.It also requires that the <Date>, <Time>, and <Offset> elements of the string representation of a date and time appear in the order specified by format. Si la chaîne de input ne correspond pas à ce paramètre de format, la méthode lève une FormatException.If the input string does not match this format parameter, the method throws a FormatException. En revanche, la méthode DateTimeOffset.Parse(String, IFormatProvider) analyse la représentation sous forme de chaîne d’une date dans l’un des formats reconnus par l’objet DateTimeFormatInfo du fournisseur de format.In contrast, the DateTimeOffset.Parse(String, IFormatProvider) method parses the string representation of a date in any one of the formats recognized by the format provider's DateTimeFormatInfo object. Parse permet également d’afficher dans n’importe quel ordre les <Date >, <Time > et <offset > éléments de la représentation sous forme de chaîne d’une date et d’une heure.Parse also allows the <Date>, <Time>, and <Offset> elements of the string representation of a date and time to appear in any order.

Le paramètre format est une chaîne qui contient soit un spécificateur de format standard unique, soit un ou plusieurs spécificateurs de format personnalisés qui définissent le format requis du paramètre input.The format parameter is a string that contains either a single standard format specifier or one or more custom format specifiers that define the required format of the input parameter. 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.For details about valid formatting codes, see Standard Date and Time Format Strings and Custom Date and Time Format Strings. Si format inclut les spécificateurs de format personnalisés z, zzou zzz pour indiquer qu’un offset doit être présent dans input, cet offset doit inclure un signe négatif ou un signe positif.If format includes the z, zz, or zzz custom format specifiers to indicate that an offset must be present in input, that offset must include either a negative sign or a positive sign. Si le signe est manquant, la méthode lève une FormatException.If the sign is missing, the method throws a FormatException.

Si format exige que les input contiennent une date mais pas une heure, l’objet DateTimeOffset résultant reçoit une heure de minuit (0:00:00).If format requires that input contain a date but not a time, the resulting DateTimeOffset object is assigned a time of midnight (0:00:00). Si format exige que les input contiennent une heure mais pas une date, l’objet DateTimeOffset résultant reçoit la date actuelle sur le système local.If format requires that input contain a time but not a date, the resulting DateTimeOffset object is assigned the current date on the local system. Si format ne requiert pas que input contiennent un décalage, le décalage de fuseau horaire du système local est assigné à l’objet DateTimeOffset résultant.If format does not require that input contain an offset, the resulting DateTimeOffset object is assigned the time zone offset of the local system.

Les symboles et les chaînes de date et d’heure particuliers utilisés dans input sont définis par le paramètre formatProvider, tout comme le format précis de input si format est une chaîne de spécificateur de format standard.The particular date and time symbols and strings used in input are defined by the formatProvider parameter, as is the precise format of input if format is a standard format specifier string. Le paramètre formatProvider peut être l’un des éléments suivants :The formatProvider parameter can be either of the following:

Si formatprovider est null, l’objet CultureInfo qui correspond à la culture actuelle est utilisé.If formatprovider is null, the CultureInfo object that corresponds to the current culture is used.

Notes pour les appelants

Dans le .NET Framework 4.NET Framework 4, la méthode ParseExact lève une FormatException si la chaîne à analyser contient un composant heure et un indicateur AM/PM qui ne sont pas en accord.In the .NET Framework 4.NET Framework 4, the ParseExact method throws a FormatException if the string to be parsed contains an hour component and an AM/PM designator that are not in agreement. Dans le .NET Framework 3.5.NET Framework 3.5 et les versions antérieures, l’indicateur AM/PM est ignoré.In the .NET Framework 3.5.NET Framework 3.5 and earlier versions, the AM/PM designator is ignored.

Voir aussi

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.Converts a character span that contains the string representation of a date and time to its DateTimeOffset equivalent using the specified formats, culture-specific format information, and style. Le format de la représentation de la date et de l’heure doit correspondre exactement à l'un des formats spécifiés.The format of the date and time representation must match one of the specified formats exactly.

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.A character span that contains a date and time to convert.

formats
String[]

Tableau des spécificateurs de format qui définissent les formats attendus de input.An array of format specifiers that define the expected formats of input.

formatProvider
IFormatProvider

Objet qui fournit des informations de mise en forme propres à la culture sur input.An object that supplies culture-specific formatting information about input.

styles
DateTimeStyles

Combinaison d'opérations de bits de valeurs d'énumération qui indique le format autorisé du paramètre input.A bitwise combination of enumeration values that indicates the permitted format of input.

Retours

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.An object that is equivalent to the date and time that is contained in the input parameter, as specified by the formats, formatProvider, and styles parameters.

Exceptions

Le décalage est supérieur à 14 heures ou inférieur à -14 heures.The offset is greater than 14 hours or less than -14 hours.
-ou- styles inclut une valeur non prise en charge.-or- styles includes an unsupported value.
- ou --or-
Le paramètre styles contient des valeurs DateTimeStyles qui ne peuvent pas être utilisées ensemble.The styles parameter contains DateTimeStyles values that cannot be used together.

input est une étendue de caractères vide.input is an empty character span.
-ou- input ne contient pas de représentation sous forme de chaîne valide d’une date et heure.-or- input does not contain a valid string representation of a date and time.
- ou --or-
Aucun élément de formats ne contient un spécificateur de format valide.No element of formats contains a valid format specifier.
- ou --or-
Le composant heure et l’indicateur AM/PM dans input ne correspondent pas.The hour component and the AM/PM designator in input do not agree.

Remarques

Cette méthode analyse une plage de caractères représentant une date qui correspond à l’un des modèles affectés au paramètre formats.This method parses a character span representing a date that matches any one of the patterns assigned to the formats parameter. Si input ne correspond à aucun de ces modèles avec l’une des variations définies par le paramètre styles, la méthode lève une FormatException.If input does not match any one of these patterns with any of the variations defined by the styles parameter, the method throws a FormatException. Hormis la comparaison des input à plusieurs modèles de mise en forme, cette surcharge se comporte de la même façon que la méthode DateTimeOffset.ParseExact(ReadOnlySpan<Char>, ReadOnlySpan<Char>, IFormatProvider, DateTimeStyles).Aside from comparing input to multiple formatting patterns, this overload behaves identically to the DateTimeOffset.ParseExact(ReadOnlySpan<Char>, ReadOnlySpan<Char>, IFormatProvider, DateTimeStyles) method.

Le paramètre formats est un tableau de chaînes dont les éléments contiennent un spécificateur de format standard unique ou un ou plusieurs spécificateurs de format personnalisés qui définissent le modèle possible du paramètre input.The formats parameter is a string array whose elements contain either a single standard format specifier or one or more custom format specifiers that define the possible pattern of the input parameter. Lorsque la méthode est appelée, input doit correspondre à l’un de ces modèles.When the method is called, input must match one of these patterns. 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.For details about valid formatting codes, see Standard Date and Time Format Strings and Custom Date and Time Format Strings. Si l’élément correspondant dans formats inclut les spécificateurs de format personnalisés z, zzou zzz pour indiquer qu’un offset doit être présent dans input, cet offset doit inclure un signe négatif ou un signe positif.If the matched element in formats includes the z, zz, or zzz custom format specifiers to indicate that an offset must be present in input, that offset must include either a negative sign or a positive sign. Si le signe est manquant, la méthode lève une FormatException.If the sign is missing, the method throws a FormatException.

Important

L’utilisation du paramètre formats 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.Using the formats parameter of this overload to specify multiple formats can help reduce the frustration many users experience when they enter dates and times. En particulier, la possibilité de définir plusieurs modèles d’entrée permet à une application de gérer des représentations de date et d’heure qui peuvent inclure ou manquer des zéros non significatifs dans les mois, les jours, les heures, les minutes et les secondes.In particular, the ability to define multiple input patterns enables an application to handle date and time representations that can either include or lack leading zeros in months, days, hours, minutes, and seconds.

Si l’élément correspondant dans formats requiert que input contiennent une date, mais pas une heure, l’objet DateTimeOffset résultant reçoit une heure de minuit (0:00:00).If the matched element in formats requires that input contain a date but not a time, the resulting DateTimeOffset object is assigned a time of midnight (0:00:00). Si l’élément correspondant dans formats requiert que input contiennent une heure mais pas une date, l’objet DateTimeOffset résultant reçoit la date actuelle sur le système local.If the matched element in formats requires that input contain a time but not a date, the resulting DateTimeOffset object is assigned the current date on the local system. Si l’élément correspondant dans formats ne requiert pas que input contiennent un offset, le décalage de l’objet DateTimeOffset résultant dépend de la valeur du paramètre styles.If the matched element in formats does not require that input contain an offset, the offset of the resulting DateTimeOffset object depends on the value of the styles parameter. Si styles contient des AssumeLocal, le décalage du fuseau horaire local est assigné à l’objet DateTimeOffset.If styles includes AssumeLocal, the offset of the local time zone is assigned to the DateTimeOffset object. Si styles comprend AssumeUniversal, l’offset de temps universel coordonné (UTC, Universal Time Coordinated), ou + 00:00, est assigné à l’objet DateTimeOffset.If styles includes AssumeUniversal, the Coordinated Universal Time (UTC) offset, or +00:00, is assigned to the DateTimeOffset object. Si aucune valeur n’est spécifiée, le décalage du fuseau horaire local est utilisé.If neither value is specified, the offset of the local time zone is used.

Les symboles et les chaînes de date et d’heure particuliers utilisés dans input sont définis par le paramètre formatProvider.The particular date and time symbols and strings used in input are defined by the formatProvider parameter. Il en va de même pour le format précis de input, si l’élément correspondant de formats est une chaîne de spécificateur de format standard.The same is true for the precise format of input, if the matching element of formats is a standard format specifier string. Le paramètre formatProvider peut être l’un des éléments suivants :The formatProvider parameter can be either of the following:

Si formatprovider est null, l’objet CultureInfo qui correspond à la culture actuelle est utilisé.If formatprovider is null, the CultureInfo object that corresponds to the current culture is used.

Le paramètre styles définit si l’espace blanc est autorisé dans la chaîne d’entrée, indique comment les chaînes sans composant de décalage explicite sont analysées et prend en charge la conversion UTC dans le cadre de l’opération d’analyse.The styles parameter defines whether white space is permitted in the input string, indicates how strings without an explicit offset component are parsed, and supports UTC conversion as part of the parsing operation. Tous les membres de l’énumération DateTimeStyles sont pris en charge à l’exception de NoCurrentDateDefault.All members of the DateTimeStyles enumeration are supported except NoCurrentDateDefault. Le tableau suivant répertorie les effets de chaque membre pris en charge.The following table lists the effect of each supported member.

MembreDateTimeStylesDateTimeStyles member ComportementBehavior
AdjustToUniversal Analyse input et, si nécessaire, le convertit en heure UTC.Parses input and, if necessary, converts it to UTC. Elle est équivalente à l’analyse d’une chaîne, puis à l’appel de la méthode DateTimeOffset.ToUniversalTime de l’objet DateTimeOffset retourné.It is equivalent to parsing a string, and then calling the DateTimeOffset.ToUniversalTime method of the returned DateTimeOffset object.
AssumeLocal Si l’élément correspondant dans formats ne requiert pas que input contiennent une valeur d’offset, l’objet DateTimeOffset retourné reçoit le décalage du fuseau horaire local.If the matched element in formats does not require that input contain an offset value, the returned DateTimeOffset object is given the offset of the local time zone. Valeur par défaut.This is the default value.
AssumeUniversal Si l’élément correspondant dans formats ne requiert pas que input contiennent une valeur de décalage, l’objet DateTimeOffset retourné reçoit le décalage UTC (+ 00:00).If the matched element in formats does not require that input contain an offset value, the returned DateTimeOffset object is given the UTC offset (+00:00).
AllowInnerWhite Autorise input à inclure un espace blanc interne non spécifié par format.Allows input to include inner white space not specified by format. Des espaces blancs supplémentaires peuvent apparaître entre les composants de date et d’heure et dans des composants individuels (à l’exception du décalage) et sont ignorés lors de l’analyse de la chaîne.Extra white space can appear between date and time components and within individual components (except the offset), and is ignored when parsing the string.
AllowLeadingWhite Permet à input d’inclure des espaces de début non spécifiés par formats.Allows input to include leading spaces not specified by formats. Elles sont ignorées lors de l’analyse de la chaîne.These are ignored when parsing the string.
AllowTrailingWhite Permet à input d’inclure des espaces de fin non spécifiés par formats.Allows input to include trailing spaces not specified by formats. Elles sont ignorées lors de l’analyse de la chaîne.These are ignored when parsing the string.
AllowWhiteSpaces Permet à input d’inclure des espaces de début, de fin et internes non spécifiés par formats.Allows input to include leading, trailing, and inner spaces not specified by formats. Tous les caractères d’espace blanc supplémentaires non spécifiés dans l’élément correspondant dans formats sont ignorés lors de l’analyse de la chaîne.All extra white-space characters not specified in the matched element in formats are ignored when parsing the string.
None Indique que des espaces blancs supplémentaires ne sont pas autorisés dans input.Indicates that additional white space is not permitted in input. L’espace blanc doit apparaître exactement comme spécifié dans un élément particulier de formats pour qu’une correspondance se produise.White space must appear exactly as specified in a particular element of formats for a match to occur. Il s'agit du comportement par défaut.This is the default behavior.
RoundtripKind N’a aucun effet, car la structure DateTimeOffset n’inclut pas de propriété Kind.Has no effect because the DateTimeOffset structure does not include a Kind property.

S’applique à