DateTimeOffset.TryParseExact Metodo
Definizione
Importante
Alcune informazioni sono relative alla release non definitiva del prodotto, che potrebbe subire modifiche significative prima della release definitiva. Microsoft non riconosce alcuna garanzia, espressa o implicita, in merito alle informazioni qui fornite.
Converte una determinata rappresentazione di stringa di una data e di un'ora nell'equivalente DateTimeOffset. Il formato della rappresentazione di stringa deve corrispondere esattamente a un formato specificato.
Overload
TryParseExact(String, String[], IFormatProvider, DateTimeStyles, DateTimeOffset) |
Converte una determinata rappresentazione di stringa di una data e di un'ora nell'oggetto DateTimeOffset equivalente usando la matrice di formati, le informazioni sul formato specifiche delle impostazioni cultura e lo stile specificati. Il formato della rappresentazione di stringa deve corrispondere esattamente a uno dei formati specificati. |
TryParseExact(ReadOnlySpan<Char>, ReadOnlySpan<Char>, IFormatProvider, DateTimeStyles, DateTimeOffset) |
Converte una determinata rappresentazione di una data e di un'ora in un intervallo di caratteri nell'oggetto DateTimeOffset equivalente usando il formato, le informazioni sul formato specifiche delle impostazioni cultura e lo stile specificati. Il formato della rappresentazione di data e ora deve corrispondere esattamente al formato specificato. |
TryParseExact(ReadOnlySpan<Char>, String[], IFormatProvider, DateTimeStyles, DateTimeOffset) |
Converte una rappresentazione di una data e ora in un intervallo di caratteri nell'elemento DateTimeOffset equivalente usando i formati, le informazioni sul formato delle impostazioni cultura e lo stile specificati. Il formato della rappresentazione di data e ora deve corrispondere esattamente a uno dei formati specificati. |
TryParseExact(String, String, IFormatProvider, DateTimeStyles, DateTimeOffset) |
Converte una determinata rappresentazione di stringa di una data e di un'ora nell'oggetto DateTimeOffset equivalente usando il formato, le informazioni sul formato specifiche delle impostazioni cultura e lo stile specificati. Il formato della rappresentazione di stringa deve corrispondere esattamente al formato specificato. |
TryParseExact(String, String[], IFormatProvider, DateTimeStyles, DateTimeOffset)
- Origine:
- DateTimeOffset.cs
- Origine:
- DateTimeOffset.cs
- Origine:
- DateTimeOffset.cs
Converte una determinata rappresentazione di stringa di una data e di un'ora nell'oggetto DateTimeOffset equivalente usando la matrice di formati, le informazioni sul formato specifiche delle impostazioni cultura e lo stile specificati. Il formato della rappresentazione di stringa deve corrispondere esattamente a uno dei formati specificati.
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
Parametri
- input
- String
Stringa che contiene una data e un'ora da convertire.
- formats
- String[]
Matrice che definisce i formati previsti di input
.
- formatProvider
- IFormatProvider
Oggetto che fornisce informazioni di formattazione specifiche delle impostazioni cultura relativamente a input
.
- styles
- DateTimeStyles
Combinazione bit per bit di valori di enumerazione che indica il formato consentito di input. Un valore tipico da specificare è None
.
- result
- DateTimeOffset
Quando il metodo viene restituito, contiene l'equivalente DateTimeOffset alla data e all'ora di input
, se la conversione ha avuto esito positivo o DateTimeOffset.MinValue, se la conversione non è riuscita. La conversione non riesce se input
non contiene una rappresentazione di data e ora in formato di stringa valida nel formato previsto oppure non contiene il formato di data e ora previsto definito da format
oppure se formats
è null
. Questo parametro viene passato non inizializzato.
Restituisce
true
se il parametro input
è stato convertito correttamente; in caso contrario, false
.
Eccezioni
styles
include un valore DateTimeStyles non definito.
-oppure-
NoCurrentDateDefault non è supportato.
-oppure-
styles
include valori DateTimeStyles che si escludono a vicenda.
Esempio
Nell'esempio seguente vengono definiti più formati di input per la rappresentazione di stringa di un valore di data e ora e offset e quindi passa la stringa immessa dall'utente al TryParseExact(String, String[], IFormatProvider, DateTimeStyles, DateTimeOffset) metodo .
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
Commenti
Il TryParseExact(String, String[], IFormatProvider, DateTimeStyles, DateTimeOffset) metodo analizza la rappresentazione di stringa di una data corrispondente a uno dei modelli assegnati alla formats
matrice. Se la input
stringa non corrisponde a uno di questi criteri con eventuali varianti definite dal styles
parametro , l'operazione di analisi ha esito negativo e il metodo restituisce false
. A parte il confronto input
con più stringhe che contengono identificatori di formato, questo overload si comporta in modo identico al DateTimeOffset.ParseExact(String, String[], IFormatProvider, DateTimeStyles) metodo .
Il formats
parametro è una matrice di stringhe i cui elementi contengono un singolo identificatore di formato standard o uno o più identificatori di formato personalizzati che definiscono il modello possibile di input
. Per informazioni dettagliate sui codici di formattazione validi, vedere Stringhe di formato data e ora standard e stringhe di formato di data e ora personalizzate. Se l'elemento corrispondente in formats
include gli z
zz
identificatori di formato personalizzati , o zzz
per indicare che un offset deve essere presente in input
, tale offset deve includere un segno negativo o un segno positivo. Se il segno non è presente, l'operazione di analisi ha esito negativo e il metodo restituisce false
.
Importante
L'uso del formats
parametro di questo overload per specificare più formati può contribuire a ridurre la frustrazione che molti utenti riscontrano quando immettono date e ore. In particolare, la possibilità di definire più modelli di input consente a un'applicazione di gestire rappresentazioni di data e ora che possono includere o mancanza di zeri iniziali in mesi, giorni, ore, minuti e secondi. Nell'esempio viene fornita un'illustrazione di questo oggetto.
Se l'elemento corrispondente in formats
richiede che input
contenga una data ma non un'ora, all'oggetto risultante DateTimeOffset viene assegnata un'ora di mezzanotte (0:00:00). Se l'elemento corrispondente in formats
richiede che l'input contenga un'ora ma non una data, all'oggetto risultante DateTimeOffset viene assegnata la data corrente nel sistema locale. Se l'elemento corrispondente in formats
non richiede che input
contenga un offset, l'offset dell'oggetto risultante DateTimeOffset dipende dal valore del styles
parametro . Se styles
include AssumeLocal, l'offset del fuso orario locale viene assegnato all'oggetto DateTimeOffset . Se styles
include AssumeUniversal, l'offset UTC (Coordinated Universal Time) o +00:00, viene assegnato all'oggetto DateTimeOffset . Se nessuno dei due valori viene specificato, viene utilizzato l'offset del fuso orario locale.
I simboli e le stringhe di data e ora specifici utilizzati in input
sono definiti dal formatProvider
parametro . Lo stesso vale per il modello preciso di input
se l'elemento corrispondente di è una stringa di identificatore di formats
formato standard. Il formatProvider
parametro può essere uno dei seguenti:
Oggetto CultureInfo che rappresenta le impostazioni cultura basate su cui
input
viene interpretato. L'oggetto DateTimeFormatInfo restituito dalla CultureInfo.DateTimeFormat proprietà definisce i simboli e la formattazione ininput
.Oggetto DateTimeFormatInfo che definisce il formato dei dati di data e ora.
Se formatprovider
è null
, viene utilizzato l'oggetto CultureInfo che corrisponde alle impostazioni cultura correnti.
Il styles
parametro definisce se lo spazio vuoto è consentito nella stringa di input, indica come vengono analizzate le stringhe senza un componente di offset esplicito e supporta la conversione UTC come parte dell'operazione di analisi. Tutti i membri dell'enumerazione DateTimeStyles sono supportati tranne NoCurrentDateDefault. La tabella seguente elenca l'effetto di ogni membro supportato.
MembroDateTimeStyles |
Comportamento |
---|---|
AdjustToUniversal | input Analizza e, se necessario, lo converte in formato UTC. Equivale ad analizzare una stringa e quindi chiamare il DateTimeOffset.ToUniversalTime metodo dell'oggetto restituito DateTimeOffset . |
AssumeLocal | Se l'elemento corrispondente in formats non richiede che input contenga un valore di offset, all'oggetto restituito DateTimeOffset viene assegnato l'offset del fuso orario locale. Rappresenta il valore predefinito. |
AssumeUniversal | Se l'elemento corrispondente in formats non richiede che input contenga un valore di offset, all'oggetto restituito DateTimeOffset viene assegnato l'offset UTC (+00:00). |
AllowInnerWhite | Consente di input includere spazi vuoti interni non specificati dagli elementi in formats . Gli spazi vuoti aggiuntivi possono essere visualizzati tra componenti di data e ora e all'interno di singoli componenti (ad eccezione dell'offset) e vengono ignorati durante l'analisi della stringa. |
AllowLeadingWhite | Consente di input includere spazi iniziali non specificati dagli elementi in formats . Questi vengono ignorati durante l'analisi della stringa. |
AllowTrailingWhite | Consente di input includere gli spazi finali non specificati dagli elementi in formats . Questi vengono ignorati durante l'analisi della stringa. |
AllowWhiteSpaces | Consente di input includere spazi iniziali, finali e interni non specificati dagli elementi in formats . Tutti gli spazi vuoti aggiuntivi non specificati nell'elemento corrispondente in formats vengono ignorati durante l'analisi della stringa. |
None | Indica che non è consentito spazio vuoto aggiuntivo in input . Gli spazi vuoti devono essere visualizzati esattamente come specificato in un particolare elemento in formats affinché si verifichi una corrispondenza corretta. Comportamento predefinito. |
RoundtripKind | Non ha alcun effetto perché la DateTimeOffset struttura non include una Kind proprietà . |
Note per i chiamanti
In .NET Framework 4, restituisce TryParseExactfalse
se la stringa da analizzare contiene un componente ora e un designatore AM/PM che non sono in accordo. In .NET Framework 3.5 e versioni precedenti, l'iniziatore AM/PM viene ignorato.
Si applica a
TryParseExact(ReadOnlySpan<Char>, ReadOnlySpan<Char>, IFormatProvider, DateTimeStyles, DateTimeOffset)
- Origine:
- DateTimeOffset.cs
- Origine:
- DateTimeOffset.cs
- Origine:
- DateTimeOffset.cs
Converte una determinata rappresentazione di una data e di un'ora in un intervallo di caratteri nell'oggetto DateTimeOffset equivalente usando il formato, le informazioni sul formato specifiche delle impostazioni cultura e lo stile specificati. Il formato della rappresentazione di data e ora deve corrispondere esattamente al formato specificato.
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
Parametri
- input
- ReadOnlySpan<Char>
Intervallo contenente i caratteri che rappresentano una data e ora da convertire.
- format
- ReadOnlySpan<Char>
Identificatore di formato che definisce il formato richiesto di input
.
- formatProvider
- IFormatProvider
Oggetto che fornisce informazioni di formattazione specifiche delle impostazioni cultura relativamente a input
.
- styles
- DateTimeStyles
Combinazione bit per bit di valori di enumerazione che indica il formato consentito di input
. Un valore tipico da specificare è None.
- result
- DateTimeOffset
Quando il metodo viene restituito, contiene l'equivalente DateTimeOffset alla data e all'ora di input
, se la conversione ha avuto esito positivo o DateTimeOffset.MinValue se la conversione non è riuscita. La conversione non riesce se
Restituisce
true
se il parametro input
è stato convertito correttamente; in caso contrario, false
.
Eccezioni
styles
include un valore DateTimeStyles non definito.
-oppure- NoCurrentDateDefault non è supportato.
-oppure- styles
include valori DateTimeStyles che si escludono a vicenda.
Commenti
Questo overload è simile al DateTimeOffset.ParseExact(ReadOnlySpan<Char>, ReadOnlySpan<Char>, IFormatProvider, DateTimeStyles) metodo , ad eccezione del fatto che questo metodo non genera un'eccezione se la conversione non riesce. Analizza la rappresentazione di una data e di un'ora che deve corrispondere esattamente al modello specificato dal format
parametro . Se input
non corrisponde a questo modello, con alcune possibili variazioni nello spazio vuoto definito dal styles
parametro , l'operazione di analisi ha esito negativo e il metodo restituisce false
.
Il format
parametro è un intervallo di caratteri che contiene un singolo identificatore di formato standard o uno o più identificatori di formato personalizzati che definiscono il modello richiesto di input
. Per informazioni dettagliate sui codici di formattazione validi, vedere Stringhe di formato data e ora standard e stringhe di formato data e ora personalizzate. Se format
include gli z
identificatori di formato , zz
o zzz
personalizzati per indicare che un offset deve essere presente in input
, tale offset deve includere un segno negativo o un segno positivo. Se il segno non è presente, l'operazione di analisi ha esito negativo e il metodo restituisce false
.
Se format
è necessario che input
contengano una data ma non un'ora, l'oggetto risultante DateTimeOffset viene assegnato un'ora di mezzanotte (0:00:00). Se format
è necessario che input
contengano un'ora ma non una data, l'oggetto risultante DateTimeOffset viene assegnato alla data corrente nel sistema locale. Se format
non richiede che input
contengano un offset, l'offset dell'oggetto risultante DateTimeOffset dipende dal valore del styles
parametro. Se styles
include AssumeLocal, l'offset del fuso orario locale viene assegnato all'oggetto DateTimeOffset . Se styles
include AssumeUniversal, l'offset UTC (Coordinated Universal Time) o +00:00, viene assegnato all'oggetto DateTimeOffset . Se non viene specificato alcun valore, viene usato l'offset del fuso orario locale.
I simboli e le stringhe di data e ora specifici usati in input
sono definiti dal formatProvider
parametro . Lo stesso vale per il modello preciso di input
se format
è una stringa di identificatore di formato standard. Il formatProvider
parametro può essere uno dei seguenti:
Oggetto CultureInfo che rappresenta le impostazioni cultura basate su cui
input
viene interpretato. L'oggetto DateTimeFormatInfoCultureInfo.DateTimeFormat restituito dalla proprietà definisce i simboli e i formati standard consentiti ininput
.Oggetto DateTimeFormatInfo che definisce il formato dei dati di data e ora.
Se formatprovider
è null
, viene usato l'oggetto CultureInfo corrispondente alle impostazioni cultura correnti.
Il styles
parametro definisce se lo spazio vuoto è consentito nella stringa di input, indica come vengono analizzate le stringhe senza un componente di offset esplicito e supporta la conversione UTC come parte dell'operazione di analisi. Tutti i membri dell'enumerazione DateTimeStyles sono supportati tranne NoCurrentDateDefault. La tabella seguente elenca l'effetto di ogni membro supportato.
MembroDateTimeStyles |
Comportamento |
---|---|
AdjustToUniversal | Analizza e, se necessario, lo converte input in UTC. Equivale a analizzare una rappresentazione data e ora e quindi chiamare il DateTimeOffset.ToUniversalTime metodo dell'oggetto restituito DateTimeOffset . |
AssumeLocal | Se format non richiede che input contenga un valore di offset, l'oggetto restituito DateTimeOffset viene assegnato all'offset del fuso orario locale. Comportamento predefinito. |
AssumeUniversal | Se format non è necessario che input contenga un valore di offset, l'oggetto restituito DateTimeOffset viene assegnato all'offset UTC (+00:00). |
AllowInnerWhite | Consente di input includere spazi vuoti interni non specificati in base al formato. Lo spazio vuoto aggiuntivo può essere visualizzato tra componenti di data e ora e all'interno di singoli componenti, diverso dall'offset e ignorato durante l'analisi della stringa. |
AllowLeadingWhite | Consente di input includere spazi iniziali non specificati da format . Questi vengono ignorati durante l'analisi della stringa. |
AllowTrailingWhite | Consente di input includere spazi finali non specificati da format . Questi vengono ignorati durante l'analisi della stringa. |
AllowWhiteSpaces | Consente di input includere spazi iniziali, finali e interni non specificati da format . Tutti i caratteri di spazio vuoto aggiuntivi non specificati in format vengono ignorati durante l'analisi della stringa. |
None | Indica che lo spazio vuoto aggiuntivo non è consentito in input . Lo spazio vuoto deve essere visualizzato esattamente come specificato in format . Comportamento predefinito. |
RoundtripKind | Non ha alcun effetto, perché la DateTimeOffset struttura non include una Kind proprietà. |
Si applica a
TryParseExact(ReadOnlySpan<Char>, String[], IFormatProvider, DateTimeStyles, DateTimeOffset)
- Origine:
- DateTimeOffset.cs
- Origine:
- DateTimeOffset.cs
- Origine:
- DateTimeOffset.cs
Converte una rappresentazione di una data e ora in un intervallo di caratteri nell'elemento DateTimeOffset equivalente usando i formati, le informazioni sul formato delle impostazioni cultura e lo stile specificati. Il formato della rappresentazione di data e ora deve corrispondere esattamente a uno dei formati specificati.
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
Parametri
- input
- ReadOnlySpan<Char>
Intervallo contenente i caratteri che rappresentano una data e ora da convertire.
- formats
- String[]
Matrice di stringhe di formato standard o personalizzato che definiscono i formati accettabili di input
.
- formatProvider
- IFormatProvider
Oggetto che fornisce informazioni di formattazione specifiche delle impostazioni cultura relativamente a input
.
- styles
- DateTimeStyles
Combinazione bit per bit di valori di enumerazione che indica il formato consentito di input
. Un valore tipico da specificare è None.
- result
- DateTimeOffset
Quando il metodo restituisce, contiene l'equivalente DateTimeOffset alla data e all'ora di input
, se la conversione ha avuto esito positivo o DateTimeOffset.MinValue se la conversione non è riuscita. La conversione non riesce se
Restituisce
true
se il parametro input
è stato convertito correttamente; in caso contrario, false
.
Eccezioni
styles
include un valore DateTimeStyles non definito.
-oppure- NoCurrentDateDefault non è supportato.
-oppure- styles
include valori DateTimeStyles che si escludono a vicenda.
Commenti
Questo metodo analizza la rappresentazione stringa di una data corrispondente a uno dei modelli assegnati alla formats
matrice. Se input
non corrisponde a uno di questi modelli con eventuali varianti definite dal styles
parametro, l'operazione di analisi ha esito negativo e il metodo restituisce false
. A parte il confronto input
con più stringhe che contengono identificatori di formato, questo overload si comporta in modo identico al DateTimeOffset.ParseExact(ReadOnlySpan<Char>, String[], IFormatProvider, DateTimeStyles) metodo.
Il formats
parametro è una matrice di stringhe i cui elementi contengono un singolo identificatore di formato standard o uno o più identificatori di formato personalizzati che definiscono il possibile modello di input
. Per informazioni dettagliate sui codici di formattazione validi, vedere Stringhe di formato data e ora standard e stringhe di formato data e ora personalizzate. Se l'elemento corrispondente in formats
include gli z
identificatori di formato , zz
o zzz
personalizzati per indicare che un offset deve essere presente in input
, tale offset deve includere un segno negativo o un segno positivo. Se il segno è mancante, l'operazione di analisi ha esito negativo e il metodo restituisce false
.
Importante
L'uso del parametro di questo overload per specificare più formati può aiutare a ridurre la frustrazione di molti utenti durante l'immissione formats
di date e ore. In particolare, la possibilità di definire più modelli di input consente a un'applicazione di gestire rappresentazioni di data e ora che possono includere o mancanza di zero iniziali in mesi, giorni, ore, minuti e secondi. L'esempio fornisce un'illustrazione di questo oggetto.
Se l'elemento corrispondente in formats
richiede che input
contenga una data ma non un'ora, l'oggetto risultante DateTimeOffset viene assegnato un'ora di mezzanotte (0:00:00). Se l'elemento corrispondente in formats
richiede che l'input contenga un'ora ma non una data, l'oggetto risultante DateTimeOffset viene assegnato la data corrente nel sistema locale. Se l'elemento corrispondente in formats
non richiede che input
contenga un offset, l'offset dell'oggetto risultante DateTimeOffset dipende dal valore del styles
parametro. Se styles
include DateTimeStyles.AssumeLocal, l'offset del fuso orario locale viene assegnato all'oggetto DateTimeOffset . Se styles
include DateTimeStyles.AssumeUniversal, l'offset UTC (Coordinated Universal Time) o +00:00, viene assegnato all'oggetto DateTimeOffset . Se non viene specificato alcun valore, viene usato l'offset del fuso orario locale.
I simboli di data e ora specifici usati in input
sono definiti dal formatProvider
parametro . Lo stesso vale per il modello preciso di input
se l'elemento corrispondente di formats
è una stringa di identificatore di formato standard. Il formatProvider
parametro può essere uno dei seguenti:
Oggetto CultureInfo che rappresenta le impostazioni cultura basate su cui
input
viene interpretato. L'oggetto DateTimeFormatInfoCultureInfo.DateTimeFormat restituito dalla proprietà definisce i simboli e la formattazione ininput
.Oggetto DateTimeFormatInfo che definisce il formato dei dati di data e ora.
Se formatprovider
è null
, viene usato l'oggetto CultureInfo corrispondente alle impostazioni cultura correnti.
Il styles
parametro definisce se lo spazio vuoto è consentito nella stringa di input, indica come vengono analizzate le stringhe senza un componente di offset esplicito e supporta la conversione UTC come parte dell'operazione di analisi. Tutti i membri dell'enumerazione DateTimeStyles sono supportati tranne NoCurrentDateDefault. La tabella seguente elenca l'effetto di ogni membro supportato.
MembroDateTimeStyles |
Comportamento |
---|---|
AdjustToUniversal | Analizza e, se necessario, lo converte input in UTC. Equivale a analizzare una stringa e quindi chiamare il DateTimeOffset.ToUniversalTime metodo dell'oggetto restituito DateTimeOffset . |
AssumeLocal | Se l'elemento corrispondente in formats non richiede che input contenga un valore di offset, l'oggetto restituito DateTimeOffset viene assegnato l'offset del fuso orario locale. Rappresenta il valore predefinito. |
AssumeUniversal | Se l'elemento corrispondente in formats non richiede che input contenga un valore di offset, l'oggetto restituito DateTimeOffset viene assegnato all'offset UTC (+00:00). |
AllowInnerWhite | Consente di input includere spazi vuoti interni non specificati dagli elementi in formats . Lo spazio vuoto aggiuntivo può essere visualizzato tra componenti di data e ora e all'interno di singoli componenti (ad eccezione dell'offset) e viene ignorato durante l'analisi della stringa. |
AllowLeadingWhite | Consente di input includere spazi iniziali non specificati dagli elementi in formats . Questi vengono ignorati durante l'analisi della stringa. |
AllowTrailingWhite | Consente di input includere spazi finali non specificati dagli elementi in formats . Questi vengono ignorati durante l'analisi della stringa. |
AllowWhiteSpaces | Consente di input includere spazi iniziali, finali e interni non specificati dagli elementi in formats . Tutti i caratteri di spazio vuoto aggiuntivi non specificati nell'elemento corrispondente in formats vengono ignorati durante l'analisi della stringa. |
None | Indica che lo spazio vuoto aggiuntivo non è consentito in input . Lo spazio vuoto deve essere visualizzato esattamente come specificato in un particolare elemento in formats per la corretta corrispondenza. Comportamento predefinito. |
RoundtripKind | Non ha alcun effetto perché la DateTimeOffset struttura non include una Kind proprietà. |
Si applica a
TryParseExact(String, String, IFormatProvider, DateTimeStyles, DateTimeOffset)
- Origine:
- DateTimeOffset.cs
- Origine:
- DateTimeOffset.cs
- Origine:
- DateTimeOffset.cs
Converte una determinata rappresentazione di stringa di una data e di un'ora nell'oggetto DateTimeOffset equivalente usando il formato, le informazioni sul formato specifiche delle impostazioni cultura e lo stile specificati. Il formato della rappresentazione di stringa deve corrispondere esattamente al formato specificato.
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
Parametri
- input
- String
Stringa che contiene una data e un'ora da convertire.
- format
- String
Identificatore di formato che definisce il formato richiesto di input
.
- formatProvider
- IFormatProvider
Oggetto che fornisce informazioni di formattazione specifiche delle impostazioni cultura relativamente a input
.
- styles
- DateTimeStyles
Combinazione bit per bit di valori di enumerazione che indica il formato consentito di input. Un valore tipico da specificare è None
.
- result
- DateTimeOffset
Quando il metodo viene restituito, contiene l'equivalente DateTimeOffset alla data e all'ora di input
, se la conversione ha avuto esito positivo o DateTimeOffset.MinValue, se la conversione non è riuscita. La conversione ha esito negativo se il parametro input
è null
o non contiene una rappresentazione di data e ora in formato di stringa valida nel formato previsto definito da format
e provider
. Questo parametro viene passato non inizializzato.
Restituisce
true
se il parametro input
è stato convertito correttamente; in caso contrario, false
.
Eccezioni
styles
include un valore DateTimeStyles non definito.
-oppure-
NoCurrentDateDefault non è supportato.
-oppure-
styles
include valori DateTimeStyles che si escludono a vicenda.
Esempio
Nell'esempio seguente viene usato il TryParseExact(String, String, IFormatProvider, DateTimeStyles, DateTimeOffset) metodo con identificatori di formato standard e personalizzati, impostazioni cultura invarianti e vari DateTimeStyles valori per analizzare diverse stringhe di data e ora.
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.
Nell'esempio seguente viene usata un'ampia gamma di DateTimeStyles valori per analizzare una matrice di stringhe conformi a ISO 8601. Come illustrato nell'output dell'esempio, le stringhe nel formato corretto non riescono ad analizzare se:
contengono spazi vuoti e un flag appropriato DateTimeStyles , ad esempio DateTimeStyles.AllowWhiteSpaces non è stato fornito nella chiamata al metodo.
contengono elementi di data e ora non compresi nell'intervallo.
Si presuppone che le stringhe che non specificano un offset UTC abbiano l'offset del fuso orario locale (in questo caso -07:00, che riflette l'offset del fuso orario di ora legale pacifico) a meno che non venga specificato il DateTimeStyles.AssumeUniversal flag nella chiamata al metodo. In tal caso, si presuppone che siano Universal Coordinated Time.
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
Commenti
Questo overload del TryParseExact(String, String, IFormatProvider, DateTimeStyles, DateTimeOffset) metodo è simile al DateTimeOffset.ParseExact(String, String, IFormatProvider, DateTimeStyles) metodo , ad eccezione del fatto che questo metodo non genera un'eccezione se la conversione non riesce. Analizza la rappresentazione di stringa di una data e di un'ora che deve corrispondere esattamente al modello specificato dal format
parametro . Se la input
stringa non corrisponde a questo criterio, con alcune possibili variazioni nello spazio vuoto definito dal styles
parametro , l'operazione di analisi ha esito negativo e il metodo restituisce false
.
Il format
parametro è una stringa che contiene un singolo identificatore di formato standard o uno o più identificatori di formato personalizzati che definiscono il modello richiesto di input
. Per informazioni dettagliate sui codici di formattazione validi, vedere Stringhe di formato data e ora standard e stringhe di formato di data e ora personalizzate. Se format
include gli z
identificatori di formato , zz
o zzz
personalizzati per indicare che un offset deve essere presente in input
, tale offset deve includere un segno negativo o un segno positivo. Se il segno non è presente, l'operazione di analisi ha esito negativo e il metodo restituisce false
.
Se format
richiede che input
contengano una data ma non un'ora, all'oggetto risultante DateTimeOffset viene assegnata un'ora di mezzanotte (0:00:00). Se format
richiede che input
contengano un'ora ma non una data, all'oggetto risultante DateTimeOffset viene assegnata la data corrente nel sistema locale. Se format
non richiede che input
contengano un offset, l'offset dell'oggetto risultante DateTimeOffset dipende dal valore del styles
parametro . Se styles
include AssumeLocal, l'offset del fuso orario locale viene assegnato all'oggetto DateTimeOffset . Se styles
include AssumeUniversal, l'offset UTC (Coordinated Universal Time) o +00:00, viene assegnato all'oggetto DateTimeOffset . Se nessuno dei due valori viene specificato, viene utilizzato l'offset del fuso orario locale.
I simboli e le stringhe di data e ora specifici utilizzati in input
sono definiti dal formatProvider
parametro . Lo stesso vale per il modello preciso di se format
è una stringa di identificatore di input
formato standard. Il formatProvider
parametro può essere uno dei seguenti:
Oggetto CultureInfo che rappresenta le impostazioni cultura basate su cui
input
viene interpretato. L'oggetto DateTimeFormatInfo restituito dalla CultureInfo.DateTimeFormat proprietà definisce i simboli e i formati standard consentiti ininput
.Oggetto DateTimeFormatInfo che definisce il formato dei dati di data e ora.
Se formatprovider
è null
, viene utilizzato l'oggetto CultureInfo che corrisponde alle impostazioni cultura correnti.
Il styles
parametro definisce se lo spazio vuoto è consentito nella stringa di input, indica come vengono analizzate le stringhe senza un componente di offset esplicito e supporta la conversione UTC come parte dell'operazione di analisi. Tutti i membri dell'enumerazione DateTimeStyles sono supportati tranne NoCurrentDateDefault. La tabella seguente elenca l'effetto di ogni membro supportato.
MembroDateTimeStyles |
Comportamento |
---|---|
AdjustToUniversal | input Analizza e, se necessario, lo converte in formato UTC. Equivale ad analizzare una stringa e quindi chiamare il DateTimeOffset.ToUniversalTime metodo dell'oggetto restituito DateTimeOffset . |
AssumeLocal | Se format non richiede che input contenga un valore di offset, all'oggetto restituito DateTimeOffset viene assegnato l'offset del fuso orario locale. Comportamento predefinito. |
AssumeUniversal | Se format non richiede che input contenga un valore di offset, all'oggetto restituito DateTimeOffset viene assegnato l'offset UTC (+00:00). |
AllowInnerWhite | Consente di input includere spazi vuoti interni non specificati dal formato. Gli spazi vuoti aggiuntivi possono essere visualizzati tra componenti di data e ora e all'interno di singoli componenti, diversi dall'offset, e vengono ignorati durante l'analisi della stringa. |
AllowLeadingWhite | Consente di input includere spazi iniziali non specificati da format . Questi vengono ignorati durante l'analisi della stringa. |
AllowTrailingWhite | Consente di input includere gli spazi finali non specificati da format . Questi vengono ignorati durante l'analisi della stringa. |
AllowWhiteSpaces | Consente di input includere spazi iniziali, finali e interni non specificati da format . Tutti gli spazi vuoti aggiuntivi non specificati in format vengono ignorati durante l'analisi della stringa. |
None | Indica che non è consentito spazio vuoto aggiuntivo in input . Gli spazi vuoti devono essere visualizzati esattamente come specificato in format . Comportamento predefinito. |
RoundtripKind | Non ha alcun effetto, perché la DateTimeOffset struttura non include una Kind proprietà . |
Note per i chiamanti
In .NET Framework 4, restituisce TryParseExactfalse
se la stringa da analizzare contiene un componente ora e un designatore AM/PM che non sono in accordo. In .NET Framework 3.5 e versioni precedenti, l'iniziatore AM/PM viene ignorato.
Vedi anche
Si applica a
Commenti e suggerimenti
https://aka.ms/ContentUserFeedback.
Presto disponibile: Nel corso del 2024 verranno gradualmente disattivati i problemi di GitHub come meccanismo di feedback per il contenuto e ciò verrà sostituito con un nuovo sistema di feedback. Per altre informazioni, vedereInvia e visualizza il feedback per