DateTimeOffset.ParseExact Metodo

Riferimento

Definizione

Spazio dei nomi:: System

Assembly:: System.Runtime.dll

Assembly:: mscorlib.dll

Assembly:: netstandard.dll

Importante

Alcune informazioni sono relative alla release non definitiva del prodotto, che potrebbe subire modifiche significative prima della release definitiva. Microsoft non riconosce alcuna garanzia, espressa o implicita, in merito alle informazioni qui fornite.

Converte una determinata rappresentazione di stringa di una data e di un'ora nell'equivalente DateTimeOffset. Il formato della rappresentazione di stringa deve corrispondere esattamente a un formato specificato.

Overload

ParseExact(String, String[], IFormatProvider, DateTimeStyles)	Converte la rappresentazione di stringa specificata di una data e di un'ora nel relativo oggetto DateTimeOffset equivalente usando i 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.
ParseExact(String, String, IFormatProvider, DateTimeStyles)	Converte una determinata rappresentazione di stringa di una data e di un'ora nell'oggetto DateTimeOffset equivalente usando il formato, le informazioni sul formato specifiche delle impostazioni cultura e lo stile specificati. Il formato della rappresentazione di stringa deve corrispondere esattamente al formato specificato.
ParseExact(String, String, IFormatProvider)	Converte una determinata rappresentazione di stringa di una data e di un'ora nel relativo oggetto DateTimeOffset equivalente usando il formato specificato e le informazioni sul formato relative alle impostazioni cultura specificate. Il formato della rappresentazione di stringa deve corrispondere esattamente al formato specificato.
ParseExact(ReadOnlySpan<Char>, ReadOnlySpan<Char>, IFormatProvider, DateTimeStyles)	Converte un intervallo di caratteri che rappresenta una data e un'ora nell'oggetto DateTimeOffset equivalente usando il formato, le informazioni sul formato specifiche delle impostazioni cultura e lo stile specificati. Il formato della rappresentazione di data e ora deve corrispondere esattamente al formato specificato.
ParseExact(ReadOnlySpan<Char>, String[], IFormatProvider, DateTimeStyles)	Converte un intervallo di caratteri che contiene la rappresentazione stringa di una data e di un'ora nel relativo oggetto 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.

ParseExact(String, String[], IFormatProvider, DateTimeStyles)

Converte la rappresentazione di stringa specificata di una data e di un'ora nel relativo oggetto DateTimeOffset equivalente usando i 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 DateTimeOffset ParseExact(System::String ^ input, cli::array <System::String ^> ^ formats, IFormatProvider ^ formatProvider, System::Globalization::DateTimeStyles styles);

public static DateTimeOffset ParseExact (string input, string[] formats, IFormatProvider formatProvider, System.Globalization.DateTimeStyles styles);

public static DateTimeOffset ParseExact (string input, string[] formats, IFormatProvider? formatProvider, System.Globalization.DateTimeStyles styles);

static member ParseExact : string * string[] * IFormatProvider * System.Globalization.DateTimeStyles -> DateTimeOffset

Public Shared Function ParseExact (input As String, formats As String(), formatProvider As IFormatProvider, styles As DateTimeStyles) As DateTimeOffset

Parametri

input: String

Stringa che contiene una data e un'ora da convertire.

formats: String[]

Matrice di identificatori di formato che definiscono i formati previsti di input.

formatProvider: IFormatProvider

Oggetto che fornisce informazioni di formattazione specifiche delle impostazioni cultura relativamente a input.

styles: DateTimeStyles

Combinazione bit per bit di valori di enumerazione che indica il formato consentito di input.

Restituisce

DateTimeOffset

Oggetto equivalente alla data e all'ora contenute nel parametro input, come specificato dai parametri formats, formatProvider e styles.

Eccezioni

ArgumentException

L'offset è maggiore di 14 ore o minore di -14 ore.

-oppure-

styles contiene un valore non supportato.

-oppure-

Il parametro styles contiene valori DateTimeStyles che non possono essere usati insieme.

ArgumentNullException

input è null.

FormatException

input è una stringa vuota ("").

-oppure-

input non contiene una rappresentazione di stringa valida per data e ora.

-oppure-

Nessun elemento di formats contiene un identificatore di formato valido.

-oppure-

Il componente relativo alle ore e l'identificatore AM/PM in input non corrispondono.

Esempio

Nell'esempio seguente vengono definiti più formati di input per la rappresentazione stringa di un valore di data e ora e offset e quindi passa la stringa immessa dall'utente al DateTimeOffset.ParseExact(String, String[], IFormatProvider, DateTimeStyles) 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 = new 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();
   try
   {
      result = DateTimeOffset.ParseExact(input, formats, provider,
                                         DateTimeStyles.AllowWhiteSpaces);
      break;
   }
   catch (FormatException)
   {
      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 input = String.Empty
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

let mutable result = None
let mutable tries = 0
while tries < 3 && result.IsNone do
    printfn "Enter a date, time, and offset (MM/DD/YYYY HH:MM +/-HH:MM),"
    printf "Then press Enter: "
    let input = stdin.ReadLine()
    printfn ""
    try
        result <- 
            DateTimeOffset.ParseExact(input, formats, provider, DateTimeStyles.AllowWhiteSpaces) 
            |> Some
    with :? FormatException ->
        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() 
    Try
       result = DateTimeOffset.ParseExact(input, formats, provider, _
                                          DateTimeStyles.AllowWhiteSpaces)
       Exit Do
    Catch e As FormatException
       Console.WriteLine("Unable to parse {0}.", input)      
       tries += 1
    End Try
 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 DateTimeOffset.ParseExact(String, String[], IFormatProvider, DateTimeStyles) metodo analizza la rappresentazione stringa di una data corrispondente a uno dei modelli assegnati al formats parametro. Se la input stringa non corrisponde a uno di questi modelli con una delle varianti definite dal styles parametro, il metodo genera un FormatExceptionoggetto . A parte il confronto input con più modelli di formattazione, 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 del input parametro. Quando viene chiamato il metodo, input deve corrispondere a uno di questi modelli. Per informazioni dettagliate sui codici di formattazione validi, vedere Stringhe di formato data e ora standard e stringhe di formato data e ora personalizzate. Se l'elemento corrispondente in formats include gli zidentificatori di formato , zzo zzz personalizzati per indicare che un offset deve essere presente in input, tale offset deve includere un segno negativo o un segno positivo. Se il segno manca, il metodo genera un FormatExceptionoggetto .

Importante

L'uso del parametro di questo overload per specificare più formati può aiutare a ridurre la frustrazione di molti utenti durante l'immissione formats di date e ore. In particolare, la possibilità di definire più modelli di input consente a un'applicazione di gestire rappresentazioni di data e ora che possono includere o mancanza di zero iniziali in mesi, giorni, ore, minuti e secondi. L'esempio fornisce un'illustrazione di questo oggetto.

Se l'elemento corrispondente in formats richiede che input contenga una data ma non un'ora, l'oggetto risultante DateTimeOffset viene assegnato un'ora di mezzanotte (0:00:00). Se l'elemento corrispondente in formats richiede che input contenga un'ora ma non una data, l'oggetto risultante DateTimeOffset viene assegnato alla 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 usato l'offset del fuso orario locale.

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

Oggetto CultureInfo che rappresenta le impostazioni cultura basate su cui input viene interpretato. L'oggetto DateTimeFormatInfo CultureInfo.DateTimeFormat restituito dalla proprietà definisce i simboli e la formattazione in input.
Oggetto DateTimeFormatInfo che definisce il formato dei dati di data e ora.

Se formatprovider è null, viene usato l'oggetto CultureInfo corrispondente alle impostazioni cultura correnti.

Il styles parametro definisce se lo spazio vuoto è consentito nella stringa di input, indica come vengono analizzate le stringhe senza un componente di offset esplicito e supporta la conversione UTC come parte dell'operazione di analisi. Tutti i membri dell'enumerazione DateTimeStyles sono supportati tranne NoCurrentDateDefault. La tabella seguente elenca l'effetto di ogni membro supportato.

Membro`DateTimeStyles`	Comportamento
AdjustToUniversal	Analizza e, se necessario, lo converte `input` in UTC. Equivale a analizzare una stringa e quindi chiamare il DateTimeOffset.ToUniversalTime metodo dell'oggetto restituito DateTimeOffset .
AssumeLocal	Se l'elemento corrispondente in `formats` non richiede che `input` contenga un valore di offset, l'oggetto restituito DateTimeOffset viene assegnato l'offset del fuso orario locale. Rappresenta il valore predefinito.
AssumeUniversal	Se l'elemento corrispondente in `formats` non richiede che `input` contenga un valore di offset, l'oggetto restituito DateTimeOffset viene assegnato all'offset UTC (+00:00).
AllowInnerWhite	Consente di `input` includere spazi vuoti interni non specificati da `format`. Lo spazio vuoto aggiuntivo può essere visualizzato tra componenti di data e ora e all'interno di singoli componenti (ad eccezione dell'offset) e viene ignorato durante l'analisi della stringa.
AllowLeadingWhite	Consente di `input` includere spazi iniziali non specificati da `formats`. Questi vengono ignorati durante l'analisi della stringa.
AllowTrailingWhite	Consente di `input` includere spazi finali non specificati da `formats`. Questi vengono ignorati durante l'analisi della stringa.
AllowWhiteSpaces	Consente di `input` includere spazi iniziali, finali e interni non specificati da `formats`. Tutti i caratteri di spazio vuoto aggiuntivi non specificati nell'elemento corrispondente in `formats` vengono ignorati durante l'analisi della stringa.
None	Indica che lo spazio vuoto aggiuntivo non è consentito in `input`. Lo spazio vuoto deve essere visualizzato esattamente come specificato in un particolare elemento di `formats` per che si verifichi una corrispondenza. Comportamento predefinito.
RoundtripKind	Non ha alcun effetto perché la DateTimeOffset struttura non include una `Kind` proprietà.

Note per i chiamanti

In .NET Framework 4 il ParseExact metodo genera un valore se la stringa da analizzare contiene un FormatException componente ora e un designatore AM/PM non in accordo. Nelle versioni precedenti e .NET Framework 3.5 viene ignorato il designatore AM/PM.

Vedi anche

Si applica a

ParseExact(String, String, IFormatProvider, DateTimeStyles)

Converte una determinata rappresentazione di stringa di una data e di un'ora nell'oggetto DateTimeOffset equivalente usando il formato, le informazioni sul formato specifiche delle impostazioni cultura e lo stile specificati. Il formato della rappresentazione di stringa deve corrispondere esattamente al formato specificato.

public:
 static DateTimeOffset ParseExact(System::String ^ input, System::String ^ format, IFormatProvider ^ formatProvider, System::Globalization::DateTimeStyles styles);

public static DateTimeOffset ParseExact (string input, string format, IFormatProvider formatProvider, System.Globalization.DateTimeStyles styles);

public static DateTimeOffset ParseExact (string input, string format, IFormatProvider? formatProvider, System.Globalization.DateTimeStyles styles);

static member ParseExact : string * string * IFormatProvider * System.Globalization.DateTimeStyles -> DateTimeOffset

Public Shared Function ParseExact (input As String, format As String, formatProvider As IFormatProvider, styles As DateTimeStyles) As DateTimeOffset

Parametri

input: String

Stringa che contiene una data e un'ora da convertire.

format: String

Identificatore di formato che definisce il formato previsto di input.

formatProvider: IFormatProvider

Oggetto che fornisce informazioni di formattazione specifiche delle impostazioni cultura relativamente a input.

styles: DateTimeStyles

Combinazione bit per bit di valori di enumerazione che indica il formato consentito di input.

Restituisce

DateTimeOffset

Oggetto equivalente alla data e all'ora contenute nel parametro input, come specificato dai parametri format, formatProvider e styles.

Eccezioni

ArgumentException

L'offset è maggiore di 14 ore o minore di -14 ore.

-oppure-

Il parametro styles include un valore non supportato.

-oppure-

Il parametro styles contiene valori DateTimeStyles che non possono essere usati insieme.

ArgumentNullException

input è null.

-oppure-

format è null.

FormatException

input è una stringa vuota ("").

-oppure-

input non contiene una rappresentazione di stringa valida per data e ora.

-oppure-

Il parametro format è una stringa vuota.

-oppure-

Il componente relativo alle ore e l'identificatore AM/PM in input non corrispondono.

Esempio

Nell'esempio seguente viene usato il DateTimeOffset.ParseExact(String, String, IFormatProvider, DateTimeStyles) 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;
CultureInfo provider = CultureInfo.InvariantCulture;

// Parse date-only value with invariant culture and assume time is UTC.
dateString = "06/15/2008";
format = "d";
try
{
   result = DateTimeOffset.ParseExact(dateString, format, provider,
                                      DateTimeStyles.AssumeUniversal);
   Console.WriteLine("'{0}' converts to {1}.", dateString, result.ToString());
}
catch (FormatException)
{
   Console.WriteLine("'{0}' is not in the correct format.", dateString);
}

// Parse date-only value with leading white space.
// Should throw a FormatException because only trailing white space is
// specified in method call.
dateString = " 06/15/2008";
try
{
   result = DateTimeOffset.ParseExact(dateString, format, provider,
                                      DateTimeStyles.AllowTrailingWhite);
   Console.WriteLine("'{0}' converts to {1}.", dateString, result.ToString());
}
catch (FormatException)
{
   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";
try
{
   result = DateTimeOffset.ParseExact(dateString, format, provider,
                                      DateTimeStyles.AllowWhiteSpaces);
   Console.WriteLine("'{0}' converts to {1}.", dateString, result.ToString());
}
catch (FormatException)
{
   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";
try
{
   result = DateTimeOffset.ParseExact(dateString, format, provider,
                                      DateTimeStyles.AllowWhiteSpaces |
                                      DateTimeStyles.AdjustToUniversal);
   Console.WriteLine("'{0}' converts to {1}.", dateString, result.ToString());
}
catch (FormatException)
{
   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"
try
    let result = DateTimeOffset.ParseExact(dateString, format, provider, DateTimeStyles.AssumeUniversal)
    printfn $"'{dateString}' converts to {result}."
with :? FormatException ->
    printfn $"'{dateString}' is not in the correct format."

// Parse date-only value with leading white space.
// Should throw a FormatException because only trailing white space is
// specified in method call.
let dateString = " 06/15/2008"
try
    let result = DateTimeOffset.ParseExact(dateString, format, provider, DateTimeStyles.AllowTrailingWhite)
    printfn $"'{dateString}' converts to {result}."
with :? FormatException ->
    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"
try
    let result = DateTimeOffset.ParseExact(dateString, format, provider, DateTimeStyles.AllowWhiteSpaces)
    printfn $"'{dateString}' converts to {result}."
with :? FormatException ->
    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"
try
    let result = 
        DateTimeOffset.ParseExact(dateString, format, provider,
                                  DateTimeStyles.AllowWhiteSpaces |||
                                  DateTimeStyles.AdjustToUniversal)
    printfn $"'{dateString}' converts to {result}."
with :? FormatException ->
    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"
Try
   result = DateTimeOffset.ParseExact(dateString, format, provider, _
                                      DateTimeStyles.AssumeUniversal)
   Console.WriteLine("'{0}' converts to {1}.", dateString, result.ToString())
Catch e As FormatException
   Console.WriteLine("'{0}' is not in the correct format.", dateString)
End Try 

' Parse date-only value with leading white space.
' Should throw a FormatException because only trailing white space is  
' specified in method call.
dateString = " 06/15/2008"
Try
   result = DateTimeOffset.ParseExact(dateString, format, provider, _
                                      DateTimeStyles.AllowTrailingWhite)
   Console.WriteLine("'{0}' converts to {1}.", dateString, result.ToString())
Catch e As FormatException
   Console.WriteLine("'{0}' is not in the correct format.", dateString)
End Try 

' 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"
Try
   result = DateTimeOffset.ParseExact(dateString, format, provider, _
                                      DateTimeStyles.AllowWhiteSpaces)
   Console.WriteLine("'{0}' converts to {1}.", dateString, result.ToString())
Catch e As FormatException
   Console.WriteLine("'{0}' is not in the correct format.", dateString)
End Try 

' 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"       
Try
   result = DateTimeOffset.ParseExact(dateString, format, provider, _
                                      DateTimeStyles.AllowWhiteSpaces Or _
                                      DateTimeStyles.AdjustToUniversal)
   Console.WriteLine("'{0}' converts to {1}.", dateString, result.ToString())
Catch e As FormatException
   Console.WriteLine("'{0}' is not in the correct format.", dateString)
End Try 
' The example displays the following output:
'    '06/15/2008' converts to 6/15/2008 12:00:00 AM +00:00.
'    ' 06/15/2008' is not in the correct format.
'    ' 06/15/   2008  15:15    -05:00' converts to 6/15/2008 3:15:00 PM -05:00.
'    '  06/15/2008 15:15:30 -05:00' converts to 6/15/2008 8:15:30 PM +00:00.

Nell'esempio seguente viene usata un'ampia gamma di valori per analizzare una matrice di DateTimeStyles stringhe che devono essere conformi a ISO 8601. Come illustrato dall'output dell'esempio, le stringhe nel formato corretto non riescono a 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) a meno che non venga fornito il DateTimeStyles.AssumeUniversal flag nella chiamata al metodo. In tal caso, si presuppone che siano tempo coordinata universale.

module parseexact_iso8601_2

open System
open System.Globalization

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" |] 

let parseWithISO8601 dateStrings styles =
    printfn $"Parsing with {styles}:"
    for dateString in dateStrings do
        try
            let date = DateTimeOffset.ParseExact(dateString, "O", null, styles)
            printfn $"""   {dateString,-35} --> {date.ToString "yyyy-MM-dd HH:mm:ss.FF zzz"}"""
        with :? FormatException ->
            printfn $"   FormatException: Unable to convert '{dateString}'"

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
//         FormatException: Unable to convert '2018/08/18T12:45:16.0000000Z'
//         FormatException: Unable to convert '2018-18-08T12:45:16.0000000Z'
//         2018-08-18T12:45:16.0000000         --> 2018-08-18 12:45:16 -07:00
//         FormatException: 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
//         FormatException: Unable to convert '2018/08/18T12:45:16.0000000Z'
//         FormatException: 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
//         FormatException: Unable to convert '2018/08/18T12:45:16.0000000Z'
//         FormatException: Unable to convert '2018-18-08T12:45:16.0000000Z'
//         2018-08-18T12:45:16.0000000         --> 2018-08-18 19:45:16 +00:00
//         FormatException: 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
//         FormatException: Unable to convert '2018/08/18T12:45:16.0000000Z'
//         FormatException: Unable to convert '2018-18-08T12:45:16.0000000Z'
//         2018-08-18T12:45:16.0000000         --> 2018-08-18 12:45:16 -07:00
//         FormatException: 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
//         FormatException: Unable to convert '2018/08/18T12:45:16.0000000Z'
//         FormatException: Unable to convert '2018-18-08T12:45:16.0000000Z'
//         2018-08-18T12:45:16.0000000         --> 2018-08-18 12:45:16 +00:00
//         FormatException: 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}:");
      foreach (var dateString in dateStrings)
      {
         try {
            var date = DateTimeOffset.ParseExact(dateString, "O", null, styles);
            Console.WriteLine($"   {dateString,-35} --> {date:yyyy-MM-dd HH:mm:ss.FF zzz}");
         }
         catch (FormatException)
         {
            Console.WriteLine($"   FormatException: 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
//         FormatException: Unable to convert '2018/08/18T12:45:16.0000000Z'
//         FormatException: Unable to convert '2018-18-08T12:45:16.0000000Z'
//         2018-08-18T12:45:16.0000000         --> 2018-08-18 12:45:16 -07:00
//         FormatException: 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
//         FormatException: Unable to convert '2018/08/18T12:45:16.0000000Z'
//         FormatException: 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
//         FormatException: Unable to convert '2018/08/18T12:45:16.0000000Z'
//         FormatException: Unable to convert '2018-18-08T12:45:16.0000000Z'
//         2018-08-18T12:45:16.0000000         --> 2018-08-18 19:45:16 +00:00
//         FormatException: 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
//         FormatException: Unable to convert '2018/08/18T12:45:16.0000000Z'
//         FormatException: Unable to convert '2018-18-08T12:45:16.0000000Z'
//         2018-08-18T12:45:16.0000000         --> 2018-08-18 12:45:16 -07:00
//         FormatException: 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
//         FormatException: Unable to convert '2018/08/18T12:45:16.0000000Z'
//         FormatException: Unable to convert '2018-18-08T12:45:16.0000000Z'
//         2018-08-18T12:45:16.0000000         --> 2018-08-18 12:45:16 +00:00
//         FormatException: 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}:")
      For Each dateStr In dateStrings
         Try 
            Dim dat = DateTimeOffset.ParseExact(dateString, "O", Nothing, styles)
            Console.WriteLine($"   {dateString,-35} --> {dat:yyyy-MM-dd HH:mm:ss.FF zzz}")
         catch e As FormatException
            Console.WriteLine($"   FormatException: Unable to convert '{dateString}'")
         End Try   
      Next 
   End Sub
End Module
' The example displays the following output:
'      Parsing with None:
'         FormatException: Unable to convert '07-30-2018'
'         FormatException: Unable to convert '07-30-2018'
'         FormatException: Unable to convert '07-30-2018'
'         FormatException: Unable to convert '07-30-2018'
'         FormatException: Unable to convert '07-30-2018'
'         FormatException: Unable to convert '07-30-2018'
'         FormatException: Unable to convert '07-30-2018'
'
'      -----
'
'      Parsing with AllowWhiteSpaces:
'         FormatException: Unable to convert '07-30-2018'
'         FormatException: Unable to convert '07-30-2018'
'         FormatException: Unable to convert '07-30-2018'
'         FormatException: Unable to convert '07-30-2018'
'         FormatException: Unable to convert '07-30-2018'
'         FormatException: Unable to convert '07-30-2018'
'         FormatException: Unable to convert '07-30-2018'
'
'      -----
'
'      Parsing with AdjustToUniversal:
'         FormatException: Unable to convert '07-30-2018'
'         FormatException: Unable to convert '07-30-2018'
'         FormatException: Unable to convert '07-30-2018'
'         FormatException: Unable to convert '07-30-2018'
'         FormatException: Unable to convert '07-30-2018'
'         FormatException: Unable to convert '07-30-2018'
'         FormatException: Unable to convert '07-30-2018'
'
'      -----
'
'      Parsing with AssumeLocal:
'         FormatException: Unable to convert '07-30-2018'
'         FormatException: Unable to convert '07-30-2018'
'         FormatException: Unable to convert '07-30-2018'
'         FormatException: Unable to convert '07-30-2018'
'         FormatException: Unable to convert '07-30-2018'
'         FormatException: Unable to convert '07-30-2018'
'         FormatException: Unable to convert '07-30-2018'
'
'      -----
'
'      Parsing with AssumeUniversal:
'         FormatException: Unable to convert '07-30-2018'
'         FormatException: Unable to convert '07-30-2018'
'         FormatException: Unable to convert '07-30-2018'
'         FormatException: Unable to convert '07-30-2018'
'         FormatException: Unable to convert '07-30-2018'
'         FormatException: Unable to convert '07-30-2018'
'         FormatException: Unable to convert '07-30-2018'

Commenti

Il DateTimeOffset.ParseExact(String, String, IFormatProvider, DateTimeStyles) metodo analizza la rappresentazione stringa di una data, che deve essere nel formato definito dal format parametro. Richiede inoltre che gli <Date>elementi , <Time>e <Offset> della rappresentazione stringa di una data e dell'ora vengano visualizzati nell'ordine specificato da format. Se la input stringa non corrisponde al modello del format parametro, con eventuali varianti definite dal styles parametro, il metodo genera un FormatExceptionoggetto . Al contrario, il DateTimeOffset.Parse(String, IFormatProvider, DateTimeStyles) metodo analizza la rappresentazione stringa di una data in uno dei formati riconosciuti dall'oggetto del DateTimeFormatInfo provider di formato. Parse consente inoltre agli <Date>elementi , <Time>e <Offset> della rappresentazione stringa di una data e dell'ora di visualizzare in qualsiasi ordine.

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 del input parametro. Per informazioni dettagliate sui codici di formattazione validi, vedere Stringhe di formato data e ora standard e stringhe di formato data e ora personalizzate. Se format include gli zidentificatori di formato , zzo zzz personalizzati per indicare che un offset deve essere presente in input, tale offset deve includere un segno negativo o un segno positivo. Se il segno manca, il metodo genera un FormatExceptionoggetto .

Se format è necessario che input contengano una data ma non un'ora, l'oggetto risultante DateTimeOffset viene assegnato un'ora di mezzanotte (0:00:00). Se format è necessario che input contengano un'ora ma non una data, l'oggetto risultante DateTimeOffset viene assegnato alla data corrente nel sistema locale. Se format non richiede che input contengano un offset, l'offset dell'oggetto risultante DateTimeOffset dipende dal valore del styles parametro. Se styles include AssumeLocal, l'offset del fuso orario locale viene assegnato all'oggetto DateTimeOffset . Se styles include AssumeUniversal, l'offset UTC (Coordinated Universal Time) o +00:00, viene assegnato all'oggetto DateTimeOffset . Se non viene specificato alcun valore, viene usato l'offset del fuso orario locale.

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

Oggetto CultureInfo che rappresenta le impostazioni cultura basate su cui input viene interpretato. L'oggetto DateTimeFormatInfo CultureInfo.DateTimeFormat restituito dalla proprietà definisce i simboli e la formattazione in input.
Oggetto DateTimeFormatInfo che definisce il formato dei dati di data e ora.

Se formatprovider è null, viene usato l'oggetto CultureInfo corrispondente alle impostazioni cultura correnti.

Membro`DateTimeStyles`	Comportamento
AdjustToUniversal	Analizza e, se necessario, lo converte `input` in UTC. Equivale a analizzare una stringa e quindi chiamare il DateTimeOffset.ToUniversalTime metodo dell'oggetto restituito DateTimeOffset .
AssumeLocal	Se `format` non richiede che `input` contenga un valore di offset, l'oggetto restituito DateTimeOffset viene assegnato all'offset del fuso orario locale. Rappresenta il valore predefinito.
AssumeUniversal	Se `format` non è necessario che `input` contenga un valore di offset, l'oggetto restituito DateTimeOffset viene assegnato all'offset UTC (+00:00).
AllowInnerWhite	Consente di `input` includere spazi vuoti interni non specificati da `format`. Lo spazio vuoto aggiuntivo può essere visualizzato tra componenti di data e ora e all'interno di singoli componenti e viene ignorato durante l'analisi della stringa.
AllowLeadingWhite	Consente di `input` includere spazi iniziali non specificati da `format`. Questi vengono ignorati durante l'analisi della stringa.
AllowTrailingWhite	Consente di `input` includere spazi finali non specificati da `format`. Questi vengono ignorati durante l'analisi della stringa.
AllowWhiteSpaces	Consente di `input` includere spazi iniziali, finali e interni non specificati da `format`. Tutti i caratteri di spazio vuoto aggiuntivi non specificati in `format` vengono ignorati durante l'analisi della stringa.
None	Indica che lo spazio vuoto aggiuntivo non è consentito in `input`. Lo spazio vuoto deve essere visualizzato esattamente come specificato in `format`. Comportamento predefinito.
RoundtripKind	Non ha alcun effetto perché la DateTimeOffset struttura non include una `Kind` proprietà.

Note per i chiamanti

Vedi anche

Si applica a

ParseExact(String, String, IFormatProvider)

Converte una determinata rappresentazione di stringa di una data e di un'ora nel relativo oggetto DateTimeOffset equivalente usando il formato specificato e le informazioni sul formato relative alle impostazioni cultura specificate. Il formato della rappresentazione di stringa deve corrispondere esattamente al formato specificato.

public:
 static DateTimeOffset ParseExact(System::String ^ input, System::String ^ format, IFormatProvider ^ formatProvider);

public static DateTimeOffset ParseExact (string input, string format, IFormatProvider formatProvider);

public static DateTimeOffset ParseExact (string input, string format, IFormatProvider? formatProvider);

static member ParseExact : string * string * IFormatProvider -> DateTimeOffset

Public Shared Function ParseExact (input As String, format As String, formatProvider As IFormatProvider) As DateTimeOffset

Parametri

input: String

Stringa che contiene una data e un'ora da convertire.

format: String

Identificatore di formato che definisce il formato previsto di input.

formatProvider: IFormatProvider

Oggetto che fornisce informazioni di formattazione specifiche delle impostazioni cultura relativamente a input.

Restituisce

DateTimeOffset

Oggetto equivalente alla data e all'ora contenute in input come specificato da format e formatProvider.

Eccezioni

ArgumentException

L'offset è maggiore di 14 ore o minore di -14 ore.

ArgumentNullException

input è null.

-oppure-

format è null.

FormatException

input è una stringa vuota ("").

-oppure-

input non contiene una rappresentazione di stringa valida per data e ora.

-oppure-

Il parametro format è una stringa vuota.

-oppure-

Il componente relativo alle ore e l'identificatore AM/PM in input non corrispondono.

Esempio

Nell'esempio seguente viene usato il DateTimeOffset.ParseExact(String, String, IFormatProvider) metodo con identificatori di formato standard e personalizzati e le impostazioni cultura invarianti per analizzare diverse stringhe di data e ora.

string dateString, format;
DateTimeOffset result;
CultureInfo provider = CultureInfo.InvariantCulture;

// Parse date-only value with invariant culture.
dateString = "06/15/2008";
format = "d";
try
{
   result = DateTimeOffset.ParseExact(dateString, format, provider);
   Console.WriteLine("{0} converts to {1}.", dateString, result.ToString());
}
catch (FormatException)
{
   Console.WriteLine("{0} is not in the correct format.", dateString);
}

// Parse date-only value without leading zero in month using "d" format.
// Should throw a FormatException because standard short date pattern of
// invariant culture requires two-digit month.
dateString = "6/15/2008";
try
{
   result = DateTimeOffset.ParseExact(dateString, format, provider);
   Console.WriteLine("{0} converts to {1}.", dateString, result.ToString());
}
catch (FormatException)
{
   Console.WriteLine("{0} is not in the correct format.", dateString);
}

// Parse date and time with custom specifier.
dateString = "Sun 15 Jun 2008 8:30 AM -06:00";
format = "ddd dd MMM yyyy h:mm tt zzz";
try
{
   result = DateTimeOffset.ParseExact(dateString, format, provider);
   Console.WriteLine("{0} converts to {1}.", dateString, result.ToString());
}
catch (FormatException)
{
   Console.WriteLine("{0} is not in the correct format.", dateString);
}

// Parse date and time with offset without offset//s minutes.
// Should throw a FormatException because "zzz" specifier requires leading
// zero in hours.
dateString = "Sun 15 Jun 2008 8:30 AM -06";
try
{
   result = DateTimeOffset.ParseExact(dateString, format, provider);
   Console.WriteLine("{0} converts to {1}.", dateString, result.ToString());
}
catch (FormatException)
{
   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 -07:00.
//    6/15/2008 is not in the correct format.
//    Sun 15 Jun 2008 8:30 AM -06:00 converts to 6/15/2008 8:30:00 AM -06:00.
//    Sun 15 Jun 2008 8:30 AM -06 is not in the correct format.

let provider = CultureInfo.InvariantCulture

// Parse date-only value with invariant culture.
let dateString = "06/15/2008"
let format = "d"
try
    let result = DateTimeOffset.ParseExact(dateString, format, provider)
    printfn $"{dateString} converts to {result}."
with :? FormatException ->
    printfn $"{dateString} is not in the correct format."

// Parse date-only value without leading zero in month using "d" format.
// Should throw a FormatException because standard short date pattern of
// invariant culture requires two-digit month.
let dateString = "6/15/2008"
try
    let result = DateTimeOffset.ParseExact(dateString, format, provider)
    printfn $"{dateString} converts to {result}."
with :? FormatException ->
    printfn $"{dateString} is not in the correct format."

// Parse date and time with custom specifier.
let dateString = "Sun 15 Jun 2008 8:30 AM -06:00"
let format = "ddd dd MMM yyyy h:mm tt zzz"
try
    let result = DateTimeOffset.ParseExact(dateString, format, provider)
    printfn $"{dateString} converts to {result}."
with :? FormatException ->
    printfn $"{dateString} is not in the correct format."

// Parse date and time with offset without offset//s minutes.
// Should throw a FormatException because "zzz" specifier requires leading
// zero in hours.
let dateString = "Sun 15 Jun 2008 8:30 AM -06"
try
    let result = DateTimeOffset.ParseExact(dateString, format, provider)
    printfn $"{dateString} converts to {result}."
with :? FormatException ->
    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 -07:00.
//    6/15/2008 is not in the correct format.
//    Sun 15 Jun 2008 8:30 AM -06:00 converts to 6/15/2008 8:30:00 AM -06:00.
//    Sun 15 Jun 2008 8:30 AM -06 is not in the correct format.

Dim dateString, format As String  
Dim result As DateTimeOffset
Dim provider As CultureInfo = CultureInfo.InvariantCulture

' Parse date-only value with invariant culture.
dateString = "06/15/2008"
format = "d"
Try
   result = DateTimeOffset.ParseExact(dateString, format, provider)
   Console.WriteLine("{0} converts to {1}.", dateString, result.ToString())
Catch e As FormatException
   Console.WriteLine("{0} is not in the correct format.", dateString)
End Try 

' Parse date-only value without leading zero in month using "d" format.
' Should throw a FormatException because standard short date pattern of 
' invariant culture requires two-digit month.
dateString = "6/15/2008"
Try
   result = DateTimeOffset.ParseExact(dateString, format, provider)
   Console.WriteLine("{0} converts to {1}.", dateString, result.ToString())
Catch e As FormatException
   Console.WriteLine("{0} is not in the correct format.", dateString)
End Try 

' Parse date and time with custom specifier.
dateString = "Sun 15 Jun 2008 8:30 AM -06:00"
format = "ddd dd MMM yyyy h:mm tt zzz"        
Try
   result = DateTimeOffset.ParseExact(dateString, format, provider)
   Console.WriteLine("{0} converts to {1}.", dateString, result.ToString())
Catch e As FormatException
   Console.WriteLine("{0} is not in the correct format.", dateString)
End Try 

' Parse date and time with offset without offset's minutes.
' Should throw a FormatException because "zzz" specifier requires leading  
' zero in hours.
dateString = "Sun 15 Jun 2008 8:30 AM -06"
Try
   result = DateTimeOffset.ParseExact(dateString, format, provider)
   Console.WriteLine("{0} converts to {1}.", dateString, result.ToString())
Catch e As FormatException
   Console.WriteLine("{0} is not in the correct format.", dateString)
End Try 
' The example displays the following output:
'    06/15/2008 converts to 6/15/2008 12:00:00 AM -07:00.
'    6/15/2008 is not in the correct format.
'    Sun 15 Jun 2008 8:30 AM -06:00 converts to 6/15/2008 8:30:00 AM -06:00.
'    Sun 15 Jun 2008 8:30 AM -06 is not in the correct format.

Nell'esempio seguente viene analizzata una matrice di stringhe conformi a ISO 8601. Come illustrato nell'output dell'esempio, le stringhe con spazi iniziali o finali non vengono analizzate correttamente, come le stringhe con elementi di data e ora non compresi nell'intervallo.

module parseexact_iso8601

open System

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.0000000Z "
      "2018-08-18T12:45:16.0000000+02:00"
      "2018-08-18T12:45:16.0000000-07:00" ]

for dateString in dateStrings do
    try
        let date =
            DateTimeOffset.ParseExact(dateString, "O", null)

        printfn $"""{dateString, -35} --> {date.ToString "yyyy-MM-dd HH:mm:ss.FF zzz"}"""
    with :? FormatException -> printfn $"FormatException: Unable to convert '{dateString}'"


// The example displays the following output:
//      2018-08-18T12:45:16.0000000Z        --> 2018-08-18 12:45:16 +00:00
//      FormatException: Unable to convert '2018/08/18T12:45:16.0000000Z'
//      FormatException: Unable to convert '2018-18-08T12:45:16.0000000Z'
//      FormatException: 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;

public class Example2
{
   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.0000000Z ",
                               "2018-08-18T12:45:16.0000000+02:00",
                               "2018-08-18T12:45:16.0000000-07:00" }; 
      
      foreach (var dateString in dateStrings)
      {
         try {
            var date = DateTimeOffset.ParseExact(dateString, "O", null);
            Console.WriteLine($"{dateString,-35} --> {date:yyyy-MM-dd HH:mm:ss.FF zzz}");
         }
         catch (FormatException)
         {
            Console.WriteLine($"FormatException: Unable to convert '{dateString}'");
         }   
      } 
   }
}
// The example displays the following output:
//      2018-08-18T12:45:16.0000000Z        --> 2018-08-18 12:45:16 +00:00
//      FormatException: Unable to convert '2018/08/18T12:45:16.0000000Z'
//      FormatException: Unable to convert '2018-18-08T12:45:16.0000000Z'
//      FormatException: 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

Public Module Example
   Public Sub Main()
      Dim dateStrings() As String = { "2018-08-18T12:45:16.0000000Z",
                                      "2018/08/18T12:45:16.0000000Z",
                                      "2018-18-08T12:45:16.0000000Z",
                                      " 2018-08-18T12:45:16.0000000Z ",
                                      "2018-08-18T12:45:16.0000000+02:00",
                                      "2018-08-18T12:45:16.0000000-07:00" } 
      
      For Each dateStr In dateStrings
         Try 
            Dim dat = DateTimeOffset.ParseExact(dateStr, "O", Nothing)
            Console.WriteLine($"{dateStr,-35} --> {dat:yyyy-MM-dd HH:mm:ss.FF zzz}")
         Catch  e As FormatException
            Console.WriteLine($"FormatException: Unable to convert '{dateStr}'")
         End Try   
      Next 
   End Sub
End Module
' The example displays the following output:
'      2018-08-18T12:45:16.0000000Z        --> 2018-08-18 12:45:16 +00:00
'      FormatException: Unable to convert '2018/08/18T12:45:16.0000000Z'
'      FormatException: Unable to convert '2018-18-08T12:45:16.0000000Z'
'      FormatException: 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

Il ParseExact(String, String, IFormatProvider) metodo analizza la rappresentazione di stringa di una data, che deve essere nel formato definito dal format parametro . È inoltre necessario che gli <Date>elementi , <Time>e <Offset> della rappresentazione di stringa di una data e dell'ora vengano visualizzati nell'ordine specificato da format. Se la input stringa non corrisponde a questo format parametro, il metodo genera un'eccezione FormatException. Al contrario, il DateTimeOffset.Parse(String, IFormatProvider) metodo analizza la rappresentazione di stringa di una data in uno dei formati riconosciuti dall'oggetto del provider di DateTimeFormatInfo formato. Parse consente inoltre agli <Date>elementi , <Time>e <Offset> della rappresentazione di stringa di una data e dell'ora di essere visualizzati in qualsiasi ordine.

Il format parametro è una stringa che contiene un singolo identificatore di formato standard o uno o più identificatori di formato personalizzati che definiscono il formato richiesto del input parametro. Per informazioni dettagliate sui codici di formattazione validi, vedere Stringhe di formato data e ora standard e stringhe di formato di data e ora personalizzate. Se format include gli zidentificatori di formato , zzo zzz personalizzati per indicare che un offset deve essere presente in input, tale offset deve includere un segno negativo o un segno positivo. Se il segno non è presente, il metodo genera un'eccezione FormatException.

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, all'oggetto risultante DateTimeOffset viene assegnata la differenza di fuso orario del sistema locale.

I simboli e le stringhe di data e ora specifici utilizzati in input sono definiti dal formatProvider parametro , così come è il formato 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 relativa DateTimeFormat proprietà definisce i simboli e la formattazione in input.
Oggetto DateTimeFormatInfo che definisce il formato dei dati di data e ora.

Se formatprovider è null, viene utilizzato l'oggetto CultureInfo che corrisponde alle impostazioni cultura correnti.

Note per i chiamanti

In .NET Framework 4 il ParseExact metodo genera un'eccezione FormatException se la stringa da analizzare contiene un componente di ora e un designatore AM/PM che non sono in accordo. In .NET Framework 3.5 e versioni precedenti, l'iniziatore AM/PM viene ignorato.

Vedi anche

Si applica a

ParseExact(ReadOnlySpan<Char>, ReadOnlySpan<Char>, IFormatProvider, DateTimeStyles)

Converte un intervallo di caratteri che rappresenta una data e un'ora nell'oggetto DateTimeOffset equivalente usando il formato, le informazioni sul formato specifiche delle impostazioni cultura e lo stile specificati. Il formato della rappresentazione di data e ora deve corrispondere esattamente al formato specificato.

public static DateTimeOffset ParseExact (ReadOnlySpan<char> input, ReadOnlySpan<char> format, IFormatProvider? formatProvider, System.Globalization.DateTimeStyles styles = System.Globalization.DateTimeStyles.None);

public static DateTimeOffset ParseExact (ReadOnlySpan<char> input, ReadOnlySpan<char> format, IFormatProvider formatProvider, System.Globalization.DateTimeStyles styles = System.Globalization.DateTimeStyles.None);

static member ParseExact : ReadOnlySpan<char> * ReadOnlySpan<char> * IFormatProvider * System.Globalization.DateTimeStyles -> DateTimeOffset

Public Shared Function ParseExact (input As ReadOnlySpan(Of Char), format As ReadOnlySpan(Of Char), formatProvider As IFormatProvider, Optional styles As DateTimeStyles = System.Globalization.DateTimeStyles.None) As DateTimeOffset

Parametri

input: ReadOnlySpan<Char>

Intervallo di caratteri che rappresenta una data e ora.

format: ReadOnlySpan<Char>

Intervallo di caratteri che contiene un identificatore di formato che definisce il formato previsto di input.

formatProvider: IFormatProvider

Oggetto che fornisce informazioni di formattazione specifiche delle impostazioni cultura relative a input.

styles: DateTimeStyles

Combinazione bit per bit di valori di enumerazione che indica il formato consentito di input.

Restituisce

DateTimeOffset

Oggetto equivalente alla data e all'ora contenute nel parametro input, come specificato dai parametri format, formatProvider e styles.

Eccezioni

ArgumentException

L'offset è maggiore di 14 ore o minore di -14 ore. -oppure- Il styles parametro include un valore non supportato. -oppure- Il styles parametro contiene DateTimeStyles valori che non possono essere usati insieme.

FormatException

input è un intervallo di caratteri vuoto. -oppure- input non contiene una rappresentazione di stringa valida per data e ora. -oppure- format è un intervallo di caratteri vuoto. -oppure- Il componente dell'ora e l'operatore di progettazione AM/PM in input non sono d'accordo.

Commenti

Questo metodo analizza un intervallo di caratteri che rappresenta una data, che deve essere nel formato definito dal format parametro . È inoltre necessario che gli <Date>elementi , <Time>e <Offset> della rappresentazione di stringa di una data e dell'ora vengano visualizzati nell'ordine specificato da format. Se input non corrisponde al format modello, il metodo genera un'eccezione FormatException. Al contrario, il DateTimeOffset.Parse(ReadOnlySpan<Char>, IFormatProvider, DateTimeStyles) metodo analizza la rappresentazione di stringa di una data in uno dei formati riconosciuti dall'oggetto del provider di DateTimeFormatInfo formato. Parse consente inoltre agli <Date>elementi , <Time>e <Offset> della rappresentazione di stringa di una data e dell'ora di essere visualizzati in qualsiasi ordine.

Il format parametro è un intervallo di caratteri che contiene un identificatore di formato standard a carattere singolo o uno o più identificatori di formato personalizzati che definiscono il formato richiesto del input parametro. Per informazioni dettagliate sui codici di formattazione validi, vedere Stringhe di formato data e ora standard e stringhe di formato di data e ora personalizzate. Se format include gli zidentificatori di formato , zzo zzz personalizzati per indicare che un offset deve essere presente in input, tale offset deve includere un segno negativo o un segno positivo. Se il segno non è presente, il metodo genera un'eccezione FormatException.

I simboli e le stringhe di data e ora specifici utilizzati in input sono definiti dal formatProvider parametro , come è il formato preciso di se format è un 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 relativa DateTimeFormat proprietà definisce i simboli e la formattazione in input.
Oggetto DateTimeFormatInfo che definisce il formato dei dati di data e ora.

Se formatprovider è null, viene utilizzato l'oggetto CultureInfo che corrisponde alle impostazioni cultura correnti.

Si applica a

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

Converte un intervallo di caratteri che contiene la rappresentazione stringa di una data e di un'ora nel relativo oggetto 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 DateTimeOffset ParseExact (ReadOnlySpan<char> input, string[] formats, IFormatProvider? formatProvider, System.Globalization.DateTimeStyles styles = System.Globalization.DateTimeStyles.None);

public static DateTimeOffset ParseExact (ReadOnlySpan<char> input, string[] formats, IFormatProvider formatProvider, System.Globalization.DateTimeStyles styles = System.Globalization.DateTimeStyles.None);

static member ParseExact : ReadOnlySpan<char> * string[] * IFormatProvider * System.Globalization.DateTimeStyles -> DateTimeOffset

Public Shared Function ParseExact (input As ReadOnlySpan(Of Char), formats As String(), formatProvider As IFormatProvider, Optional styles As DateTimeStyles = System.Globalization.DateTimeStyles.None) As DateTimeOffset

Parametri

input: ReadOnlySpan<Char>

Intervallo di caratteri contenente una data e un'ora da convertire.

formats: String[]

Matrice di identificatori di formato che definiscono i formati previsti di input.

formatProvider: IFormatProvider

Oggetto che fornisce informazioni di formattazione specifiche delle impostazioni cultura relativamente a input.

styles: DateTimeStyles

Combinazione bit per bit di valori di enumerazione che indica il formato consentito di input.

Restituisce

DateTimeOffset

Oggetto equivalente alla data e all'ora contenute nel parametro input, come specificato dai parametri formats, formatProvider e styles.

Eccezioni

ArgumentException

L'offset è maggiore di 14 ore o minore di -14 ore. -oppure- styles include un valore non supportato. -o- Il styles parametro contiene DateTimeStyles valori che non possono essere usati insieme.

FormatException

input è un intervallo di caratteri vuoto. -oppure- input non contiene una rappresentazione di stringa valida per data e ora. -or- Nessun elemento di contiene un identificatore di formats formato valido. -or- Componente ora e designatore AM/PM in input non accettano.

Commenti

Questo metodo analizza un intervallo di caratteri che rappresenta una data corrispondente a uno dei modelli assegnati al formats parametro . Se input non corrisponde a uno di questi modelli con una delle varianti definite dal styles parametro , il metodo genera un'eccezione FormatException. A parte il confronto input con più modelli di formattazione, questo overload si comporta in modo identico al DateTimeOffset.ParseExact(ReadOnlySpan<Char>, ReadOnlySpan<Char>, IFormatProvider, DateTimeStyles) metodo .

Il formats parametro è una matrice di stringhe i cui elementi contengono un singolo identificatore di formato standard o uno o più identificatori di formato personalizzati che definiscono il modello possibile del input parametro. Quando viene chiamato il metodo, input deve corrispondere a uno di questi modelli. Per informazioni dettagliate sui codici di formattazione validi, vedere Stringhe di formato data e ora standard e stringhe di formato di data e ora personalizzate. Se l'elemento corrispondente in formats include gli z``zzidentificatori di formato personalizzati , o zzz per indicare che un offset deve essere presente in input, tale offset deve includere un segno negativo o un segno positivo. Se il segno non è presente, il metodo genera un'eccezione FormatException.

Importante

L'uso del formats parametro di questo overload per specificare più formati può contribuire a ridurre la frustrazione che molti utenti riscontrano quando immettono date e ore. In particolare, la possibilità di definire più modelli di input consente a un'applicazione di gestire rappresentazioni di data e ora che possono includere o mancanza di zeri iniziali in mesi, giorni, ore, minuti e secondi.

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 input contenga un'ora ma non una data, all'oggetto risultante DateTimeOffset viene assegnata la data corrente nel sistema locale. Se l'elemento corrispondente in formats non richiede che input contenga un offset, l'offset dell'oggetto risultante DateTimeOffset dipende dal valore del styles parametro . Se styles include AssumeLocal, l'offset del fuso orario locale viene assegnato all'oggetto DateTimeOffset . Se styles include AssumeUniversal, l'offset UTC (Coordinated Universal Time) o +00:00, viene assegnato all'oggetto DateTimeOffset . Se nessuno dei due valori viene specificato, viene utilizzato l'offset del fuso orario locale.

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

Oggetto CultureInfo che rappresenta le impostazioni cultura basate su cui input viene interpretato. L'oggetto DateTimeFormatInfo restituito dalla CultureInfo.DateTimeFormat proprietà definisce i simboli e la formattazione in input.
Oggetto DateTimeFormatInfo che definisce il formato dei dati di data e ora.

Se formatprovider è null, viene utilizzato l'oggetto CultureInfo che corrisponde alle impostazioni cultura correnti.

Membro`DateTimeStyles`	Comportamento
AdjustToUniversal	Analizza e, se necessario, lo converte `input` in UTC. Equivale a analizzare una stringa e quindi chiamare il DateTimeOffset.ToUniversalTime metodo dell'oggetto restituito DateTimeOffset .
AssumeLocal	Se l'elemento corrispondente in `formats` non richiede che `input` contenga un valore di offset, l'oggetto restituito DateTimeOffset viene assegnato l'offset del fuso orario locale. Rappresenta il valore predefinito.
AssumeUniversal	Se l'elemento corrispondente in `formats` non richiede che `input` contenga un valore di offset, l'oggetto restituito DateTimeOffset viene assegnato all'offset UTC (+00:00).
AllowInnerWhite	Consente di `input` includere spazi vuoti interni non specificati da `format`. Lo spazio vuoto aggiuntivo può essere visualizzato tra componenti di data e ora e all'interno di singoli componenti (ad eccezione dell'offset) e viene ignorato durante l'analisi della stringa.
AllowLeadingWhite	Consente di `input` includere spazi iniziali non specificati da `formats`. Questi vengono ignorati durante l'analisi della stringa.
AllowTrailingWhite	Consente di `input` includere spazi finali non specificati da `formats`. Questi vengono ignorati durante l'analisi della stringa.
AllowWhiteSpaces	Consente di `input` includere spazi iniziali, finali e interni non specificati da `formats`. Tutti i caratteri di spazio vuoto aggiuntivi non specificati nell'elemento corrispondente in `formats` vengono ignorati durante l'analisi della stringa.
None	Indica che lo spazio vuoto aggiuntivo non è consentito in `input`. Lo spazio vuoto deve essere visualizzato esattamente come specificato in un particolare elemento di `formats` per che si verifichi una corrispondenza. Comportamento predefinito.
RoundtripKind	Non ha alcun effetto perché la DateTimeOffset struttura non include una `Kind` proprietà.

Si applica a

Condividi tramite

DateTimeOffset.ParseExact Metodo

Definizione

Overload

ParseExact(String, String[], IFormatProvider, DateTimeStyles)

Parametri

Restituisce

Eccezioni

Esempio

Commenti

Note per i chiamanti

Vedi anche

Si applica a

ParseExact(String, String, IFormatProvider, DateTimeStyles)

Parametri

Restituisce

Eccezioni

Esempio

Commenti

Note per i chiamanti

Vedi anche

Si applica a

ParseExact(String, String, IFormatProvider)

Parametri

Restituisce

Eccezioni

Esempio

Commenti

Note per i chiamanti

Vedi anche

Si applica a

ParseExact(ReadOnlySpan<Char>, ReadOnlySpan<Char>, IFormatProvider, DateTimeStyles)

Parametri

Restituisce

Eccezioni

Commenti

Si applica a

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

Parametri

Restituisce

Eccezioni

Commenti

Si applica a

Risorse aggiuntive