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 la rappresentazione di stringa specificata di una data e un'ora nel relativo DateTimeOffset equivalente. Il formato della rappresentazione di stringa deve corrispondere esattamente a un formato specificato.

Overload

TryParseExact(String, String[], IFormatProvider, DateTimeStyles, DateTimeOffset)	Converte la rappresentazione di stringa specificata di una data e un'ora nel relativo 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 la rappresentazione di una data e di un'ora in un intervallo di caratteri nel relativo 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 la rappresentazione di una data e di un'ora in un intervallo di caratteri nel relativo DateTimeOffset equivalente usando i formati, le informazioni sul formato specifiche 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 la rappresentazione di stringa specificata di una data e un'ora nel relativo DateTimeOffset equivalente usando il formato specificato, le informazioni sul formato specifico 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 la rappresentazione di stringa specificata di una data e un'ora nel relativo 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 contenente 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 su input.

styles: DateTimeStyles

Combinazione bit per bit di valori di enumerazione che indica il formato di input consentito. Un valore tipico da specificare è None.

result: DateTimeOffset

Quando termina, il metodo contiene l'DateTimeOffset equivalente 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 il input non contiene una rappresentazione di stringa valida di una data e ora o non contiene la data e l'ora nel formato previsto definito da formatso se formats è null. Questo parametro viene passato non inizializzato.

Restituisce

Boolean

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

Eccezioni

ArgumentException

styles include un valore DateTimeStyles non definito.

-o-

NoCurrentDateDefault non è supportato.

-o-

styles include valori di 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 metodo TryParseExact(String, String[], IFormatProvider, DateTimeStyles, DateTimeOffset).

TextReader conIn = Console.In;
TextWriter conOut = Console.Out;
int tries = 0;
string input = String.Empty;

string[] formats = new string[] {"M/dd/yyyy HH:m zzz", "MM/dd/yyyy HH:m zzz",
                                 "M/d/yyyy HH:m zzz", "MM/d/yyyy HH:m zzz",
                                 "M/dd/yy HH:m zzz", "MM/dd/yy HH:m zzz",
                                 "M/d/yy HH:m zzz", "MM/d/yy HH:m zzz",
                                 "M/dd/yyyy H:m zzz", "MM/dd/yyyy H:m zzz",
                                 "M/d/yyyy H:m zzz", "MM/d/yyyy H:m zzz",
                                 "M/dd/yy H:m zzz", "MM/dd/yy H:m zzz",
                                 "M/d/yy H:m zzz", "MM/d/yy H:m zzz",
                                 "M/dd/yyyy HH:mm zzz", "MM/dd/yyyy HH:mm zzz",
                                 "M/d/yyyy HH:mm zzz", "MM/d/yyyy HH:mm zzz",
                                 "M/dd/yy HH:mm zzz", "MM/dd/yy HH:mm zzz",
                                 "M/d/yy HH:mm zzz", "MM/d/yy HH:mm zzz",
                                 "M/dd/yyyy H:mm zzz", "MM/dd/yyyy H:mm zzz",
                                 "M/d/yyyy H:mm zzz", "MM/d/yyyy H:mm zzz",
                                 "M/dd/yy H:mm zzz", "MM/dd/yy H:mm zzz",
                                 "M/d/yy H:mm zzz", "MM/d/yy H:mm zzz"};
IFormatProvider provider = CultureInfo.InvariantCulture.DateTimeFormat;
DateTimeOffset result;

do {
   conOut.WriteLine("Enter a date, time, and offset (MM/DD/YYYY HH:MM +/-HH:MM),");
   conOut.Write("Then press Enter: ");
   input = conIn.ReadLine();
   conOut.WriteLine();
   if (DateTimeOffset.TryParseExact(input, formats, provider,
                                   DateTimeStyles.AllowWhiteSpaces,
                                   out result))
   {
      break;
   }
   else
   {
      Console.WriteLine("Unable to parse {0}.", input);
      tries++;
   }
} while (tries < 3);
if (tries >= 3)
   Console.WriteLine("Exiting application without parsing {0}", input);
else
   Console.WriteLine("{0} was converted to {1}", input, result.ToString());
// Some successful sample interactions with the user might appear as follows:
//    Enter a date, time, and offset (MM/DD/YYYY HH:MM +/-HH:MM),
//    Then press Enter: 12/08/2007 6:54 -6:00
//
//    12/08/2007 6:54 -6:00 was converted to 12/8/2007 6:54:00 AM -06:00
//
//    Enter a date, time, and offset (MM/DD/YYYY HH:MM +/-HH:MM),
//    Then press Enter: 12/8/2007 06:54 -06:00
//
//    12/8/2007 06:54 -06:00 was converted to 12/8/2007 6:54:00 AM -06:00
//
//    Enter a date, time, and offset (MM/DD/YYYY HH:MM +/-HH:MM),
//    Then press Enter: 12/5/07 6:54 -6:00
//
//    12/5/07 6:54 -6:00 was converted to 12/5/2007 6:54:00 AM -06:00

let mutable result = None    
let mutable tries = 0
let mutable input = ""

let formats = 
    [| "M/dd/yyyy HH:m zzz"; "MM/dd/yyyy HH:m zzz"
       "M/d/yyyy HH:m zzz"; "MM/d/yyyy HH:m zzz"
       "M/dd/yy HH:m zzz"; "MM/dd/yy HH:m zzz"
       "M/d/yy HH:m zzz"; "MM/d/yy HH:m zzz"
       "M/dd/yyyy H:m zzz"; "MM/dd/yyyy H:m zzz"
       "M/d/yyyy H:m zzz"; "MM/d/yyyy H:m zzz"
       "M/dd/yy H:m zzz"; "MM/dd/yy H:m zzz"
       "M/d/yy H:m zzz"; "MM/d/yy H:m zzz"
       "M/dd/yyyy HH:mm zzz"; "MM/dd/yyyy HH:mm zzz"
       "M/d/yyyy HH:mm zzz"; "MM/d/yyyy HH:mm zzz"
       "M/dd/yy HH:mm zzz"; "MM/dd/yy HH:mm zzz"
       "M/d/yy HH:mm zzz"; "MM/d/yy HH:mm zzz"
       "M/dd/yyyy H:mm zzz"; "MM/dd/yyyy H:mm zzz"
       "M/d/yyyy H:mm zzz"; "MM/d/yyyy H:mm zzz"
       "M/dd/yy H:mm zzz"; "MM/dd/yy H:mm zzz"
       "M/d/yy H:mm zzz"; "MM/d/yy H:mm zzz" |]
let provider = CultureInfo.InvariantCulture.DateTimeFormat

while tries < 3 && result.IsNone do
    printfn "Enter a date, time, and offset (MM/DD/YYYY HH:MM +/-HH:MM),"
    printf "Then press Enter: "
    input <- stdin.ReadLine()
    printfn ""
    match DateTimeOffset.TryParseExact(input, formats, provider, DateTimeStyles.AllowWhiteSpaces) with
    | true, dto ->
        result <- Some dto
    | _ ->
        printfn $"Unable to parse {input}."
    tries <- tries + 1

match result with
| Some result ->
    printfn $"{input} was converted to {result}"
| None ->
    printfn $"Exiting application without parsing {input}"

// Some successful sample interactions with the user might appear as follows:
//    Enter a date, time, and offset (MM/DD/YYYY HH:MM +/-HH:MM),
//    Then press Enter: 12/08/2007 6:54 -6:00
//
//    12/08/2007 6:54 -6:00 was converted to 12/8/2007 6:54:00 AM -06:00
//
//    Enter a date, time, and offset (MM/DD/YYYY HH:MM +/-HH:MM),
//    Then press Enter: 12/8/2007 06:54 -06:00
//
//    12/8/2007 06:54 -06:00 was converted to 12/8/2007 6:54:00 AM -06:00
//
//    Enter a date, time, and offset (MM/DD/YYYY HH:MM +/-HH:MM),
//    Then press Enter: 12/5/07 6:54 -6:00
//
//    12/5/07 6:54 -6:00 was converted to 12/5/2007 6:54:00 AM -06:00

 Dim conIn As TextReader = Console.In
 Dim conOut As TextWriter = Console.Out
 Dim tries As Integer = 0
 Dim input As String = String.Empty
 Dim formats() As String = {"M/dd/yyyy HH:m zzz", "MM/dd/yyyy HH:m zzz", _
                            "M/d/yyyy HH:m zzz", "MM/d/yyyy HH:m zzz", _
                            "M/dd/yy HH:m zzz", "MM/dd/yy HH:m zzz", _
                            "M/d/yy HH:m zzz", "MM/d/yy HH:m zzz", _                                 
                            "M/dd/yyyy H:m zzz", "MM/dd/yyyy H:m zzz", _
                            "M/d/yyyy H:m zzz", "MM/d/yyyy H:m zzz", _
                            "M/dd/yy H:m zzz", "MM/dd/yy H:m zzz", _
                            "M/d/yy H:m zzz", "MM/d/yy H:m zzz", _                               
                            "M/dd/yyyy HH:mm zzz", "MM/dd/yyyy HH:mm zzz", _
                            "M/d/yyyy HH:mm zzz", "MM/d/yyyy HH:mm zzz", _
                            "M/dd/yy HH:mm zzz", "MM/dd/yy HH:mm zzz", _
                            "M/d/yy HH:mm zzz", "MM/d/yy HH:mm zzz", _                                 
                            "M/dd/yyyy H:mm zzz", "MM/dd/yyyy H:mm zzz", _
                            "M/d/yyyy H:mm zzz", "MM/d/yyyy H:mm zzz", _
                            "M/dd/yy H:mm zzz", "MM/dd/yy H:mm zzz", _
                            "M/d/yy H:mm zzz", "MM/d/yy H:mm zzz"}   
 Dim provider As IFormatProvider = CultureInfo.InvariantCulture.DateTimeFormat
 Dim result As DateTimeOffset

 Do 
    conOut.WriteLine("Enter a date, time, and offset (MM/DD/YYYY HH:MM +/-HH:MM),")
    conOut.Write("Then press Enter: ")
    input = conIn.ReadLine()
    conOut.WriteLine() 
    If DateTimeOffset.TryParseExact(input, formats, provider, _
                                    DateTimeStyles.AllowWhiteSpaces, _
                                    result) Then
       Exit Do
    Else
       Console.WriteLine("Unable to parse {0}.", input)      
       tries += 1
    End If
 Loop While tries < 3
 If tries >= 3 Then
    Console.WriteLine("Exiting application without parsing {0}", input)
 Else
    Console.WriteLine("{0} was converted to {1}", input, result.ToString())                                                     
 End If 
 ' Some successful sample interactions with the user might appear as follows:
 '    Enter a date, time, and offset (MM/DD/YYYY HH:MM +/-HH:MM),
 '    Then press Enter: 12/08/2007 6:54 -6:00
 '    
 '    12/08/2007 6:54 -6:00 was converted to 12/8/2007 6:54:00 AM -06:00         
 '    
 '    Enter a date, time, and offset (MM/DD/YYYY HH:MM +/-HH:MM),
 '    Then press Enter: 12/8/2007 06:54 -06:00
 '    
 '    12/8/2007 06:54 -06:00 was converted to 12/8/2007 6:54:00 AM -06:00
 '    
 '    Enter a date, time, and offset (MM/DD/YYYY HH:MM +/-HH:MM),
 '    Then press Enter: 12/5/07 6:54 -6:00
 '    
 '    12/5/07 6:54 -6:00 was converted to 12/5/2007 6:54:00 AM -06:00

Commenti

Il metodo TryParseExact(String, String[], IFormatProvider, DateTimeStyles, DateTimeOffset) analizza la rappresentazione di stringa di una data corrispondente a uno dei modelli assegnati alla matrice di formats. Se la stringa input non corrisponde a uno di questi modelli con le varianti definite dal parametro styles, l'operazione di analisi non riesce e il metodo restituisce false. Oltre a confrontare input con più stringhe che contengono identificatori di formato, questo overload si comporta in modo identico al metodo DateTimeOffset.ParseExact(String, String[], IFormatProvider, DateTimeStyles).

Il parametro formats è 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 di data e ora standard e stringhe di formato di data e ora personalizzate. Se l'elemento corrispondente in formats include l'z, zzo zzz identificatori di formato 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.

Importante

L'uso del parametro formats 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 mancano zeri iniziali in mesi, giorni, ore, minuti e secondi. Nell'esempio viene fornita un'illustrazione di questa operazione.

Se l'elemento corrispondente in formats richiede che input contengano una data ma non un'ora, all'oggetto DateTimeOffset risultante 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 DateTimeOffset risultante 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 DateTimeOffset risultante dipende dal valore del parametro styles. 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 utilizzato l'offset del fuso orario locale.

I simboli e le stringhe di data e ora specifici usati in input sono definiti dal parametro formatProvider. Lo stesso vale per il criterio preciso di input se l'elemento corrispondente di formats è una stringa di identificatore di formato standard. Il parametro formatProvider può essere uno dei seguenti:

Oggetto CultureInfo che rappresenta le impostazioni cultura in base alle quali input viene interpretato. L'oggetto DateTimeFormatInfo restituito dalla proprietà CultureInfo.DateTimeFormat 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 corrispondente alle impostazioni cultura correnti.

Il parametro styles definisce se lo spazio vuoto è consentito nella stringa di input, indica come vengono analizzate le stringhe senza un componente 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	Analizza `input` e, se necessario, lo converte in formato UTC. Equivale ad analizzare una stringa e quindi chiamare il metodo DateTimeOffset.ToUniversalTime dell'oggetto DateTimeOffset restituito.
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. Questo è 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 `input` di includere lo spazio vuoto interno non specificato 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 `input` di includere gli spazi iniziali non specificati dagli elementi in `formats`. Questi vengono ignorati durante l'analisi della stringa.
AllowTrailingWhite	Consente `input` di includere gli spazi finali non specificati dagli elementi in `formats`. Questi vengono ignorati durante l'analisi della stringa.
AllowWhiteSpaces	Consente `input` di 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. Si tratta del comportamento predefinito.
RoundtripKind	Non ha alcun effetto perché la struttura DateTimeOffset non include una proprietà `Kind`.

Note per i chiamanti

In .NET Framework 4, il TryParseExact restituisce false 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, il designatore 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 la rappresentazione di una data e di un'ora in un intervallo di caratteri nel relativo 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 un'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 su 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 il DateTimeOffset equivalente 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

Restituisce

Boolean

true se il parametro input viene 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 metodo DateTimeOffset.ParseExact(ReadOnlySpan<Char>, ReadOnlySpan<Char>, IFormatProvider, DateTimeStyles), 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 parametro format. Se input non corrisponde a questo modello, con alcune possibili variazioni nello spazio vuoto definito dal parametro styles, l'operazione di analisi ha esito negativo e il metodo restituisce false.

Il parametro format è 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 di data e ora standard e stringhe di formato di data e ora personalizzate. Se format include z, zzo zzz identificatori di formato 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 DateTimeOffset risultante viene assegnata un'ora di mezzanotte (0:00:00). Se format richiede che input contengano un'ora ma non una data, all'oggetto DateTimeOffset risultante viene assegnata la data corrente nel sistema locale. Se format non richiede che input contengano un offset, l'offset dell'oggetto DateTimeOffset risultante dipende dal valore del parametro styles. 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 utilizzato l'offset del fuso orario locale.

I simboli e le stringhe di data e ora specifici usati in input sono definiti dal parametro formatProvider. Lo stesso vale per il modello preciso di input se format è una stringa di identificatore di formato standard. Il parametro formatProvider può essere uno dei seguenti:

Oggetto CultureInfo che rappresenta le impostazioni cultura in base alle quali input viene interpretato. L'oggetto DateTimeFormatInfo restituito dalla proprietà CultureInfo.DateTimeFormat 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 corrispondente alle impostazioni cultura correnti.

membro `DateTimeStyles`	Comportamento
AdjustToUniversal	Analizza `input` e, se necessario, lo converte in formato UTC. Equivale ad analizzare una rappresentazione di data e ora e quindi a chiamare il metodo DateTimeOffset.ToUniversalTime dell'oggetto restituito DateTimeOffset.
AssumeLocal	Se `format` non richiede che `input` contenga un valore di offset, all'oggetto DateTimeOffset restituito viene assegnato l'offset del fuso orario locale. Si tratta del 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 `input` di 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 `input` di includere gli spazi iniziali non specificati da `format`. Questi vengono ignorati durante l'analisi della stringa.
AllowTrailingWhite	Consente `input` di includere gli spazi finali non specificati da `format`. Questi vengono ignorati durante l'analisi della stringa.
AllowWhiteSpaces	Consente `input` di 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`. Si tratta del comportamento predefinito.
RoundtripKind	Non ha alcun effetto, perché la struttura DateTimeOffset non include una proprietà `Kind`.

Si applica a

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

Origine:: DateTimeOffset.cs

Origine:: DateTimeOffset.cs

Origine:: DateTimeOffset.cs

Converte la rappresentazione di una data e di un'ora in un intervallo di caratteri nel relativo DateTimeOffset equivalente usando i formati, le informazioni sul formato specifiche 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 un'ora da convertire.

formats: String[]

Matrice di stringhe di formato standard o personalizzate che definiscono i formati accettabili di input.

formatProvider: IFormatProvider

Oggetto che fornisce informazioni di formattazione specifiche delle impostazioni cultura su 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 viene 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 di stringa di una data che corrisponde a uno dei modelli assegnati alla matrice formats. Se input non corrisponde a uno di questi modelli con eventuali varianti definite dal parametro styles, l'operazione di analisi ha esito negativo e il metodo restituisce false. Oltre a confrontare input con più stringhe che contengono identificatori di formato, questo overload si comporta in modo identico al metodo DateTimeOffset.ParseExact(ReadOnlySpan<Char>, String[], IFormatProvider, DateTimeStyles).

Importante

Se l'elemento corrispondente in formats richiede che input contengano una data ma non un'ora, all'oggetto DateTimeOffset risultante 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 DateTimeOffset risultante 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 DateTimeOffset risultante dipende dal valore del parametro styles. 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 utilizzato l'offset del fuso orario locale.

I simboli di data e ora specifici usati in input sono definiti dal parametro formatProvider. Lo stesso vale per il criterio preciso di input se l'elemento corrispondente di formats è una stringa di identificatore di formato standard. Il parametro formatProvider può essere uno dei seguenti:

Oggetto CultureInfo che rappresenta le impostazioni cultura in base alle quali input viene interpretato. L'oggetto DateTimeFormatInfo restituito dalla proprietà CultureInfo.DateTimeFormat 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 corrispondente alle impostazioni cultura correnti.

membro `DateTimeStyles`	Comportamento
AdjustToUniversal	Analizza `input` e, se necessario, lo converte in formato UTC. Equivale ad analizzare una stringa e quindi chiamare il metodo DateTimeOffset.ToUniversalTime dell'oggetto DateTimeOffset restituito.
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. Questo è 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 `input` di includere lo spazio vuoto interno non specificato 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 `input` di includere gli spazi iniziali non specificati dagli elementi in `formats`. Questi vengono ignorati durante l'analisi della stringa.
AllowTrailingWhite	Consente `input` di includere gli spazi finali non specificati dagli elementi in `formats`. Questi vengono ignorati durante l'analisi della stringa.
AllowWhiteSpaces	Consente `input` di 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. Si tratta del comportamento predefinito.
RoundtripKind	Non ha alcun effetto perché la struttura DateTimeOffset non include una proprietà `Kind`.

Si applica a

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

Origine:: DateTimeOffset.cs

Origine:: DateTimeOffset.cs

Origine:: DateTimeOffset.cs

Converte la rappresentazione di stringa specificata di una data e un'ora nel relativo DateTimeOffset equivalente usando il formato specificato, le informazioni sul formato specifico 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 contenente 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 su input.

styles: DateTimeStyles

Combinazione bit per bit di valori di enumerazione che indica il formato di input consentito. Un valore tipico da specificare è None.

result: DateTimeOffset

Quando termina, il metodo contiene l'DateTimeOffset equivalente 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 il parametro input è nullo non contiene una rappresentazione di stringa valida di una data e un'ora nel formato previsto definito da format e provider. Questo parametro viene passato non inizializzato.

Restituisce

Boolean

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

Eccezioni

ArgumentException

styles include un valore DateTimeStyles non definito.

-o-

NoCurrentDateDefault non è supportato.

-o-

styles include valori di DateTimeStyles che si escludono a vicenda.

Esempio

Nell'esempio seguente viene utilizzato il metodo TryParseExact(String, String, IFormatProvider, DateTimeStyles, DateTimeOffset) con identificatori di formato standard e personalizzati, le impostazioni cultura invarianti e vari valori DateTimeStyles per analizzare più 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.

L'esempio seguente usa un'ampia gamma di valori DateTimeStyles per analizzare una matrice di stringhe che devono essere 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 di DateTimeStyles appropriato, 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 legale pacifico) a meno che non venga fornito il flag DateTimeStyles.AssumeUniversal 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 metodo TryParseExact(String, String, IFormatProvider, DateTimeStyles, DateTimeOffset) è simile al metodo DateTimeOffset.ParseExact(String, String, IFormatProvider, DateTimeStyles), 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 un'ora che deve corrispondere esattamente al modello specificato dal parametro format. Se la stringa input non corrisponde a questo modello, con alcune possibili variazioni nello spazio vuoto definito dal parametro styles, l'operazione di analisi non riesce e il metodo restituisce false.

Il parametro format è 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 di data e ora standard e stringhe di formato di data e ora personalizzate. Se format include z, zzo zzz identificatori di formato 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.

Oggetto CultureInfo che rappresenta le impostazioni cultura in base alle quali input viene interpretato. L'oggetto DateTimeFormatInfo restituito dalla proprietà CultureInfo.DateTimeFormat 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 corrispondente alle impostazioni cultura correnti.

membro `DateTimeStyles`	Comportamento
AdjustToUniversal	Analizza `input` e, se necessario, lo converte in formato UTC. Equivale ad analizzare una stringa e quindi chiamare il metodo DateTimeOffset.ToUniversalTime dell'oggetto DateTimeOffset restituito.
AssumeLocal	Se `format` non richiede che `input` contenga un valore di offset, all'oggetto DateTimeOffset restituito viene assegnato l'offset del fuso orario locale. Si tratta del 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 `input` di 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 `input` di includere gli spazi iniziali non specificati da `format`. Questi vengono ignorati durante l'analisi della stringa.
AllowTrailingWhite	Consente `input` di includere gli spazi finali non specificati da `format`. Questi vengono ignorati durante l'analisi della stringa.
AllowWhiteSpaces	Consente `input` di 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`. Si tratta del comportamento predefinito.
RoundtripKind	Non ha alcun effetto, perché la struttura DateTimeOffset non include una proprietà `Kind`.

Note per i chiamanti

Vedi anche

ParseExact

Si applica a

Condividi tramite

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

Risorse aggiuntive