DateTimeOffset.TryParseExact Méthode
Définition
Important
Certaines informations portent sur la préversion du produit qui est susceptible d’être en grande partie modifiée avant sa publication. Microsoft exclut toute garantie, expresse ou implicite, concernant les informations fournies ici.
Convertit la représentation sous forme de chaîne spécifiée d’une date et d’une heure en son équivalent DateTimeOffset. Le format de la représentation sous forme de chaîne doit correspondre exactement à un format spécifié.
Surcharges
TryParseExact(String, String[], IFormatProvider, DateTimeStyles, DateTimeOffset) |
Convertit la représentation sous forme de chaîne spécifiée d’une date et d’une heure en son DateTimeOffset équivalent à l’aide du tableau de formats, des informations de format spécifiques à la culture et du style spécifiés. Le format de la représentation sous forme de chaîne doit correspondre exactement à l’un des formats spécifiés. |
TryParseExact(ReadOnlySpan<Char>, ReadOnlySpan<Char>, IFormatProvider, DateTimeStyles, DateTimeOffset) |
Convertit la représentation d’une date et d’une heure dans une étendue de caractères en son équivalent DateTimeOffset à l’aide des informations de format spécifiques à la culture et au format spécifiés. Le format de la représentation de date et d’heure doit correspondre exactement au format spécifié. |
TryParseExact(ReadOnlySpan<Char>, String[], IFormatProvider, DateTimeStyles, DateTimeOffset) |
Convertit la représentation d’une date et d’une heure dans une étendue de caractères en son équivalent DateTimeOffset à l’aide des formats spécifiés, des informations de format propres à la culture et du style. Le format de la représentation de date et d’heure doit correspondre exactement à l’un des formats spécifiés. |
TryParseExact(String, String, IFormatProvider, DateTimeStyles, DateTimeOffset) |
Convertit la représentation sous forme de chaîne spécifiée d’une date et d’une heure en son DateTimeOffset équivalent à l’aide du format spécifié, des informations de format propres à la culture et du style. Le format de la représentation sous forme de chaîne doit correspondre exactement au format spécifié. |
TryParseExact(String, String[], IFormatProvider, DateTimeStyles, DateTimeOffset)
- Source:
- DateTimeOffset.cs
- Source:
- DateTimeOffset.cs
- Source:
- DateTimeOffset.cs
Convertit la représentation sous forme de chaîne spécifiée d’une date et d’une heure en son DateTimeOffset équivalent à l’aide du tableau de formats, des informations de format spécifiques à la culture et du style spécifiés. Le format de la représentation sous forme de chaîne doit correspondre exactement à l’un des formats spécifiés.
public:
static bool TryParseExact(System::String ^ input, cli::array <System::String ^> ^ formats, IFormatProvider ^ formatProvider, System::Globalization::DateTimeStyles styles, [Runtime::InteropServices::Out] DateTimeOffset % result);
public static bool TryParseExact (string input, string[] formats, IFormatProvider formatProvider, System.Globalization.DateTimeStyles styles, out DateTimeOffset result);
public static bool TryParseExact (string? input, string?[]? formats, IFormatProvider? formatProvider, System.Globalization.DateTimeStyles styles, out DateTimeOffset result);
static member TryParseExact : string * string[] * IFormatProvider * System.Globalization.DateTimeStyles * DateTimeOffset -> bool
Public Shared Function TryParseExact (input As String, formats As String(), formatProvider As IFormatProvider, styles As DateTimeStyles, ByRef result As DateTimeOffset) As Boolean
Paramètres
- input
- String
Chaîne qui contient une date et une heure à convertir.
- formats
- String[]
Tableau qui définit les formats attendus de input
.
- formatProvider
- IFormatProvider
Objet qui fournit des informations de mise en forme spécifiques à la culture sur input
.
- styles
- DateTimeStyles
Combinaison de valeurs d’énumération au niveau du bit qui indique le format autorisé d’entrée. Une valeur classique à spécifier est None
.
- result
- DateTimeOffset
Lorsque la méthode est retournée, contient le DateTimeOffset équivalent à la date et à l’heure de input
, si la conversion a réussi ou DateTimeOffset.MinValue, si la conversion a échoué. La conversion échoue si l'input
ne contient pas de représentation sous forme de chaîne valide d’une date et d’une heure, ou ne contient pas la date et l’heure dans le format attendu défini par formats
, ou si formats
est null
. Ce paramètre est passé non initialisé.
Retours
true
si le paramètre input
est correctement converti ; sinon, false
.
Exceptions
styles
inclut une valeur DateTimeStyles non définie.
-ou-
NoCurrentDateDefault n’est pas pris en charge.
-ou-
styles
inclut des valeurs de DateTimeStyles mutuellement exclusives.
Exemples
L’exemple suivant définit plusieurs formats d’entrée pour la représentation sous forme de chaîne d’une valeur de date et d’heure et de décalage, puis transmet la chaîne entrée par l’utilisateur à la méthode TryParseExact(String, String[], IFormatProvider, DateTimeStyles, DateTimeOffset).
TextReader conIn = Console.In;
TextWriter conOut = Console.Out;
int tries = 0;
string input = String.Empty;
string[] formats = new string[] {"M/dd/yyyy HH:m zzz", "MM/dd/yyyy HH:m zzz",
"M/d/yyyy HH:m zzz", "MM/d/yyyy HH:m zzz",
"M/dd/yy HH:m zzz", "MM/dd/yy HH:m zzz",
"M/d/yy HH:m zzz", "MM/d/yy HH:m zzz",
"M/dd/yyyy H:m zzz", "MM/dd/yyyy H:m zzz",
"M/d/yyyy H:m zzz", "MM/d/yyyy H:m zzz",
"M/dd/yy H:m zzz", "MM/dd/yy H:m zzz",
"M/d/yy H:m zzz", "MM/d/yy H:m zzz",
"M/dd/yyyy HH:mm zzz", "MM/dd/yyyy HH:mm zzz",
"M/d/yyyy HH:mm zzz", "MM/d/yyyy HH:mm zzz",
"M/dd/yy HH:mm zzz", "MM/dd/yy HH:mm zzz",
"M/d/yy HH:mm zzz", "MM/d/yy HH:mm zzz",
"M/dd/yyyy H:mm zzz", "MM/dd/yyyy H:mm zzz",
"M/d/yyyy H:mm zzz", "MM/d/yyyy H:mm zzz",
"M/dd/yy H:mm zzz", "MM/dd/yy H:mm zzz",
"M/d/yy H:mm zzz", "MM/d/yy H:mm zzz"};
IFormatProvider provider = CultureInfo.InvariantCulture.DateTimeFormat;
DateTimeOffset result;
do {
conOut.WriteLine("Enter a date, time, and offset (MM/DD/YYYY HH:MM +/-HH:MM),");
conOut.Write("Then press Enter: ");
input = conIn.ReadLine();
conOut.WriteLine();
if (DateTimeOffset.TryParseExact(input, formats, provider,
DateTimeStyles.AllowWhiteSpaces,
out result))
{
break;
}
else
{
Console.WriteLine("Unable to parse {0}.", input);
tries++;
}
} while (tries < 3);
if (tries >= 3)
Console.WriteLine("Exiting application without parsing {0}", input);
else
Console.WriteLine("{0} was converted to {1}", input, result.ToString());
// Some successful sample interactions with the user might appear as follows:
// Enter a date, time, and offset (MM/DD/YYYY HH:MM +/-HH:MM),
// Then press Enter: 12/08/2007 6:54 -6:00
//
// 12/08/2007 6:54 -6:00 was converted to 12/8/2007 6:54:00 AM -06:00
//
// Enter a date, time, and offset (MM/DD/YYYY HH:MM +/-HH:MM),
// Then press Enter: 12/8/2007 06:54 -06:00
//
// 12/8/2007 06:54 -06:00 was converted to 12/8/2007 6:54:00 AM -06:00
//
// Enter a date, time, and offset (MM/DD/YYYY HH:MM +/-HH:MM),
// Then press Enter: 12/5/07 6:54 -6:00
//
// 12/5/07 6:54 -6:00 was converted to 12/5/2007 6:54:00 AM -06:00
let mutable result = None
let mutable tries = 0
let mutable input = ""
let formats =
[| "M/dd/yyyy HH:m zzz"; "MM/dd/yyyy HH:m zzz"
"M/d/yyyy HH:m zzz"; "MM/d/yyyy HH:m zzz"
"M/dd/yy HH:m zzz"; "MM/dd/yy HH:m zzz"
"M/d/yy HH:m zzz"; "MM/d/yy HH:m zzz"
"M/dd/yyyy H:m zzz"; "MM/dd/yyyy H:m zzz"
"M/d/yyyy H:m zzz"; "MM/d/yyyy H:m zzz"
"M/dd/yy H:m zzz"; "MM/dd/yy H:m zzz"
"M/d/yy H:m zzz"; "MM/d/yy H:m zzz"
"M/dd/yyyy HH:mm zzz"; "MM/dd/yyyy HH:mm zzz"
"M/d/yyyy HH:mm zzz"; "MM/d/yyyy HH:mm zzz"
"M/dd/yy HH:mm zzz"; "MM/dd/yy HH:mm zzz"
"M/d/yy HH:mm zzz"; "MM/d/yy HH:mm zzz"
"M/dd/yyyy H:mm zzz"; "MM/dd/yyyy H:mm zzz"
"M/d/yyyy H:mm zzz"; "MM/d/yyyy H:mm zzz"
"M/dd/yy H:mm zzz"; "MM/dd/yy H:mm zzz"
"M/d/yy H:mm zzz"; "MM/d/yy H:mm zzz" |]
let provider = CultureInfo.InvariantCulture.DateTimeFormat
while tries < 3 && result.IsNone do
printfn "Enter a date, time, and offset (MM/DD/YYYY HH:MM +/-HH:MM),"
printf "Then press Enter: "
input <- stdin.ReadLine()
printfn ""
match DateTimeOffset.TryParseExact(input, formats, provider, DateTimeStyles.AllowWhiteSpaces) with
| true, dto ->
result <- Some dto
| _ ->
printfn $"Unable to parse {input}."
tries <- tries + 1
match result with
| Some result ->
printfn $"{input} was converted to {result}"
| None ->
printfn $"Exiting application without parsing {input}"
// Some successful sample interactions with the user might appear as follows:
// Enter a date, time, and offset (MM/DD/YYYY HH:MM +/-HH:MM),
// Then press Enter: 12/08/2007 6:54 -6:00
//
// 12/08/2007 6:54 -6:00 was converted to 12/8/2007 6:54:00 AM -06:00
//
// Enter a date, time, and offset (MM/DD/YYYY HH:MM +/-HH:MM),
// Then press Enter: 12/8/2007 06:54 -06:00
//
// 12/8/2007 06:54 -06:00 was converted to 12/8/2007 6:54:00 AM -06:00
//
// Enter a date, time, and offset (MM/DD/YYYY HH:MM +/-HH:MM),
// Then press Enter: 12/5/07 6:54 -6:00
//
// 12/5/07 6:54 -6:00 was converted to 12/5/2007 6:54:00 AM -06:00
Dim conIn As TextReader = Console.In
Dim conOut As TextWriter = Console.Out
Dim tries As Integer = 0
Dim input As String = String.Empty
Dim formats() As String = {"M/dd/yyyy HH:m zzz", "MM/dd/yyyy HH:m zzz", _
"M/d/yyyy HH:m zzz", "MM/d/yyyy HH:m zzz", _
"M/dd/yy HH:m zzz", "MM/dd/yy HH:m zzz", _
"M/d/yy HH:m zzz", "MM/d/yy HH:m zzz", _
"M/dd/yyyy H:m zzz", "MM/dd/yyyy H:m zzz", _
"M/d/yyyy H:m zzz", "MM/d/yyyy H:m zzz", _
"M/dd/yy H:m zzz", "MM/dd/yy H:m zzz", _
"M/d/yy H:m zzz", "MM/d/yy H:m zzz", _
"M/dd/yyyy HH:mm zzz", "MM/dd/yyyy HH:mm zzz", _
"M/d/yyyy HH:mm zzz", "MM/d/yyyy HH:mm zzz", _
"M/dd/yy HH:mm zzz", "MM/dd/yy HH:mm zzz", _
"M/d/yy HH:mm zzz", "MM/d/yy HH:mm zzz", _
"M/dd/yyyy H:mm zzz", "MM/dd/yyyy H:mm zzz", _
"M/d/yyyy H:mm zzz", "MM/d/yyyy H:mm zzz", _
"M/dd/yy H:mm zzz", "MM/dd/yy H:mm zzz", _
"M/d/yy H:mm zzz", "MM/d/yy H:mm zzz"}
Dim provider As IFormatProvider = CultureInfo.InvariantCulture.DateTimeFormat
Dim result As DateTimeOffset
Do
conOut.WriteLine("Enter a date, time, and offset (MM/DD/YYYY HH:MM +/-HH:MM),")
conOut.Write("Then press Enter: ")
input = conIn.ReadLine()
conOut.WriteLine()
If DateTimeOffset.TryParseExact(input, formats, provider, _
DateTimeStyles.AllowWhiteSpaces, _
result) Then
Exit Do
Else
Console.WriteLine("Unable to parse {0}.", input)
tries += 1
End If
Loop While tries < 3
If tries >= 3 Then
Console.WriteLine("Exiting application without parsing {0}", input)
Else
Console.WriteLine("{0} was converted to {1}", input, result.ToString())
End If
' Some successful sample interactions with the user might appear as follows:
' Enter a date, time, and offset (MM/DD/YYYY HH:MM +/-HH:MM),
' Then press Enter: 12/08/2007 6:54 -6:00
'
' 12/08/2007 6:54 -6:00 was converted to 12/8/2007 6:54:00 AM -06:00
'
' Enter a date, time, and offset (MM/DD/YYYY HH:MM +/-HH:MM),
' Then press Enter: 12/8/2007 06:54 -06:00
'
' 12/8/2007 06:54 -06:00 was converted to 12/8/2007 6:54:00 AM -06:00
'
' Enter a date, time, and offset (MM/DD/YYYY HH:MM +/-HH:MM),
' Then press Enter: 12/5/07 6:54 -6:00
'
' 12/5/07 6:54 -6:00 was converted to 12/5/2007 6:54:00 AM -06:00
Remarques
La méthode TryParseExact(String, String[], IFormatProvider, DateTimeStyles, DateTimeOffset) analyse la représentation sous forme de chaîne d’une date qui correspond à l’un des modèles attribués au tableau formats
. Si la chaîne input
ne correspond à aucun de ces modèles avec des variantes définies par le paramètre styles
, l’opération d’analyse échoue et la méthode retourne false
. En plus de comparer input
à plusieurs chaînes qui contiennent des spécificateurs de format, cette surcharge se comporte de la même façon que la méthode DateTimeOffset.ParseExact(String, String[], IFormatProvider, DateTimeStyles).
Le paramètre formats
est un tableau de chaînes dont les éléments contiennent un spécificateur de format standard unique ou un ou plusieurs spécificateurs de format personnalisés qui définissent le modèle possible de input
. Pour plus d’informations sur les codes de mise en forme valides, consultez chaînes de format de date et d’heure standard et chaînes de format de date et d’heure personnalisées. Si l’élément mis en correspondance dans formats
inclut l'z
, zz
ou zzz
spécificateurs de format personnalisé pour indiquer qu’un décalage doit être présent dans input
, ce décalage doit inclure un signe négatif ou un signe positif. Si le signe est manquant, l’opération d’analyse échoue et la méthode retourne false
.
Important
L’utilisation du paramètre formats
de cette surcharge pour spécifier plusieurs formats peut contribuer à réduire la frustration de nombreux utilisateurs lorsqu’ils entrent des dates et des heures. En particulier, la possibilité de définir plusieurs modèles d’entrée permet à une application de gérer les représentations de date et d’heure qui peuvent inclure ou manquer de zéros non significatifs en mois, jours, heures, minutes et secondes. L’exemple fournit une illustration de ceci.
Si l’élément mis en correspondance dans formats
nécessite que input
contiennent une date, mais pas une heure, l’objet DateTimeOffset résultant est affecté à l’heure de minuit (0:00:00). Si l’élément mis en correspondance dans formats
nécessite que l’entrée contienne une heure, mais pas une date, l’objet DateTimeOffset résultant est affecté à la date actuelle sur le système local. Si l’élément mis en correspondance dans formats
ne nécessite pas que input
contiennent un décalage, le décalage de l’objet DateTimeOffset résultant dépend de la valeur du paramètre styles
. Si styles
inclut AssumeLocal, le décalage du fuseau horaire local est affecté à l’objet DateTimeOffset. Si styles
inclut AssumeUniversal, le décalage UTC (Temps universel coordonné) ou +00:00 est affecté à l’objet DateTimeOffset. Si aucune valeur n’est spécifiée, le décalage du fuseau horaire local est utilisé.
Les symboles et chaînes de date et d’heure spécifiques utilisés dans input
sont définis par le paramètre formatProvider
. Il en va de même pour le modèle précis de input
si l’élément correspondant de formats
est une chaîne de spécificateur de format standard. Le paramètre formatProvider
peut être l’un des éléments suivants :
Objet CultureInfo qui représente la culture en fonction de laquelle
input
est interprété. L’objet DateTimeFormatInfo retourné par la propriété CultureInfo.DateTimeFormat définit les symboles et la mise en forme dansinput
.Objet DateTimeFormatInfo qui définit le format des données de date et d’heure.
Si formatprovider
est null
, l’objet CultureInfo qui correspond à la culture actuelle est utilisé.
Le paramètre styles
définit si l’espace blanc est autorisé dans la chaîne d’entrée, indique comment les chaînes sans composant de décalage explicite sont analysées et prennent en charge la conversion UTC dans le cadre de l’opération d’analyse. Tous les membres de l’énumération DateTimeStyles sont pris en charge, sauf NoCurrentDateDefault. Le tableau suivant répertorie l’effet de chaque membre pris en charge.
membre DateTimeStyles |
Comportement |
---|---|
AdjustToUniversal | Analyse input et, si nécessaire, la convertit en UTC. Il équivaut à analyser une chaîne, puis à appeler la méthode DateTimeOffset.ToUniversalTime de l’objet DateTimeOffset retourné. |
AssumeLocal | Si l’élément mis en correspondance dans formats ne nécessite pas que input contiennent une valeur de décalage, l’objet DateTimeOffset retourné reçoit le décalage du fuseau horaire local. Il s’agit de la valeur par défaut. |
AssumeUniversal | Si l’élément mis en correspondance dans formats ne nécessite pas que input contiennent une valeur de décalage, l’objet DateTimeOffset retourné reçoit le décalage UTC (+00:00). |
AllowInnerWhite | Permet input d’inclure un espace blanc interne non spécifié par les éléments dans formats . Un espace blanc supplémentaire peut apparaître entre les composants de date et d’heure et dans des composants individuels (à l’exception du décalage) et est ignoré lors de l’analyse de la chaîne. |
AllowLeadingWhite | Permet input d’inclure des espaces de début non spécifiés par les éléments dans formats . Elles sont ignorées lors de l’analyse de la chaîne. |
AllowTrailingWhite | Permet input d’inclure des espaces de fin non spécifiés par les éléments dans formats . Elles sont ignorées lors de l’analyse de la chaîne. |
AllowWhiteSpaces | Permet input d’inclure des espaces de début, de fin et d’intérieur non spécifiés par les éléments dans formats . Tous les espaces blancs supplémentaires non spécifiés dans l’élément correspondant dans formats sont ignorés lors de l’analyse de la chaîne. |
None | Indique que l’espace blanc supplémentaire n’est pas autorisé dans input . L’espace blanc doit apparaître exactement comme spécifié dans un élément particulier dans formats pour qu’une correspondance réussie se produise. Il s’agit du comportement par défaut. |
RoundtripKind | N’a aucun effet, car la structure DateTimeOffset n’inclut pas de propriété Kind . |
Notes pour les appelants
Dans .NET Framework 4, le TryParseExact retourne false
si la chaîne à analyser contient un composant d’heure et un indicateur AM/PM qui ne sont pas en accord. Dans .NET Framework 3.5 et versions antérieures, l’indicateur AM/PM est ignoré.
S’applique à
TryParseExact(ReadOnlySpan<Char>, ReadOnlySpan<Char>, IFormatProvider, DateTimeStyles, DateTimeOffset)
- Source:
- DateTimeOffset.cs
- Source:
- DateTimeOffset.cs
- Source:
- DateTimeOffset.cs
Convertit la représentation d’une date et d’une heure dans une étendue de caractères en son équivalent DateTimeOffset à l’aide des informations de format spécifiques à la culture et au format spécifiés. Le format de la représentation de date et d’heure doit correspondre exactement au format spécifié.
public:
static bool TryParseExact(ReadOnlySpan<char> input, ReadOnlySpan<char> format, IFormatProvider ^ formatProvider, System::Globalization::DateTimeStyles styles, [Runtime::InteropServices::Out] DateTimeOffset % result);
public static bool TryParseExact (ReadOnlySpan<char> input, ReadOnlySpan<char> format, IFormatProvider? formatProvider, System.Globalization.DateTimeStyles styles, out DateTimeOffset result);
public static bool TryParseExact (ReadOnlySpan<char> input, ReadOnlySpan<char> format, IFormatProvider formatProvider, System.Globalization.DateTimeStyles styles, out DateTimeOffset result);
static member TryParseExact : ReadOnlySpan<char> * ReadOnlySpan<char> * IFormatProvider * System.Globalization.DateTimeStyles * DateTimeOffset -> bool
Public Shared Function TryParseExact (input As ReadOnlySpan(Of Char), format As ReadOnlySpan(Of Char), formatProvider As IFormatProvider, styles As DateTimeStyles, ByRef result As DateTimeOffset) As Boolean
Paramètres
- input
- ReadOnlySpan<Char>
Étendue contenant les caractères qui représentent une date et une heure à convertir.
- format
- ReadOnlySpan<Char>
Spécificateur de format qui définit le format requis de input
.
- formatProvider
- IFormatProvider
Objet qui fournit des informations de mise en forme spécifiques à la culture sur input
.
- styles
- DateTimeStyles
Combinaison de valeurs d’énumération au niveau du bit qui indique le format autorisé de input
. Une valeur classique à spécifier est None.
- result
- DateTimeOffset
Lorsque la méthode est retournée, contient le DateTimeOffset équivalent à la date et à l’heure de input
, si la conversion a réussi ou DateTimeOffset.MinValue si la conversion a échoué. La conversion échoue si la
Retours
true
si le paramètre input
est correctement converti ; sinon, false
.
Exceptions
styles
inclut une valeur DateTimeStyles non définie.
-ou- NoCurrentDateDefault n’est pas pris en charge.
-ou- styles
inclut des valeurs d'DateTimeStyles mutuellement exclusives.
Remarques
Cette surcharge est semblable à la méthode DateTimeOffset.ParseExact(ReadOnlySpan<Char>, ReadOnlySpan<Char>, IFormatProvider, DateTimeStyles), sauf que cette méthode ne lève pas d’exception si la conversion échoue. Il analyse la représentation d’une date et d’une heure qui doivent correspondre exactement au modèle spécifié par le paramètre format
. Si input
ne correspond pas à ce modèle, avec certaines variations possibles de l’espace blanc défini par le paramètre styles
, l’opération d’analyse échoue et la méthode retourne false
.
Le paramètre format
est une étendue de caractères qui contient un spécificateur de format standard unique ou un ou plusieurs spécificateurs de format personnalisés qui définissent le modèle requis de input
. Pour plus d’informations sur les codes de mise en forme valides, consultez chaînes de format de date et d’heure standard et chaînes de format de date et d’heure personnalisées. Si format
inclut le z
, zz
ou zzz
spécificateurs de format personnalisé pour indiquer qu’un décalage doit être présent dans input
, ce décalage doit inclure un signe négatif ou un signe positif. Si le signe est manquant, l’opération d’analyse échoue et la méthode retourne false
.
Si format
exige que input
contiennent une date, mais pas une heure, l’objet DateTimeOffset résultant est affecté à l’heure de minuit (0:00:00). Si format
exige que input
contiennent une heure, mais pas une date, l’objet DateTimeOffset résultant est affecté à la date actuelle sur le système local. Si format
ne nécessite pas que input
contiennent un décalage, le décalage de l’objet DateTimeOffset résultant dépend de la valeur du paramètre styles
. Si styles
inclut AssumeLocal, le décalage du fuseau horaire local est affecté à l’objet DateTimeOffset. Si styles
inclut AssumeUniversal, le décalage UTC (Temps universel coordonné) ou +00:00 est affecté à l’objet DateTimeOffset. Si aucune valeur n’est spécifiée, le décalage du fuseau horaire local est utilisé.
Les symboles et chaînes de date et d’heure spécifiques utilisés dans input
sont définis par le paramètre formatProvider
. Il en va de même pour le modèle précis de input
si format
est une chaîne de spécificateur de format standard. Le paramètre formatProvider
peut être l’un des éléments suivants :
Objet CultureInfo qui représente la culture en fonction de laquelle
input
est interprété. L’objet DateTimeFormatInfo retourné par la propriété CultureInfo.DateTimeFormat définit les symboles et les formats standard autorisés dansinput
.Objet DateTimeFormatInfo qui définit le format des données de date et d’heure.
Si formatprovider
est null
, l’objet CultureInfo qui correspond à la culture actuelle est utilisé.
Le paramètre styles
définit si l’espace blanc est autorisé dans la chaîne d’entrée, indique comment les chaînes sans composant de décalage explicite sont analysées et prend en charge la conversion UTC dans le cadre de l’opération d’analyse. Tous les membres de l’énumération DateTimeStyles sont pris en charge, sauf NoCurrentDateDefault. Le tableau suivant répertorie l’effet de chaque membre pris en charge.
membre DateTimeStyles |
Comportement |
---|---|
AdjustToUniversal | Analyse input et, si nécessaire, la convertit en UTC. Elle équivaut à analyser une représentation de date et d’heure, puis à appeler la méthode DateTimeOffset.ToUniversalTime de l’objet DateTimeOffset retourné. |
AssumeLocal | Si format ne nécessite pas que input contiennent une valeur de décalage, l’objet DateTimeOffset retourné reçoit le décalage du fuseau horaire local. Il s’agit du comportement par défaut. |
AssumeUniversal | Si format ne nécessite pas que input contiennent une valeur de décalage, l’objet DateTimeOffset retourné reçoit le décalage UTC (+00:00). |
AllowInnerWhite | Permet input d’inclure un espace blanc interne non spécifié par format. Un espace blanc supplémentaire peut apparaître entre les composants de date et d’heure et dans des composants individuels, autres que le décalage, et est ignoré lors de l’analyse de la chaîne. |
AllowLeadingWhite | Permet input d’inclure des espaces de début non spécifiés par format . Elles sont ignorées lors de l’analyse de la chaîne. |
AllowTrailingWhite | Permet input d’inclure des espaces de fin non spécifiés par format . Elles sont ignorées lors de l’analyse de la chaîne. |
AllowWhiteSpaces | Permet input d’inclure des espaces de début, de fin et d’intérieur non spécifiés par format . Tous les espaces blancs supplémentaires non spécifiés dans format sont ignorés lors de l’analyse de la chaîne. |
None | Indique que l’espace blanc supplémentaire n’est pas autorisé dans input . L’espace blanc doit apparaître exactement comme spécifié dans format . Il s’agit du comportement par défaut. |
RoundtripKind | N’a aucun effet, car la structure DateTimeOffset n’inclut pas de propriété Kind . |
S’applique à
TryParseExact(ReadOnlySpan<Char>, String[], IFormatProvider, DateTimeStyles, DateTimeOffset)
- Source:
- DateTimeOffset.cs
- Source:
- DateTimeOffset.cs
- Source:
- DateTimeOffset.cs
Convertit la représentation d’une date et d’une heure dans une étendue de caractères en son équivalent DateTimeOffset à l’aide des formats spécifiés, des informations de format propres à la culture et du style. Le format de la représentation de date et d’heure doit correspondre exactement à l’un des formats spécifiés.
public:
static bool TryParseExact(ReadOnlySpan<char> input, cli::array <System::String ^> ^ formats, IFormatProvider ^ formatProvider, System::Globalization::DateTimeStyles styles, [Runtime::InteropServices::Out] DateTimeOffset % result);
public static bool TryParseExact (ReadOnlySpan<char> input, string?[]? formats, IFormatProvider? formatProvider, System.Globalization.DateTimeStyles styles, out DateTimeOffset result);
public static bool TryParseExact (ReadOnlySpan<char> input, string[] formats, IFormatProvider formatProvider, System.Globalization.DateTimeStyles styles, out DateTimeOffset result);
static member TryParseExact : ReadOnlySpan<char> * string[] * IFormatProvider * System.Globalization.DateTimeStyles * DateTimeOffset -> bool
Public Shared Function TryParseExact (input As ReadOnlySpan(Of Char), formats As String(), formatProvider As IFormatProvider, styles As DateTimeStyles, ByRef result As DateTimeOffset) As Boolean
Paramètres
- input
- ReadOnlySpan<Char>
Étendue contenant les caractères qui représentent une date et une heure à convertir.
- formats
- String[]
Tableau de chaînes de format standard ou personnalisées qui définissent les formats acceptables de input
.
- formatProvider
- IFormatProvider
Objet qui fournit des informations de mise en forme spécifiques à la culture sur input
.
- styles
- DateTimeStyles
Combinaison de valeurs d’énumération au niveau du bit qui indique le format autorisé de input
. Une valeur classique à spécifier est None.
- result
- DateTimeOffset
Lorsque la méthode est retournée, contient le DateTimeOffset équivalent à la date et à l’heure de input
, si la conversion a réussi ou DateTimeOffset.MinValue si la conversion a échoué. La conversion échoue si la
Retours
true
si le paramètre input
est correctement converti ; sinon, false
.
Exceptions
styles
inclut une valeur DateTimeStyles non définie.
-ou- NoCurrentDateDefault n’est pas pris en charge.
-ou- styles
inclut des valeurs d'DateTimeStyles mutuellement exclusives.
Remarques
Cette méthode analyse la représentation sous forme de chaîne d’une date qui correspond à l’un des modèles attribués au tableau formats
. Si input
ne correspond pas à l’un de ces modèles avec des variantes définies par le paramètre styles
, l’opération d’analyse échoue et la méthode retourne false
. En plus de comparer input
à plusieurs chaînes qui contiennent des spécificateurs de format, cette surcharge se comporte de la même façon que la méthode DateTimeOffset.ParseExact(ReadOnlySpan<Char>, String[], IFormatProvider, DateTimeStyles).
Le paramètre formats
est un tableau de chaînes dont les éléments contiennent un spécificateur de format standard unique ou un ou plusieurs spécificateurs de format personnalisés qui définissent le modèle possible de input
. Pour plus d’informations sur les codes de mise en forme valides, consultez chaînes de format de date et d’heure standard et chaînes de format de date et d’heure personnalisées. Si l’élément mis en correspondance dans formats
inclut l'z
, zz
ou zzz
spécificateurs de format personnalisé pour indiquer qu’un décalage doit être présent dans input
, ce décalage doit inclure un signe négatif ou un signe positif. Si le signe est manquant, l’opération d’analyse échoue et la méthode retourne false
.
Important
L’utilisation du paramètre formats
de cette surcharge pour spécifier plusieurs formats peut contribuer à réduire la frustration de nombreux utilisateurs lorsqu’ils entrent des dates et des heures. En particulier, la possibilité de définir plusieurs modèles d’entrée permet à une application de gérer les représentations de date et d’heure qui peuvent inclure ou manquer de zéros non significatifs en mois, jours, heures, minutes et secondes. L’exemple fournit une illustration de ceci.
Si l’élément mis en correspondance dans formats
nécessite que input
contiennent une date, mais pas une heure, l’objet DateTimeOffset résultant est affecté à l’heure de minuit (0:00:00). Si l’élément mis en correspondance dans formats
nécessite que l’entrée contienne une heure, mais pas une date, l’objet DateTimeOffset résultant est affecté à la date actuelle sur le système local. Si l’élément mis en correspondance dans formats
ne nécessite pas que input
contiennent un décalage, le décalage de l’objet DateTimeOffset résultant dépend de la valeur du paramètre styles
. Si styles
inclut DateTimeStyles.AssumeLocal, le décalage du fuseau horaire local est affecté à l’objet DateTimeOffset. Si styles
inclut DateTimeStyles.AssumeUniversal, le décalage UTC (Temps universel coordonné) ou +00:00 est affecté à l’objet DateTimeOffset. Si aucune valeur n’est spécifiée, le décalage du fuseau horaire local est utilisé.
Les symboles de date et d’heure particuliers utilisés dans input
sont définis par le paramètre formatProvider
. Il en va de même pour le modèle précis de input
si l’élément correspondant de formats
est une chaîne de spécificateur de format standard. Le paramètre formatProvider
peut être l’un des éléments suivants :
Objet CultureInfo qui représente la culture en fonction de laquelle
input
est interprété. L’objet DateTimeFormatInfo retourné par la propriété CultureInfo.DateTimeFormat définit les symboles et la mise en forme dansinput
.Objet DateTimeFormatInfo qui définit le format des données de date et d’heure.
Si formatprovider
est null
, l’objet CultureInfo qui correspond à la culture actuelle est utilisé.
Le paramètre styles
définit si l’espace blanc est autorisé dans la chaîne d’entrée, indique comment les chaînes sans composant de décalage explicite sont analysées et prennent en charge la conversion UTC dans le cadre de l’opération d’analyse. Tous les membres de l’énumération DateTimeStyles sont pris en charge, sauf NoCurrentDateDefault. Le tableau suivant répertorie l’effet de chaque membre pris en charge.
membre DateTimeStyles |
Comportement |
---|---|
AdjustToUniversal | Analyse input et, si nécessaire, la convertit en UTC. Il équivaut à analyser une chaîne, puis à appeler la méthode DateTimeOffset.ToUniversalTime de l’objet DateTimeOffset retourné. |
AssumeLocal | Si l’élément mis en correspondance dans formats ne nécessite pas que input contiennent une valeur de décalage, l’objet DateTimeOffset retourné reçoit le décalage du fuseau horaire local. Il s’agit de la valeur par défaut. |
AssumeUniversal | Si l’élément mis en correspondance dans formats ne nécessite pas que input contiennent une valeur de décalage, l’objet DateTimeOffset retourné reçoit le décalage UTC (+00:00). |
AllowInnerWhite | Permet input d’inclure un espace blanc interne non spécifié par les éléments dans formats . Un espace blanc supplémentaire peut apparaître entre les composants de date et d’heure et dans des composants individuels (à l’exception du décalage) et est ignoré lors de l’analyse de la chaîne. |
AllowLeadingWhite | Permet input d’inclure des espaces de début non spécifiés par les éléments dans formats . Elles sont ignorées lors de l’analyse de la chaîne. |
AllowTrailingWhite | Permet input d’inclure des espaces de fin non spécifiés par les éléments dans formats . Elles sont ignorées lors de l’analyse de la chaîne. |
AllowWhiteSpaces | Permet input d’inclure des espaces de début, de fin et d’intérieur non spécifiés par les éléments dans formats . Tous les espaces blancs supplémentaires non spécifiés dans l’élément correspondant dans formats sont ignorés lors de l’analyse de la chaîne. |
None | Indique que l’espace blanc supplémentaire n’est pas autorisé dans input . L’espace blanc doit apparaître exactement comme spécifié dans un élément particulier dans formats pour qu’une correspondance réussie se produise. Il s’agit du comportement par défaut. |
RoundtripKind | N’a aucun effet, car la structure DateTimeOffset n’inclut pas de propriété Kind . |
S’applique à
TryParseExact(String, String, IFormatProvider, DateTimeStyles, DateTimeOffset)
- Source:
- DateTimeOffset.cs
- Source:
- DateTimeOffset.cs
- Source:
- DateTimeOffset.cs
Convertit la représentation sous forme de chaîne spécifiée d’une date et d’une heure en son DateTimeOffset équivalent à l’aide du format spécifié, des informations de format propres à la culture et du style. Le format de la représentation sous forme de chaîne doit correspondre exactement au format spécifié.
public:
static bool TryParseExact(System::String ^ input, System::String ^ format, IFormatProvider ^ formatProvider, System::Globalization::DateTimeStyles styles, [Runtime::InteropServices::Out] DateTimeOffset % result);
public static bool TryParseExact (string input, string format, IFormatProvider formatProvider, System.Globalization.DateTimeStyles styles, out DateTimeOffset result);
public static bool TryParseExact (string? input, string? format, IFormatProvider? formatProvider, System.Globalization.DateTimeStyles styles, out DateTimeOffset result);
static member TryParseExact : string * string * IFormatProvider * System.Globalization.DateTimeStyles * DateTimeOffset -> bool
Public Shared Function TryParseExact (input As String, format As String, formatProvider As IFormatProvider, styles As DateTimeStyles, ByRef result As DateTimeOffset) As Boolean
Paramètres
- input
- String
Chaîne qui contient une date et une heure à convertir.
- format
- String
Spécificateur de format qui définit le format requis de input
.
- formatProvider
- IFormatProvider
Objet qui fournit des informations de mise en forme spécifiques à la culture sur input
.
- styles
- DateTimeStyles
Combinaison de valeurs d’énumération au niveau du bit qui indique le format autorisé d’entrée. Une valeur classique à spécifier est None
.
- result
- DateTimeOffset
Lorsque la méthode est retournée, contient le DateTimeOffset équivalent à la date et à l’heure de input
, si la conversion a réussi ou DateTimeOffset.MinValue, si la conversion a échoué. La conversion échoue si le paramètre input
est null
ou ne contient pas de représentation sous forme de chaîne valide d’une date et d’une heure au format attendu défini par format
et provider
. Ce paramètre est passé non initialisé.
Retours
true
si le paramètre input
est correctement converti ; sinon, false
.
Exceptions
styles
inclut une valeur DateTimeStyles non définie.
-ou-
NoCurrentDateDefault n’est pas pris en charge.
-ou-
styles
inclut des valeurs de DateTimeStyles mutuellement exclusives.
Exemples
L’exemple suivant utilise la méthode TryParseExact(String, String, IFormatProvider, DateTimeStyles, DateTimeOffset) avec des spécificateurs de format standard et personnalisés, la culture invariante et diverses valeurs de DateTimeStyles pour analyser plusieurs chaînes de date et d’heure.
string dateString, format;
DateTimeOffset result;
IFormatProvider provider = CultureInfo.InvariantCulture;
// Parse date-only value with invariant culture and assume time is UTC.
dateString = "06/15/2008";
format = "d";
if (DateTimeOffset.TryParseExact(dateString, format, provider,
DateTimeStyles.AssumeUniversal,
out result))
Console.WriteLine("'{0}' converts to {1}.", dateString, result.ToString());
else
Console.WriteLine("'{0}' is not in the correct format.", dateString);
// Parse date-only value with leading white space.
// Should return False because only trailing white space is
// specified in method call.
dateString = " 06/15/2008";
if (DateTimeOffset.TryParseExact(dateString, format, provider,
DateTimeStyles.AllowTrailingWhite,
out result))
Console.WriteLine("'{0}' converts to {1}.", dateString, result.ToString());
else
Console.WriteLine("'{0}' is not in the correct format.", dateString);
// Parse date and time value, and allow all white space.
dateString = " 06/15/ 2008 15:15 -05:00";
format = "MM/dd/yyyy H:mm zzz";
if (DateTimeOffset.TryParseExact(dateString, format, provider,
DateTimeStyles.AllowWhiteSpaces,
out result))
Console.WriteLine("'{0}' converts to {1}.", dateString, result.ToString());
else
Console.WriteLine("'{0}' is not in the correct format.", dateString);
// Parse date and time and convert to UTC.
dateString = " 06/15/2008 15:15:30 -05:00";
format = "MM/dd/yyyy H:mm:ss zzz";
if (DateTimeOffset.TryParseExact(dateString, format, provider,
DateTimeStyles.AllowWhiteSpaces |
DateTimeStyles.AdjustToUniversal,
out result))
Console.WriteLine("'{0}' converts to {1}.", dateString, result.ToString());
else
Console.WriteLine("'{0}' is not in the correct format.", dateString);
// The example displays the following output:
// '06/15/2008' converts to 6/15/2008 12:00:00 AM +00:00.
// ' 06/15/2008' is not in the correct format.
// ' 06/15/ 2008 15:15 -05:00' converts to 6/15/2008 3:15:00 PM -05:00.
// ' 06/15/2008 15:15:30 -05:00' converts to 6/15/2008 8:15:30 PM +00:00.
let provider = CultureInfo.InvariantCulture
// Parse date-only value with invariant culture and assume time is UTC.
let dateString = "06/15/2008"
let format = "d"
match DateTimeOffset.TryParseExact(dateString, format, provider, DateTimeStyles.AssumeUniversal) with
| true, result ->
printfn $"'{dateString}' converts to {result}."
| _ ->
printfn $"'{dateString}' is not in the correct format."
// Parse date-only value with leading white space.
// Should return False because only trailing white space is
// specified in method call.
let dateString = " 06/15/2008"
match DateTimeOffset.TryParseExact(dateString, format, provider, DateTimeStyles.AllowTrailingWhite) with
| true, result ->
printfn $"'{dateString}' converts to {result}."
| _ ->
printfn $"'{dateString}' is not in the correct format."
// Parse date and time value, and allow all white space.
let dateString = " 06/15/ 2008 15:15 -05:00"
let format = "MM/dd/yyyy H:mm zzz"
match DateTimeOffset.TryParseExact(dateString, format, provider, DateTimeStyles.AllowWhiteSpaces) with
| true, result ->
printfn $"'{dateString}' converts to {result}."
| _ ->
printfn $"'{dateString}' is not in the correct format."
// Parse date and time and convert to UTC.
let dateString = " 06/15/2008 15:15:30 -05:00"
let format = "MM/dd/yyyy H:mm:ss zzz"
match DateTimeOffset.TryParseExact(dateString, format, provider, DateTimeStyles.AllowWhiteSpaces ||| DateTimeStyles.AdjustToUniversal) with
| true, result ->
printfn $"'{dateString}' converts to {result}."
| _ ->
printfn $"'{dateString}' is not in the correct format."
// The example displays the following output:
// '06/15/2008' converts to 6/15/2008 12:00:00 AM +00:00.
// ' 06/15/2008' is not in the correct format.
// ' 06/15/ 2008 15:15 -05:00' converts to 6/15/2008 3:15:00 PM -05:00.
// ' 06/15/2008 15:15:30 -05:00' converts to 6/15/2008 8:15:30 PM +00:00.
Dim dateString, format As String
Dim result As DateTimeOffset
Dim provider As CultureInfo = CultureInfo.InvariantCulture
' Parse date-only value with invariant culture and assume time is UTC.
dateString = "06/15/2008"
format = "d"
If DateTimeOffset.TryParseExact(dateString, format, provider, _
DateTimeStyles.AssumeUniversal, _
result) Then
Console.WriteLine("'{0}' converts to {1}.", dateString, result.ToString())
Else
Console.WriteLine("'{0}' is not in the correct format.", dateString)
End If
' Parse date-only value with leading white space.
' Should return False because only trailing white space is
' specified in method call.
dateString = " 06/15/2008"
If DateTimeOffset.TryParseExact(dateString, format, provider, _
DateTimeStyles.AllowTrailingWhite, _
result) Then
Console.WriteLine("'{0}' converts to {1}.", dateString, result.ToString())
Else
Console.WriteLine("'{0}' is not in the correct format.", dateString)
End If
' Parse date and time value, and allow all white space.
dateString = " 06/15/ 2008 15:15 -05:00"
format = "MM/dd/yyyy H:mm zzz"
If DateTimeOffset.TryParseExact(dateString, format, provider, _
DateTimeStyles.AllowWhiteSpaces, _
result) Then
Console.WriteLine("'{0}' converts to {1}.", dateString, result.ToString())
Else
Console.WriteLine("'{0}' is not in the correct format.", dateString)
End If
' Parse date and time and convert to UTC.
dateString = " 06/15/2008 15:15:30 -05:00"
format = "MM/dd/yyyy H:mm:ss zzz"
If DateTimeOffset.TryParseExact(dateString, format, provider, _
DateTimeStyles.AllowWhiteSpaces Or _
DateTimeStyles.AdjustToUniversal, _
result) Then
Console.WriteLine("'{0}' converts to {1}.", dateString, result.ToString())
Else
Console.WriteLine("'{0}' is not in the correct format.", dateString)
End If
' The example displays the following output:
' '06/15/2008' converts to 6/15/2008 12:00:00 AM +00:00.
' ' 06/15/2008' is not in the correct format.
' ' 06/15/ 2008 15:15 -05:00' converts to 6/15/2008 3:15:00 PM -05:00.
' ' 06/15/2008 15:15:30 -05:00' converts to 6/15/2008 8:15:30 PM +00:00.
L’exemple suivant utilise une variété de valeurs DateTimeStyles pour analyser un tableau de chaînes qui sont censées être conformes à ISO 8601. Comme le montre la sortie de l’exemple, les chaînes au format approprié ne parviennent pas à analyser si :
ils contiennent un espace blanc et un indicateur de DateTimeStyles approprié (par exemple, DateTimeStyles.AllowWhiteSpaces n’a pas été fourni dans l’appel de méthode.
ils contiennent des éléments de date et d’heure hors limites.
Les chaînes qui ne spécifient pas de décalage UTC sont supposées avoir le décalage du fuseau horaire local (dans ce cas, -07:00, qui reflète le décalage du fuseau horaire d’été du Pacifique), sauf si l’indicateur DateTimeStyles.AssumeUniversal est fourni dans l’appel de méthode. Dans ce cas, elles sont supposées être un temps coordonné universel.
open System
open System.Globalization
let parseWithISO8601 dateStrings styles =
printfn $"Parsing with {styles}:"
for dateString in dateStrings do
match DateTimeOffset.TryParseExact(dateString, "O", null, styles) with
| true, date ->
printfn $""" {dateString,-35} --> {date.ToString "yyyy-MM-dd HH:mm:ss.FF zzz"}"""
| _ ->
printfn $" Unable to convert '{dateString}'"
let dateStrings =
[ "2018-08-18T12:45:16.0000000Z"
"2018/08/18T12:45:16.0000000Z"
"2018-18-08T12:45:16.0000000Z"
"2018-08-18T12:45:16.0000000"
" 2018-08-18T12:45:16.0000000Z "
"2018-08-18T12:45:16.0000000+02:00"
"2018-08-18T12:45:16.0000000-07:00" ]
parseWithISO8601 dateStrings DateTimeStyles.None
printfn "\n-----\n"
parseWithISO8601 dateStrings DateTimeStyles.AllowWhiteSpaces
printfn "\n-----\n"
parseWithISO8601 dateStrings DateTimeStyles.AdjustToUniversal
printfn "\n-----\n"
parseWithISO8601 dateStrings DateTimeStyles.AssumeLocal
printfn "\n-----\n"
parseWithISO8601 dateStrings DateTimeStyles.AssumeUniversal
// The example displays the following output:
// Parsing with None:
// 2018-08-18T12:45:16.0000000Z --> 2018-08-18 12:45:16 +00:00
// Unable to convert '2018/08/18T12:45:16.0000000Z'
// Unable to convert '2018-18-08T12:45:16.0000000Z'
// 2018-08-18T12:45:16.0000000 --> 2018-08-18 12:45:16 -07:00
// Unable to convert ' 2018-08-18T12:45:16.0000000Z '
// 2018-08-18T12:45:16.0000000+02:00 --> 2018-08-18 12:45:16 +02:00
// 2018-08-18T12:45:16.0000000-07:00 --> 2018-08-18 12:45:16 -07:00
//
// -----
//
// Parsing with AllowWhiteSpaces:
// 2018-08-18T12:45:16.0000000Z --> 2018-08-18 12:45:16 +00:00
// Unable to convert '2018/08/18T12:45:16.0000000Z'
// Unable to convert '2018-18-08T12:45:16.0000000Z'
// 2018-08-18T12:45:16.0000000 --> 2018-08-18 12:45:16 -07:00
// 2018-08-18T12:45:16.0000000Z --> 2018-08-18 12:45:16 +00:00
// 2018-08-18T12:45:16.0000000+02:00 --> 2018-08-18 12:45:16 +02:00
// 2018-08-18T12:45:16.0000000-07:00 --> 2018-08-18 12:45:16 -07:00
//
// -----
//
// Parsing with AdjustToUniversal:
// 2018-08-18T12:45:16.0000000Z --> 2018-08-18 12:45:16 +00:00
// Unable to convert '2018/08/18T12:45:16.0000000Z'
// Unable to convert '2018-18-08T12:45:16.0000000Z'
// 2018-08-18T12:45:16.0000000 --> 2018-08-18 19:45:16 +00:00
// Unable to convert ' 2018-08-18T12:45:16.0000000Z '
// 2018-08-18T12:45:16.0000000+02:00 --> 2018-08-18 10:45:16 +00:00
// 2018-08-18T12:45:16.0000000-07:00 --> 2018-08-18 19:45:16 +00:00
//
// -----
//
// Parsing with AssumeLocal:
// 2018-08-18T12:45:16.0000000Z --> 2018-08-18 12:45:16 +00:00
// Unable to convert '2018/08/18T12:45:16.0000000Z'
// Unable to convert '2018-18-08T12:45:16.0000000Z'
// 2018-08-18T12:45:16.0000000 --> 2018-08-18 12:45:16 -07:00
// Unable to convert ' 2018-08-18T12:45:16.0000000Z '
// 2018-08-18T12:45:16.0000000+02:00 --> 2018-08-18 12:45:16 +02:00
// 2018-08-18T12:45:16.0000000-07:00 --> 2018-08-18 12:45:16 -07:00
//
// -----
//
// Parsing with AssumeUniversal:
// 2018-08-18T12:45:16.0000000Z --> 2018-08-18 12:45:16 +00:00
// Unable to convert '2018/08/18T12:45:16.0000000Z'
// Unable to convert '2018-18-08T12:45:16.0000000Z'
// 2018-08-18T12:45:16.0000000 --> 2018-08-18 12:45:16 +00:00
// Unable to convert ' 2018-08-18T12:45:16.0000000Z '
// 2018-08-18T12:45:16.0000000+02:00 --> 2018-08-18 12:45:16 +02:00
// 2018-08-18T12:45:16.0000000-07:00 --> 2018-08-18 12:45:16 -07:00
using System;
using System.Globalization;
public class Example
{
public static void Main()
{
string[] dateStrings = { "2018-08-18T12:45:16.0000000Z",
"2018/08/18T12:45:16.0000000Z",
"2018-18-08T12:45:16.0000000Z",
"2018-08-18T12:45:16.0000000",
" 2018-08-18T12:45:16.0000000Z ",
"2018-08-18T12:45:16.0000000+02:00",
"2018-08-18T12:45:16.0000000-07:00" };
ParseWithISO8601(dateStrings, DateTimeStyles.None);
Console.WriteLine("\n-----\n");
ParseWithISO8601(dateStrings, DateTimeStyles.AllowWhiteSpaces);
Console.WriteLine("\n-----\n");
ParseWithISO8601(dateStrings, DateTimeStyles.AdjustToUniversal);
Console.WriteLine("\n-----\n");
ParseWithISO8601(dateStrings, DateTimeStyles.AssumeLocal);
Console.WriteLine("\n-----\n");
ParseWithISO8601(dateStrings, DateTimeStyles.AssumeUniversal); }
private static void ParseWithISO8601(string[] dateStrings, DateTimeStyles styles)
{
Console.WriteLine($"Parsing with {styles}:");
DateTimeOffset date;
foreach (var dateString in dateStrings)
{
if (DateTimeOffset.TryParseExact(dateString, "O", null, styles, out date))
{
Console.WriteLine($" {dateString,-35} --> {date:yyyy-MM-dd HH:mm:ss.FF zzz}");
}
else
{
Console.WriteLine($" Unable to convert '{dateString}'");
}
}
}
}
// The example displays the following output:
// Parsing with None:
// 2018-08-18T12:45:16.0000000Z --> 2018-08-18 12:45:16 +00:00
// Unable to convert '2018/08/18T12:45:16.0000000Z'
// Unable to convert '2018-18-08T12:45:16.0000000Z'
// 2018-08-18T12:45:16.0000000 --> 2018-08-18 12:45:16 -07:00
// Unable to convert ' 2018-08-18T12:45:16.0000000Z '
// 2018-08-18T12:45:16.0000000+02:00 --> 2018-08-18 12:45:16 +02:00
// 2018-08-18T12:45:16.0000000-07:00 --> 2018-08-18 12:45:16 -07:00
//
// -----
//
// Parsing with AllowWhiteSpaces:
// 2018-08-18T12:45:16.0000000Z --> 2018-08-18 12:45:16 +00:00
// Unable to convert '2018/08/18T12:45:16.0000000Z'
// Unable to convert '2018-18-08T12:45:16.0000000Z'
// 2018-08-18T12:45:16.0000000 --> 2018-08-18 12:45:16 -07:00
// 2018-08-18T12:45:16.0000000Z --> 2018-08-18 12:45:16 +00:00
// 2018-08-18T12:45:16.0000000+02:00 --> 2018-08-18 12:45:16 +02:00
// 2018-08-18T12:45:16.0000000-07:00 --> 2018-08-18 12:45:16 -07:00
//
// -----
//
// Parsing with AdjustToUniversal:
// 2018-08-18T12:45:16.0000000Z --> 2018-08-18 12:45:16 +00:00
// Unable to convert '2018/08/18T12:45:16.0000000Z'
// Unable to convert '2018-18-08T12:45:16.0000000Z'
// 2018-08-18T12:45:16.0000000 --> 2018-08-18 19:45:16 +00:00
// Unable to convert ' 2018-08-18T12:45:16.0000000Z '
// 2018-08-18T12:45:16.0000000+02:00 --> 2018-08-18 10:45:16 +00:00
// 2018-08-18T12:45:16.0000000-07:00 --> 2018-08-18 19:45:16 +00:00
//
// -----
//
// Parsing with AssumeLocal:
// 2018-08-18T12:45:16.0000000Z --> 2018-08-18 12:45:16 +00:00
// Unable to convert '2018/08/18T12:45:16.0000000Z'
// Unable to convert '2018-18-08T12:45:16.0000000Z'
// 2018-08-18T12:45:16.0000000 --> 2018-08-18 12:45:16 -07:00
// Unable to convert ' 2018-08-18T12:45:16.0000000Z '
// 2018-08-18T12:45:16.0000000+02:00 --> 2018-08-18 12:45:16 +02:00
// 2018-08-18T12:45:16.0000000-07:00 --> 2018-08-18 12:45:16 -07:00
//
// -----
//
// Parsing with AssumeUniversal:
// 2018-08-18T12:45:16.0000000Z --> 2018-08-18 12:45:16 +00:00
// Unable to convert '2018/08/18T12:45:16.0000000Z'
// Unable to convert '2018-18-08T12:45:16.0000000Z'
// 2018-08-18T12:45:16.0000000 --> 2018-08-18 12:45:16 +00:00
// Unable to convert ' 2018-08-18T12:45:16.0000000Z '
// 2018-08-18T12:45:16.0000000+02:00 --> 2018-08-18 12:45:16 +02:00
// 2018-08-18T12:45:16.0000000-07:00 --> 2018-08-18 12:45:16 -07:00
Imports System.Globalization
Public Module Example
Public Sub Main()
Dim dateStrings() = { "2018-08-18T12:45:16.0000000Z",
"2018/08/18T12:45:16.0000000Z",
"2018-18-08T12:45:16.0000000Z",
"2018-08-18T12:45:16.0000000",
" 2018-08-18T12:45:16.0000000Z ",
"2018-08-18T12:45:16.0000000+02:00",
"2018-08-18T12:45:16.0000000-07:00" }
ParseWithISO8601(dateStrings, DateTimeStyles.None)
Console.WriteLine($"{vbCrLf}-----{vbCrLf}")
ParseWithISO8601(dateStrings, DateTimeStyles.AllowWhiteSpaces)
Console.WriteLine($"{vbCrLf}-----{vbCrLf}")
ParseWithISO8601(dateStrings, DateTimeStyles.AdjustToUniversal)
Console.WriteLine($"{vbCrLf}-----{vbCrLf}")
ParseWithISO8601(dateStrings, DateTimeStyles.AssumeLocal)
Console.WriteLine($"{vbCrLf}-----{vbCrLf}")
ParseWithISO8601(dateStrings, DateTimeStyles.AssumeUniversal)
End Sub
Private Sub ParseWithISO8601(dateStrings() As String, styles As DateTimeStyles)
Console.WriteLine($"Parsing with {styles}:")
Dim dat As DateTimeOffset
For Each dateStr In dateStrings
If DateTimeOffset.TryParseExact(dateStr, "O", Nothing, styles, dat) Then
Console.WriteLine($" {dateStr,-35} --> {dat:yyyy-MM-dd HH:mm:ss.FF zzz}")
Else
Console.WriteLine($" Unable to convert '{dateStr}'")
End If
Next
End Sub
End Module
' The example displays the following output:
' Parsing with None:
' 2018-08-18T12:45:16.0000000Z --> 2018-08-18 12:45:16 +00:00
' Unable to convert '2018/08/18T12:45:16.0000000Z'
' Unable to convert '2018-18-08T12:45:16.0000000Z'
' 2018-08-18T12:45:16.0000000 --> 2018-08-18 12:45:16 -07:00
' Unable to convert ' 2018-08-18T12:45:16.0000000Z '
' 2018-08-18T12:45:16.0000000+02:00 --> 2018-08-18 12:45:16 +02:00
' 2018-08-18T12:45:16.0000000-07:00 --> 2018-08-18 12:45:16 -07:00
'
' -----
'
' Parsing with AllowWhiteSpaces:
' 2018-08-18T12:45:16.0000000Z --> 2018-08-18 12:45:16 +00:00
' Unable to convert '2018/08/18T12:45:16.0000000Z'
' Unable to convert '2018-18-08T12:45:16.0000000Z'
' 2018-08-18T12:45:16.0000000 --> 2018-08-18 12:45:16 -07:00
' 2018-08-18T12:45:16.0000000Z --> 2018-08-18 12:45:16 +00:00
' 2018-08-18T12:45:16.0000000+02:00 --> 2018-08-18 12:45:16 +02:00
' 2018-08-18T12:45:16.0000000-07:00 --> 2018-08-18 12:45:16 -07:00
'
' -----
'
' Parsing with AdjustToUniversal:
' 2018-08-18T12:45:16.0000000Z --> 2018-08-18 12:45:16 +00:00
' Unable to convert '2018/08/18T12:45:16.0000000Z'
' Unable to convert '2018-18-08T12:45:16.0000000Z'
' 2018-08-18T12:45:16.0000000 --> 2018-08-18 19:45:16 +00:00
' Unable to convert ' 2018-08-18T12:45:16.0000000Z '
' 2018-08-18T12:45:16.0000000+02:00 --> 2018-08-18 10:45:16 +00:00
' 2018-08-18T12:45:16.0000000-07:00 --> 2018-08-18 19:45:16 +00:00
'
' -----
'
' Parsing with AssumeLocal:
' 2018-08-18T12:45:16.0000000Z --> 2018-08-18 12:45:16 +00:00
' Unable to convert '2018/08/18T12:45:16.0000000Z'
' Unable to convert '2018-18-08T12:45:16.0000000Z'
' 2018-08-18T12:45:16.0000000 --> 2018-08-18 12:45:16 -07:00
' Unable to convert ' 2018-08-18T12:45:16.0000000Z '
' 2018-08-18T12:45:16.0000000+02:00 --> 2018-08-18 12:45:16 +02:00
' 2018-08-18T12:45:16.0000000-07:00 --> 2018-08-18 12:45:16 -07:00
'
' -----
'
' Parsing with AssumeUniversal:
' 2018-08-18T12:45:16.0000000Z --> 2018-08-18 12:45:16 +00:00
' Unable to convert '2018/08/18T12:45:16.0000000Z'
' Unable to convert '2018-18-08T12:45:16.0000000Z'
' 2018-08-18T12:45:16.0000000 --> 2018-08-18 12:45:16 +00:00
' Unable to convert ' 2018-08-18T12:45:16.0000000Z '
' 2018-08-18T12:45:16.0000000+02:00 --> 2018-08-18 12:45:16 +02:00
' 2018-08-18T12:45:16.0000000-07:00 --> 2018-08-18 12:45:16 -07:00
Remarques
Cette surcharge de la méthode TryParseExact(String, String, IFormatProvider, DateTimeStyles, DateTimeOffset) est semblable à la méthode DateTimeOffset.ParseExact(String, String, IFormatProvider, DateTimeStyles), sauf que cette méthode ne lève pas d’exception si la conversion échoue. Il analyse la représentation sous forme de chaîne d’une date et d’une heure qui doivent correspondre exactement au modèle spécifié par le paramètre format
. Si la chaîne input
ne correspond pas à ce modèle, avec certaines variations possibles de l’espace blanc défini par le paramètre styles
, l’opération d’analyse échoue et la méthode retourne false
.
Le paramètre format
est une chaîne qui contient un spécificateur de format standard unique ou un ou plusieurs spécificateurs de format personnalisés qui définissent le modèle requis de input
. Pour plus d’informations sur les codes de mise en forme valides, consultez chaînes de format de date et d’heure standard et chaînes de format de date et d’heure personnalisées. Si format
inclut le z
, zz
ou zzz
spécificateurs de format personnalisé pour indiquer qu’un décalage doit être présent dans input
, ce décalage doit inclure un signe négatif ou un signe positif. Si le signe est manquant, l’opération d’analyse échoue et la méthode retourne false
.
Si format
exige que input
contiennent une date, mais pas une heure, l’objet DateTimeOffset résultant est affecté à l’heure de minuit (0:00:00). Si format
exige que input
contiennent une heure, mais pas une date, l’objet DateTimeOffset résultant est affecté à la date actuelle sur le système local. Si format
ne nécessite pas que input
contiennent un décalage, le décalage de l’objet DateTimeOffset résultant dépend de la valeur du paramètre styles
. Si styles
inclut AssumeLocal, le décalage du fuseau horaire local est affecté à l’objet DateTimeOffset. Si styles
inclut AssumeUniversal, le décalage UTC (Temps universel coordonné) ou +00:00 est affecté à l’objet DateTimeOffset. Si aucune valeur n’est spécifiée, le décalage du fuseau horaire local est utilisé.
Les symboles et chaînes de date et d’heure spécifiques utilisés dans input
sont définis par le paramètre formatProvider
. Il en va de même pour le modèle précis de input
si format
est une chaîne de spécificateur de format standard. Le paramètre formatProvider
peut être l’un des éléments suivants :
Objet CultureInfo qui représente la culture en fonction de laquelle
input
est interprété. L’objet DateTimeFormatInfo retourné par la propriété CultureInfo.DateTimeFormat définit les symboles et les formats standard autorisés dansinput
.Objet DateTimeFormatInfo qui définit le format des données de date et d’heure.
Si formatprovider
est null
, l’objet CultureInfo qui correspond à la culture actuelle est utilisé.
Le paramètre styles
définit si l’espace blanc est autorisé dans la chaîne d’entrée, indique comment les chaînes sans composant de décalage explicite sont analysées et prend en charge la conversion UTC dans le cadre de l’opération d’analyse. Tous les membres de l’énumération DateTimeStyles sont pris en charge, sauf NoCurrentDateDefault. Le tableau suivant répertorie l’effet de chaque membre pris en charge.
membre DateTimeStyles |
Comportement |
---|---|
AdjustToUniversal | Analyse input et, si nécessaire, la convertit en UTC. Il équivaut à analyser une chaîne, puis à appeler la méthode DateTimeOffset.ToUniversalTime de l’objet DateTimeOffset retourné. |
AssumeLocal | Si format ne nécessite pas que input contiennent une valeur de décalage, l’objet DateTimeOffset retourné reçoit le décalage du fuseau horaire local. Il s’agit du comportement par défaut. |
AssumeUniversal | Si format ne nécessite pas que input contiennent une valeur de décalage, l’objet DateTimeOffset retourné reçoit le décalage UTC (+00:00). |
AllowInnerWhite | Permet input d’inclure un espace blanc interne non spécifié par format. Un espace blanc supplémentaire peut apparaître entre les composants de date et d’heure et dans des composants individuels, autres que le décalage, et est ignoré lors de l’analyse de la chaîne. |
AllowLeadingWhite | Permet input d’inclure des espaces de début non spécifiés par format . Elles sont ignorées lors de l’analyse de la chaîne. |
AllowTrailingWhite | Permet input d’inclure des espaces de fin non spécifiés par format . Elles sont ignorées lors de l’analyse de la chaîne. |
AllowWhiteSpaces | Permet input d’inclure des espaces de début, de fin et d’intérieur non spécifiés par format . Tous les espaces blancs supplémentaires non spécifiés dans format sont ignorés lors de l’analyse de la chaîne. |
None | Indique que l’espace blanc supplémentaire n’est pas autorisé dans input . L’espace blanc doit apparaître exactement comme spécifié dans format . Il s’agit du comportement par défaut. |
RoundtripKind | N’a aucun effet, car la structure DateTimeOffset n’inclut pas de propriété Kind . |
Notes pour les appelants
Dans .NET Framework 4, le TryParseExact retourne false
si la chaîne à analyser contient un composant d’heure et un indicateur AM/PM qui ne sont pas en accord. Dans .NET Framework 3.5 et versions antérieures, l’indicateur AM/PM est ignoré.
Voir aussi
S’applique à
Commentaires
https://aka.ms/ContentUserFeedback.
Bientôt disponible : Tout au long de 2024, nous allons supprimer progressivement GitHub Issues comme mécanisme de commentaires pour le contenu et le remplacer par un nouveau système de commentaires. Pour plus d’informations, consultezEnvoyer et afficher des commentaires pour