DateTimeOffset.TryParseExact Metodo

Origine:

DateTimeOffset.cs

Origine:

DateTimeOffset.cs

Origine:

DateTimeOffset.cs

Origine:

DateTimeOffset.cs

Origine:

DateTimeOffset.cs

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

Restituisce

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

Eccezioni

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 modelli con eventuali varianti definite dal styles parametro , l'operazione di analisi non riesce 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 possibile modello 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 gli zidentificatori di formato personalizzati zz, 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.

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 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 formatProvider parametro . Lo stesso vale per il criterio 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 DateTimeFormatInfoCultureInfo.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 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 ad eccezione NoCurrentDateDefaultdi . La tabella seguente elenca l'effetto di ogni membro supportato.

DateTimeStylesMembro	Comportamento
AdjustToUniversal	Analizza e, se necessario, lo converte input in formato UTC. Equivale ad analizzare una stringa e quindi a 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. 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 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. Si tratta del 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, il designatore AM/PM viene ignorato.

Origine:

DateTimeOffset.cs

Origine:

DateTimeOffset.cs

Origine:

DateTimeOffset.cs

Origine:

DateTimeOffset.cs

Origine:

DateTimeOffset.cs

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

Restituisce

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

Eccezioni

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 di data e ora standard e stringhe di formato di data e ora personalizzate. Se format include gli zidentificatori di formato personalizzati , zzo 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.

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 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 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 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.

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 ad eccezione NoCurrentDateDefaultdi . La tabella seguente elenca l'effetto di ogni membro supportato.

DateTimeStylesMembro	Comportamento
AdjustToUniversal	Analizza e, se necessario, lo converte input in formato UTC. Equivale ad analizzare una rappresentazione di data e ora e quindi a 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. 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 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. Si tratta del comportamento predefinito.
RoundtripKind	Non ha alcun effetto, perché la DateTimeOffset struttura non include una Kind proprietà .

Origine:

DateTimeOffset.cs

Origine:

DateTimeOffset.cs

Origine:

DateTimeOffset.cs

Origine:

DateTimeOffset.cs

Origine:

DateTimeOffset.cs

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

Restituisce

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

Eccezioni

Commenti

Questo metodo analizza la rappresentazione di stringa di una data che corrisponde 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 non riesce 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 di data e ora standard e stringhe di formato di data e ora personalizzate. Se l'elemento corrispondente in formats include gli zidentificatori di formato personalizzati zz, 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.

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 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 formatProvider parametro . Lo stesso vale per il criterio 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 DateTimeFormatInfoCultureInfo.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 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 ad eccezione NoCurrentDateDefaultdi . La tabella seguente elenca l'effetto di ogni membro supportato.

DateTimeStylesMembro	Comportamento
AdjustToUniversal	Analizza e, se necessario, lo converte input in formato UTC. Equivale ad analizzare una stringa e quindi a 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. 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 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. Si tratta del comportamento predefinito.
RoundtripKind	Non ha alcun effetto perché la DateTimeOffset struttura non include una Kind proprietà .

Origine:

DateTimeOffset.cs

Origine:

DateTimeOffset.cs

Origine:

DateTimeOffset.cs

Origine:

DateTimeOffset.cs

Origine:

DateTimeOffset.cs

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

Restituisce

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

Eccezioni

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.

L'esempio seguente usa un'ampia gamma di DateTimeStyles valori 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 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 legale pacifico) a meno che il DateTimeStyles.AssumeUniversal flag non venga fornito 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 un'ora che deve corrispondere esattamente al modello specificato dal format parametro . Se la input stringa 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 è 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 gli zidentificatori di formato personalizzati , zzo 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.

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 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 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 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.

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 ad eccezione NoCurrentDateDefaultdi . La tabella seguente elenca l'effetto di ogni membro supportato.

DateTimeStylesMembro	Comportamento
AdjustToUniversal	Analizza e, se necessario, lo converte input in formato UTC. Equivale ad analizzare una stringa e quindi a 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. 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 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. Si tratta del 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, il designatore AM/PM viene ignorato.

Vedi anche

• ParseExact