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