DateTimeOffset.TryParseExact Metodo

Riferimento

Definizione

Spazio dei nomi:: System

Assembly:: System.Runtime.dll

Assembly:: mscorlib.dll

Assembly:: netstandard.dll

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)

Source:: DateTimeOffset.cs

Source:: DateTimeOffset.cs

Source:: 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

Boolean

true se il parametro input è stato convertito correttamente; in caso contrario, false.

Eccezioni

ArgumentException

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 zzzidentificatori 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 in input.
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.

Membro`DateTimeStyles`	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)

Source:: DateTimeOffset.cs

Source:: DateTimeOffset.cs

Source:: 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

Restituisce

Boolean

true se il parametro input è stato convertito correttamente; in caso contrario, false.

Eccezioni

ArgumentException

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 zidentificatori di formato , zzo 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 DateTimeFormatInfo CultureInfo.DateTimeFormat restituito dalla proprietà definisce i simboli e i formati standard consentiti in input.
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.

Membro`DateTimeStyles`	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)

Source:: DateTimeOffset.cs

Source:: DateTimeOffset.cs

Source:: 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

Boolean

true se il parametro input è stato convertito correttamente; in caso contrario, false.

Eccezioni

ArgumentException

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 zidentificatori di formato , zzo 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 DateTimeFormatInfo CultureInfo.DateTimeFormat restituito dalla proprietà definisce i simboli e la formattazione in input.
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.

Membro`DateTimeStyles`	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)

Source:: DateTimeOffset.cs

Source:: DateTimeOffset.cs

Source:: 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 è nullo 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

Boolean

true se il parametro input è stato convertito correttamente; in caso contrario, false.

Eccezioni

ArgumentException

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 zidentificatori di formato , zzo 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 in input.
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.

Membro`DateTimeStyles`	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

Vedi anche

ParseExact

Si applica a

DateTimeOffset.TryParseExact Metodo

Definizione

Overload

TryParseExact(String, String[], IFormatProvider, DateTimeStyles, DateTimeOffset)

Parametri

Restituisce

Eccezioni

Esempio

Commenti

Note per i chiamanti

Si applica a

TryParseExact(ReadOnlySpan<Char>, ReadOnlySpan<Char>, IFormatProvider, DateTimeStyles, DateTimeOffset)

Parametri

Restituisce

Eccezioni

Commenti

Si applica a

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

Parametri

Restituisce

Eccezioni

Commenti

Si applica a

TryParseExact(String, String, IFormatProvider, DateTimeStyles, DateTimeOffset)

Parametri

Restituisce

Eccezioni

Esempio

Commenti

Note per i chiamanti

Vedi anche

Si applica a

Commenti e suggerimenti

Risorse aggiuntive