Teilen über


DateTimeOffset.TryParseExact Methode

Definition

Konvertiert die angegebene Zeichenfolgendarstellung eines Datums und einer Uhrzeit in dessen DateTimeOffset Entsprechung. Das Format der Zeichenfolgendarstellung muss genau mit einem angegebenen Format übereinstimmen.

Überlädt

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

Konvertiert die angegebene Zeichenfolgendarstellung eines Datums und einer Uhrzeit in seine DateTimeOffset Entsprechung mithilfe des angegebenen Arrays von Formaten, kulturspezifischen Formatinformationen und Formatvorlagen. Das Format der Zeichenfolgendarstellung muss genau mit einem der angegebenen Formate übereinstimmen.

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

Konvertiert die Darstellung eines Datums und einer Uhrzeit in einem Zeichenbereich in dessen DateTimeOffset Äquivalent mithilfe des angegebenen Formats, kulturspezifischer Formatinformationen und formatspezifischer Formatinformationen. Das Format der Datums- und Uhrzeitdarstellung muss exakt mit dem angegebenen Format übereinstimmen.

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

Konvertiert die Darstellung eines Datums und einer Uhrzeit in einem Zeichenbereich in seine DateTimeOffset Äquivalent mithilfe der angegebenen Formate, kulturspezifischen Formatinformationen und Formatvorlagen. Das Format der Datums- und Uhrzeitdarstellung muss genau mit einem der angegebenen Formate übereinstimmen.

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

Konvertiert die angegebene Zeichenfolgendarstellung eines Datums und einer Uhrzeit in dessen DateTimeOffset Äquivalent mithilfe des angegebenen Formats, kulturspezifischer Formatinformationen und Formatvorlagen. Das Format der Zeichenfolgendarstellung muss exakt mit dem angegebenen Format übereinstimmen.

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

Quelle:
DateTimeOffset.cs
Quelle:
DateTimeOffset.cs
Quelle:
DateTimeOffset.cs

Konvertiert die angegebene Zeichenfolgendarstellung eines Datums und einer Uhrzeit in seine DateTimeOffset Entsprechung mithilfe des angegebenen Arrays von Formaten, kulturspezifischen Formatinformationen und Formatvorlagen. Das Format der Zeichenfolgendarstellung muss genau mit einem der angegebenen Formate übereinstimmen.

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

Parameter

input
String

Eine Zeichenfolge, die ein Datum und eine Uhrzeit enthält, die konvertiert werden soll.

formats
String[]

Ein Array, das die erwarteten Formate von inputdefiniert.

formatProvider
IFormatProvider

Ein Objekt, das kulturspezifische Formatierungsinformationen zu inputbereitstellt.

styles
DateTimeStyles

Eine bitweise Kombination von Enumerationswerten, die das zulässige Format der Eingabe angibt. Ein typischer Wert, der angegeben werden soll, ist None.

result
DateTimeOffset

Wenn die Methode zurückgegeben wird, enthält die DateTimeOffset entspricht dem Datum und der Uhrzeit von input, wenn die Konvertierung erfolgreich war, oder DateTimeOffset.MinValue, wenn die Konvertierung fehlgeschlagen ist. Die Konvertierung schlägt fehl, wenn die input keine gültige Zeichenfolgendarstellung eines Datums und einer Uhrzeit enthält oder nicht das Datum und die Uhrzeit im erwarteten Format enthält, das durch formatsdefiniert wird, oder wenn formatsnullist. Dieser Parameter wird nicht initialisiert übergeben.

Gibt zurück

true, wenn der parameter input erfolgreich konvertiert wird; andernfalls false.

Ausnahmen

styles enthält einen nicht definierten DateTimeStyles Wert.

-oder-

NoCurrentDateDefault wird nicht unterstützt.

-oder-

styles schließt sich gegenseitig ausschließende DateTimeStyles Werte ein.

Beispiele

Im folgenden Beispiel werden mehrere Eingabeformate für die Zeichenfolgendarstellung eines Datums- und Uhrzeit- und Offsetwerts definiert und anschließend die vom Benutzer eingegebene Zeichenfolge an die TryParseExact(String, String[], IFormatProvider, DateTimeStyles, DateTimeOffset)-Methode übergeben.

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

Hinweise

Die TryParseExact(String, String[], IFormatProvider, DateTimeStyles, DateTimeOffset)-Methode analysiert die Zeichenfolgendarstellung eines Datums, das einem der dem formats Array zugewiesenen Muster entspricht. Wenn die input Zeichenfolge keines dieser Muster mit variationen übereinstimmt, die vom parameter styles definiert sind, schlägt der Analysevorgang fehl, und die Methode gibt falsezurück. Abgesehen vom Vergleich von input mit mehreren Zeichenfolgen, die Formatbezeichner enthalten, verhält sich diese Überladung identisch mit der DateTimeOffset.ParseExact(String, String[], IFormatProvider, DateTimeStyles)-Methode.

Der formats Parameter ist ein Zeichenfolgenarray, dessen Elemente entweder einen einzelnen Standardformatbezeichner oder einen oder mehrere benutzerdefinierte Formatbezeichner enthalten, die das mögliche Muster von inputdefinieren. Ausführliche Informationen zu gültigen Formatierungscodes finden Sie unter Standard-Datums- und Uhrzeitformatzeichenfolgen und benutzerdefinierten Datums- und Uhrzeitformatzeichenfolgen. Wenn das übereinstimmende Element in formats die z, zzoder zzz benutzerdefinierte Formatbezeichner enthält, um anzugeben, dass ein Offset in inputvorhanden sein muss, muss dieser Offset entweder ein negatives Oder ein positives Zeichen enthalten. Wenn das Zeichen fehlt, schlägt der Analysevorgang fehl, und die Methode gibt falsezurück.

Wichtig

Die Verwendung des formats Parameters dieser Überladung zur Angabe mehrerer Formate kann dazu beitragen, die Frustration vieler Benutzer zu verringern, wenn sie Datums- und Uhrzeitangaben eingeben. Die Möglichkeit zum Definieren mehrerer Eingabemuster ermöglicht es einer Anwendung, Datums- und Uhrzeitdarstellungen zu verarbeiten, die entweder führende Nullen in Monaten, Tagen, Stunden, Minuten und Sekunden enthalten oder fehlen. Das Beispiel stellt eine Abbildung dieses Beispiels bereit.

Wenn das übereinstimmene Element in formats erfordert, dass input ein Datum, aber keine Uhrzeit enthalten, wird dem resultierenden DateTimeOffset-Objekt eine Uhrzeit von Mitternacht (0:00:00:00) zugewiesen. Wenn das übereinstimmene Element in formats erfordert, dass die Eingabe eine Uhrzeit, aber kein Datum enthält, wird dem resultierenden DateTimeOffset-Objekt das aktuelle Datum im lokalen System zugewiesen. Wenn das übereinstimmene Element in formats nicht erfordert, dass input einen Offset enthalten, hängt der Offset des resultierenden DateTimeOffset-Objekts vom Wert des styles-Parameters ab. Wenn stylesAssumeLocalenthält, wird dem DateTimeOffset-Objekt der Offset der lokalen Zeitzone zugewiesen. Wenn stylesAssumeUniversalenthält, wird dem DateTimeOffset-Objekt der Offset für koordinierte Weltzeit (COORDINATED Universal Time, UTC) oder +00:00 zugewiesen. Wenn kein Wert angegeben wird, wird der Offset der lokalen Zeitzone verwendet.

Die in input verwendeten Datums- und Uhrzeitsymbole und Zeichenfolgen werden durch den parameter formatProvider definiert. Das gleiche gilt für das genaue Muster von input, wenn das übereinstimmende Element von formats eine Standardformatbezeichnerzeichenfolge ist. Der parameter formatProvider kann eine der folgenden sein:

Wenn formatprovidernullist, wird das CultureInfo-Objekt verwendet, das der aktuellen Kultur entspricht.

Der parameter styles definiert, ob Leerzeichen in der Eingabezeichenfolge zulässig sind, gibt an, wie Zeichenfolgen ohne explizite Offsetkomponente analysiert werden und die UTC-Konvertierung als Teil des Analysevorgangs unterstützt wird. Alle Member der DateTimeStyles-Aufzählung werden mit Ausnahme von NoCurrentDateDefaultunterstützt. In der folgenden Tabelle sind die Auswirkungen der einzelnen unterstützten Member aufgeführt.

mitglied DateTimeStyles Benehmen
AdjustToUniversal Analysiert input und konvertiert sie bei Bedarf in UTC. Sie entspricht der Analyse einer Zeichenfolge und dem Anschließenden Aufrufen der DateTimeOffset.ToUniversalTime Methode des zurückgegebenen DateTimeOffset Objekts.
AssumeLocal Wenn das übereinstimmene Element in formats nicht erfordert, dass input einen Offsetwert enthalten, erhält das zurückgegebene DateTimeOffset Objekt den Offset der lokalen Zeitzone. Dies ist der Standardwert.
AssumeUniversal Wenn das übereinstimmende Element in formats nicht erfordert, dass input einen Offsetwert enthalten, erhält das zurückgegebene DateTimeOffset Objekt den UTC-Offset (+00:00).
AllowInnerWhite Ermöglicht es input, inneren Leerraum einzuschließen, der von den Elementen in formatsnicht angegeben wird. Zusätzlicher Leerraum kann zwischen Datums- und Uhrzeitkomponenten und innerhalb einzelner Komponenten (mit Ausnahme des Offsets) angezeigt werden und beim Analysieren der Zeichenfolge ignoriert werden.
AllowLeadingWhite Ermöglicht input, führende Leerzeichen einzuschließen, die von den Elementen in formatsnicht angegeben werden. Diese werden beim Analysieren der Zeichenfolge ignoriert.
AllowTrailingWhite Ermöglicht input, nachfolgende Leerzeichen einzuschließen, die von den Elementen in formatsnicht angegeben werden. Diese werden beim Analysieren der Zeichenfolge ignoriert.
AllowWhiteSpaces Ermöglicht input, führende, nachfolgende und innere Leerzeichen einzuschließen, die von den Elementen in formatsnicht angegeben werden. Alle zusätzlichen Leerzeichen, die im übereinstimmenden Element in formats nicht angegeben sind, werden beim Analysieren der Zeichenfolge ignoriert.
None Gibt an, dass in inputkein zusätzlicher Leerraum zulässig ist. Leerzeichen müssen genau wie in einem bestimmten Element in formats angezeigt werden, damit eine erfolgreiche Übereinstimmung eintritt. Dies ist das Standardverhalten.
RoundtripKind Hat keine Auswirkung, da die DateTimeOffset-Struktur keine Kind-Eigenschaft enthält.

Hinweise für Aufrufer

In .NET Framework 4 gibt der TryParseExactfalse zurück, wenn die zu analysierende Zeichenfolge eine Stundenkomponente und einen AM/PM-Kennzeichner enthält, der nicht in Übereinstimmung ist. In .NET Framework 3.5 und früheren Versionen wird der AM/PM-Kennzeichner ignoriert.

Gilt für:

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

Quelle:
DateTimeOffset.cs
Quelle:
DateTimeOffset.cs
Quelle:
DateTimeOffset.cs

Konvertiert die Darstellung eines Datums und einer Uhrzeit in einem Zeichenbereich in dessen DateTimeOffset Äquivalent mithilfe des angegebenen Formats, kulturspezifischer Formatinformationen und formatspezifischer Formatinformationen. Das Format der Datums- und Uhrzeitdarstellung muss exakt mit dem angegebenen Format übereinstimmen.

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

Parameter

input
ReadOnlySpan<Char>

Eine Spanne, die die Zeichen enthält, die ein zu konvertierende Datum und eine Uhrzeit darstellen.

format
ReadOnlySpan<Char>

Ein Formatbezeichner, der das erforderliche Format von inputdefiniert.

formatProvider
IFormatProvider

Ein Objekt, das kulturspezifische Formatierungsinformationen zu inputbereitstellt.

styles
DateTimeStyles

Eine bitweise Kombination von Enumerationswerten, die das zulässige Format von inputangibt. Ein typischer Wert, der angegeben werden soll, ist None.

result
DateTimeOffset

Wenn die Methode zurückgegeben wird, enthält die DateTimeOffset entspricht dem Datum und der Uhrzeit input, wenn die Konvertierung erfolgreich war, oder DateTimeOffset.MinValue, wenn die Konvertierung fehlgeschlagen ist. Die Konvertierung schlägt fehl, wenn die

Gibt zurück

true, wenn der parameter input erfolgreich konvertiert wird; andernfalls false.

Ausnahmen

styles enthält einen nicht definierten DateTimeStyles Wert. -oder- NoCurrentDateDefault wird nicht unterstützt. -oder- styles schließt sich gegenseitig DateTimeStyles Werte ein.

Hinweise

Diese Überladung ähnelt der DateTimeOffset.ParseExact(ReadOnlySpan<Char>, ReadOnlySpan<Char>, IFormatProvider, DateTimeStyles)-Methode, mit der Ausnahme, dass diese Methode keine Ausnahme auslöst, wenn die Konvertierung fehlschlägt. Es analysiert die Darstellung eines Datums und einer Uhrzeit, die genau mit dem muster übereinstimmen muss, das durch den parameter format angegeben wird. Wenn input diesem Muster nicht entspricht, schlägt der Analysevorgang fehl, styles und die Methode gibt falsezurück.

Der format-Parameter ist ein Zeichenbereich, der entweder einen einzelnen Standardformatbezeichner oder einen oder mehrere benutzerdefinierte Formatbezeichner enthält, die das erforderliche Muster von inputdefinieren. Ausführliche Informationen zu gültigen Formatierungscodes finden Sie unter Standard-Datums- und Uhrzeitformatzeichenfolgen und benutzerdefinierten Datums- und Uhrzeitformatzeichenfolgen. Wenn format die z, zzoder zzz benutzerdefinierte Formatbezeichner enthält, um anzugeben, dass ein Offset in inputvorhanden sein muss, muss dieser Offset entweder ein negatives Zeichen oder ein positives Zeichen enthalten. Wenn das Zeichen fehlt, schlägt der Analysevorgang fehl, und die Methode gibt falsezurück.

Wenn format erfordert, dass input ein Datum, aber keine Uhrzeit enthalten, wird dem resultierenden DateTimeOffset Objekt eine Mitternachtszeit zugewiesen (0:00:00). Wenn format erfordert, dass input eine Uhrzeit, aber kein Datum enthalten, wird dem resultierenden DateTimeOffset Objekt das aktuelle Datum im lokalen System zugewiesen. Wenn format nicht erfordert, dass input einen Offset enthalten, hängt der Offset des resultierenden DateTimeOffset-Objekts vom Wert des styles Parameters ab. Wenn stylesAssumeLocalenthält, wird dem DateTimeOffset-Objekt der Offset der lokalen Zeitzone zugewiesen. Wenn stylesAssumeUniversalenthält, wird dem DateTimeOffset-Objekt der Offset für koordinierte Weltzeit (COORDINATED Universal Time, UTC) oder +00:00 zugewiesen. Wenn kein Wert angegeben wird, wird der Offset der lokalen Zeitzone verwendet.

Die in input verwendeten Datums- und Uhrzeitsymbole und Zeichenfolgen werden durch den parameter formatProvider definiert. Das gleiche gilt für das genaue Muster von input, wenn format eine Standardformatbezeichnerzeichenfolge ist. Der parameter formatProvider kann eine der folgenden sein:

Wenn formatprovidernullist, wird das CultureInfo-Objekt verwendet, das der aktuellen Kultur entspricht.

Der parameter styles definiert, ob Leerzeichen in der Eingabezeichenfolge zulässig sind, gibt an, wie Zeichenfolgen ohne explizite Offsetkomponente analysiert werden und die UTC-Konvertierung als Teil des Analysevorgangs unterstützt wird. Alle Member der DateTimeStyles-Aufzählung werden mit Ausnahme von NoCurrentDateDefaultunterstützt. In der folgenden Tabelle sind die Auswirkungen der einzelnen unterstützten Member aufgeführt.

mitglied DateTimeStyles Benehmen
AdjustToUniversal Analysiert input und konvertiert sie bei Bedarf in UTC. Sie entspricht der Analyse einer Datums- und Uhrzeitdarstellung und dem Aufrufen der DateTimeOffset.ToUniversalTime Methode des zurückgegebenen DateTimeOffset Objekts.
AssumeLocal Wenn format nicht erfordert, dass input einen Offsetwert enthalten, erhält das zurückgegebene DateTimeOffset Objekt den Offset der lokalen Zeitzone. Dies ist das Standardverhalten.
AssumeUniversal Wenn format nicht erfordert, dass input einen Offsetwert enthalten, erhält das zurückgegebene DateTimeOffset Objekt den UTC-Offset (+00:00).
AllowInnerWhite Ermöglicht es input, inneren Leerraum einzuschließen, der nicht im Format angegeben ist. Zusätzlicher Leerraum kann zwischen Datums- und Uhrzeitkomponenten und innerhalb einzelner Komponenten, außer dem Offset, angezeigt werden und beim Analysieren der Zeichenfolge ignoriert werden.
AllowLeadingWhite Ermöglicht input, führende Leerzeichen einzuschließen, die nicht durch formatangegeben werden. Diese werden beim Analysieren der Zeichenfolge ignoriert.
AllowTrailingWhite Ermöglicht input, nachfolgende Leerzeichen einzuschließen, die nicht durch formatangegeben werden. Diese werden beim Analysieren der Zeichenfolge ignoriert.
AllowWhiteSpaces Ermöglicht input, führende, nachfolgende und innere Leerzeichen einzuschließen, die nicht durch formatangegeben werden. Alle zusätzlichen Leerzeichen, die in format nicht angegeben sind, werden beim Analysieren der Zeichenfolge ignoriert.
None Gibt an, dass in inputkein zusätzlicher Leerraum zulässig ist. Leerzeichen müssen genau wie in formatangegeben angezeigt werden. Dies ist das Standardverhalten.
RoundtripKind Hat keine Auswirkung, da die DateTimeOffset-Struktur keine Kind-Eigenschaft enthält.

Gilt für:

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

Quelle:
DateTimeOffset.cs
Quelle:
DateTimeOffset.cs
Quelle:
DateTimeOffset.cs

Konvertiert die Darstellung eines Datums und einer Uhrzeit in einem Zeichenbereich in seine DateTimeOffset Äquivalent mithilfe der angegebenen Formate, kulturspezifischen Formatinformationen und Formatvorlagen. Das Format der Datums- und Uhrzeitdarstellung muss genau mit einem der angegebenen Formate übereinstimmen.

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

Parameter

input
ReadOnlySpan<Char>

Eine Spanne, die die Zeichen enthält, die ein zu konvertierende Datum und eine Uhrzeit darstellen.

formats
String[]

Ein Array von Standard- oder benutzerdefinierten Formatzeichenfolgen, die die zulässigen Formate von inputdefinieren.

formatProvider
IFormatProvider

Ein Objekt, das kulturspezifische Formatierungsinformationen zu inputbereitstellt.

styles
DateTimeStyles

Eine bitweise Kombination von Enumerationswerten, die das zulässige Format von inputangibt. Ein typischer Wert, der angegeben werden soll, ist None.

result
DateTimeOffset

Wenn die Methode zurückgegeben wird, enthält die DateTimeOffset entspricht dem Datum und der Uhrzeit input, wenn die Konvertierung erfolgreich war, oder DateTimeOffset.MinValue, wenn die Konvertierung fehlgeschlagen ist. Die Konvertierung schlägt fehl, wenn die

Gibt zurück

true, wenn der parameter input erfolgreich konvertiert wird; andernfalls false.

Ausnahmen

styles enthält einen nicht definierten DateTimeStyles Wert. -oder- NoCurrentDateDefault wird nicht unterstützt. -oder- styles schließt sich gegenseitig DateTimeStyles Werte ein.

Hinweise

Diese Methode analysiert die Zeichenfolgendarstellung eines Datums, das einem der dem formats Array zugewiesenen Muster entspricht. Wenn input keines dieser Muster mit variationen übereinstimmt, die vom parameter styles definiert sind, schlägt der Analysevorgang fehl, und die Methode gibt falsezurück. Abgesehen vom Vergleich von input mit mehreren Zeichenfolgen, die Formatbezeichner enthalten, verhält sich diese Überladung identisch mit der DateTimeOffset.ParseExact(ReadOnlySpan<Char>, String[], IFormatProvider, DateTimeStyles)-Methode.

Der formats Parameter ist ein Zeichenfolgenarray, dessen Elemente entweder einen einzelnen Standardformatbezeichner oder einen oder mehrere benutzerdefinierte Formatbezeichner enthalten, die das mögliche Muster von inputdefinieren. Ausführliche Informationen zu gültigen Formatierungscodes finden Sie unter Standard-Datums- und Uhrzeitformatzeichenfolgen und benutzerdefinierten Datums- und Uhrzeitformatzeichenfolgen. Wenn das übereinstimmende Element in formats die z, zzoder zzz benutzerdefinierte Formatbezeichner enthält, um anzugeben, dass ein Offset in inputvorhanden sein muss, muss dieser Offset entweder ein negatives Oder ein positives Zeichen enthalten. Wenn das Zeichen fehlt, schlägt der Analysevorgang fehl, und die Methode gibt falsezurück.

Wichtig

Die Verwendung des formats Parameters dieser Überladung zur Angabe mehrerer Formate kann dazu beitragen, die Frustration vieler Benutzer zu verringern, wenn sie Datums- und Uhrzeitangaben eingeben. Die Möglichkeit zum Definieren mehrerer Eingabemuster ermöglicht es einer Anwendung, Datums- und Uhrzeitdarstellungen zu verarbeiten, die entweder führende Nullen in Monaten, Tagen, Stunden, Minuten und Sekunden enthalten oder fehlen. Das Beispiel stellt eine Abbildung dieses Beispiels bereit.

Wenn das übereinstimmene Element in formats erfordert, dass input ein Datum, aber keine Uhrzeit enthalten, wird dem resultierenden DateTimeOffset-Objekt eine Uhrzeit von Mitternacht (0:00:00:00) zugewiesen. Wenn das übereinstimmene Element in formats erfordert, dass die Eingabe eine Uhrzeit, aber kein Datum enthält, wird dem resultierenden DateTimeOffset-Objekt das aktuelle Datum im lokalen System zugewiesen. Wenn das übereinstimmene Element in formats nicht erfordert, dass input einen Offset enthalten, hängt der Offset des resultierenden DateTimeOffset-Objekts vom Wert des styles-Parameters ab. Wenn stylesDateTimeStyles.AssumeLocalenthält, wird dem DateTimeOffset-Objekt der Offset der lokalen Zeitzone zugewiesen. Wenn stylesDateTimeStyles.AssumeUniversalenthält, wird dem DateTimeOffset-Objekt der Offset für koordinierte Weltzeit (COORDINATED Universal Time, UTC) oder +00:00 zugewiesen. Wenn kein Wert angegeben wird, wird der Offset der lokalen Zeitzone verwendet.

Die in input verwendeten Datums- und Uhrzeitsymbole werden durch den parameter formatProvider definiert. Das gleiche gilt für das genaue Muster von input, wenn das übereinstimmende Element von formats eine Standardformatbezeichnerzeichenfolge ist. Der parameter formatProvider kann eine der folgenden sein:

Wenn formatprovidernullist, wird das CultureInfo-Objekt verwendet, das der aktuellen Kultur entspricht.

Der parameter styles definiert, ob Leerzeichen in der Eingabezeichenfolge zulässig sind, gibt an, wie Zeichenfolgen ohne explizite Offsetkomponente analysiert werden und die UTC-Konvertierung als Teil des Analysevorgangs unterstützt wird. Alle Member der DateTimeStyles-Aufzählung werden mit Ausnahme von NoCurrentDateDefaultunterstützt. In der folgenden Tabelle sind die Auswirkungen der einzelnen unterstützten Member aufgeführt.

mitglied DateTimeStyles Benehmen
AdjustToUniversal Analysiert input und konvertiert sie bei Bedarf in UTC. Sie entspricht der Analyse einer Zeichenfolge und dem Anschließenden Aufrufen der DateTimeOffset.ToUniversalTime Methode des zurückgegebenen DateTimeOffset Objekts.
AssumeLocal Wenn das übereinstimmene Element in formats nicht erfordert, dass input einen Offsetwert enthalten, erhält das zurückgegebene DateTimeOffset Objekt den Offset der lokalen Zeitzone. Dies ist der Standardwert.
AssumeUniversal Wenn das übereinstimmende Element in formats nicht erfordert, dass input einen Offsetwert enthalten, erhält das zurückgegebene DateTimeOffset Objekt den UTC-Offset (+00:00).
AllowInnerWhite Ermöglicht es input, inneren Leerraum einzuschließen, der von den Elementen in formatsnicht angegeben wird. Zusätzlicher Leerraum kann zwischen Datums- und Uhrzeitkomponenten und innerhalb einzelner Komponenten (mit Ausnahme des Offsets) angezeigt werden und beim Analysieren der Zeichenfolge ignoriert werden.
AllowLeadingWhite Ermöglicht input, führende Leerzeichen einzuschließen, die von den Elementen in formatsnicht angegeben werden. Diese werden beim Analysieren der Zeichenfolge ignoriert.
AllowTrailingWhite Ermöglicht input, nachfolgende Leerzeichen einzuschließen, die von den Elementen in formatsnicht angegeben werden. Diese werden beim Analysieren der Zeichenfolge ignoriert.
AllowWhiteSpaces Ermöglicht input, führende, nachfolgende und innere Leerzeichen einzuschließen, die von den Elementen in formatsnicht angegeben werden. Alle zusätzlichen Leerzeichen, die im übereinstimmenden Element in formats nicht angegeben sind, werden beim Analysieren der Zeichenfolge ignoriert.
None Gibt an, dass in inputkein zusätzlicher Leerraum zulässig ist. Leerzeichen müssen genau wie in einem bestimmten Element in formats angezeigt werden, damit eine erfolgreiche Übereinstimmung eintritt. Dies ist das Standardverhalten.
RoundtripKind Hat keine Auswirkung, da die DateTimeOffset-Struktur keine Kind-Eigenschaft enthält.

Gilt für:

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

Quelle:
DateTimeOffset.cs
Quelle:
DateTimeOffset.cs
Quelle:
DateTimeOffset.cs

Konvertiert die angegebene Zeichenfolgendarstellung eines Datums und einer Uhrzeit in dessen DateTimeOffset Äquivalent mithilfe des angegebenen Formats, kulturspezifischer Formatinformationen und Formatvorlagen. Das Format der Zeichenfolgendarstellung muss exakt mit dem angegebenen Format übereinstimmen.

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

Parameter

input
String

Eine Zeichenfolge, die ein Datum und eine Uhrzeit enthält, die konvertiert werden soll.

format
String

Ein Formatbezeichner, der das erforderliche Format von inputdefiniert.

formatProvider
IFormatProvider

Ein Objekt, das kulturspezifische Formatierungsinformationen zu inputbereitstellt.

styles
DateTimeStyles

Eine bitweise Kombination von Enumerationswerten, die das zulässige Format der Eingabe angibt. Ein typischer Wert, der angegeben werden soll, ist None.

result
DateTimeOffset

Wenn die Methode zurückgegeben wird, enthält die DateTimeOffset entspricht dem Datum und der Uhrzeit von input, wenn die Konvertierung erfolgreich war, oder DateTimeOffset.MinValue, wenn die Konvertierung fehlgeschlagen ist. Die Konvertierung schlägt fehl, wenn der parameter inputnullist oder keine gültige Zeichenfolgendarstellung eines Datums und einer Uhrzeit im erwarteten Format enthält, das durch format und providerdefiniert wird. Dieser Parameter wird nicht initialisiert übergeben.

Gibt zurück

true, wenn der parameter input erfolgreich konvertiert wird; andernfalls false.

Ausnahmen

styles enthält einen nicht definierten DateTimeStyles Wert.

-oder-

NoCurrentDateDefault wird nicht unterstützt.

-oder-

styles schließt sich gegenseitig ausschließende DateTimeStyles Werte ein.

Beispiele

Im folgenden Beispiel wird die TryParseExact(String, String, IFormatProvider, DateTimeStyles, DateTimeOffset)-Methode mit Standard- und benutzerdefinierten Formatbezeichnern, der invarianten Kultur und verschiedenen DateTimeStyles Werten verwendet, um mehrere Datums- und Uhrzeitzeichenfolgen zu analysieren.

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.

Im folgenden Beispiel wird eine Vielzahl von DateTimeStyles Werten verwendet, um ein Array von Zeichenfolgen zu analysieren, die ISO 8601-entsprechen. Wie die Ausgabe aus dem Beispiel zeigt, können Zeichenfolgen, die sich im richtigen Format befinden, nicht analysiert werden, wenn:

  • sie enthalten Leerzeichen und ein entsprechendes DateTimeStyles Flag (z. B. DateTimeStyles.AllowWhiteSpaces wurde im Methodenaufruf nicht angegeben.

  • sie enthalten Datums- und Uhrzeitelemente, die außerhalb des zulässigen Bereichs liegen.

Zeichenfolgen, die keinen UTC-Offset angeben, werden angenommen, dass der Offset der lokalen Zeitzone (in diesem Fall -07:00, die den Offset der Pacific Daylight Time Zone widerspiegelt) aufweisen, es sei denn, das DateTimeStyles.AssumeUniversal Flag wird im Methodenaufruf angegeben. In diesem Fall wird davon ausgegangen, dass sie die koordinierte Weltzeit sind.

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

Hinweise

Diese Überladung der TryParseExact(String, String, IFormatProvider, DateTimeStyles, DateTimeOffset)-Methode entspricht der DateTimeOffset.ParseExact(String, String, IFormatProvider, DateTimeStyles)-Methode, mit der Ausnahme, dass diese Methode keine Ausnahme auslöst, wenn die Konvertierung fehlschlägt. Es analysiert die Zeichenfolgendarstellung eines Datums und einer Uhrzeit, die exakt mit dem muster übereinstimmen muss, das durch den parameter format angegeben wurde. Wenn die input Zeichenfolge nicht mit diesem Muster übereinstimmt, styles schlägt der Analysevorgang fehl, und die Methode gibt falsezurück.

Der parameter format ist eine Zeichenfolge, die entweder einen einzelnen Standardformatbezeichner oder einen oder mehrere benutzerdefinierte Formatbezeichner enthält, die das erforderliche Muster von inputdefinieren. Ausführliche Informationen zu gültigen Formatierungscodes finden Sie unter Standard-Datums- und Uhrzeitformatzeichenfolgen und benutzerdefinierten Datums- und Uhrzeitformatzeichenfolgen. Wenn format die z, zzoder zzz benutzerdefinierte Formatbezeichner enthält, um anzugeben, dass ein Offset in inputvorhanden sein muss, muss dieser Offset entweder ein negatives Zeichen oder ein positives Zeichen enthalten. Wenn das Zeichen fehlt, schlägt der Analysevorgang fehl, und die Methode gibt falsezurück.

Wenn format erfordert, dass input ein Datum, aber keine Uhrzeit enthalten, wird dem resultierenden DateTimeOffset Objekt eine Mitternachtszeit zugewiesen (0:00:00). Wenn format erfordert, dass input eine Uhrzeit, aber kein Datum enthalten, wird dem resultierenden DateTimeOffset Objekt das aktuelle Datum im lokalen System zugewiesen. Wenn format nicht erfordert, dass input einen Offset enthalten, hängt der Offset des resultierenden DateTimeOffset-Objekts vom Wert des styles Parameters ab. Wenn stylesAssumeLocalenthält, wird dem DateTimeOffset-Objekt der Offset der lokalen Zeitzone zugewiesen. Wenn stylesAssumeUniversalenthält, wird dem DateTimeOffset-Objekt der Offset für koordinierte Weltzeit (COORDINATED Universal Time, UTC) oder +00:00 zugewiesen. Wenn kein Wert angegeben wird, wird der Offset der lokalen Zeitzone verwendet.

Die in input verwendeten Datums- und Uhrzeitsymbole und Zeichenfolgen werden durch den parameter formatProvider definiert. Das gleiche gilt für das genaue Muster von input, wenn format eine Standardformatbezeichnerzeichenfolge ist. Der parameter formatProvider kann eine der folgenden sein:

Wenn formatprovidernullist, wird das CultureInfo-Objekt verwendet, das der aktuellen Kultur entspricht.

Der parameter styles definiert, ob Leerzeichen in der Eingabezeichenfolge zulässig sind, gibt an, wie Zeichenfolgen ohne explizite Offsetkomponente analysiert werden und die UTC-Konvertierung als Teil des Analysevorgangs unterstützt wird. Alle Member der DateTimeStyles-Aufzählung werden mit Ausnahme von NoCurrentDateDefaultunterstützt. In der folgenden Tabelle sind die Auswirkungen der einzelnen unterstützten Member aufgeführt.

mitglied DateTimeStyles Benehmen
AdjustToUniversal Analysiert input und konvertiert sie bei Bedarf in UTC. Sie entspricht der Analyse einer Zeichenfolge und dem Anschließenden Aufrufen der DateTimeOffset.ToUniversalTime Methode des zurückgegebenen DateTimeOffset Objekts.
AssumeLocal Wenn format nicht erfordert, dass input einen Offsetwert enthalten, erhält das zurückgegebene DateTimeOffset Objekt den Offset der lokalen Zeitzone. Dies ist das Standardverhalten.
AssumeUniversal Wenn format nicht erfordert, dass input einen Offsetwert enthalten, erhält das zurückgegebene DateTimeOffset Objekt den UTC-Offset (+00:00).
AllowInnerWhite Ermöglicht es input, inneren Leerraum einzuschließen, der nicht im Format angegeben ist. Zusätzlicher Leerraum kann zwischen Datums- und Uhrzeitkomponenten und innerhalb einzelner Komponenten, außer dem Offset, angezeigt werden und beim Analysieren der Zeichenfolge ignoriert werden.
AllowLeadingWhite Ermöglicht input, führende Leerzeichen einzuschließen, die nicht durch formatangegeben werden. Diese werden beim Analysieren der Zeichenfolge ignoriert.
AllowTrailingWhite Ermöglicht input, nachfolgende Leerzeichen einzuschließen, die nicht durch formatangegeben werden. Diese werden beim Analysieren der Zeichenfolge ignoriert.
AllowWhiteSpaces Ermöglicht input, führende, nachfolgende und innere Leerzeichen einzuschließen, die nicht durch formatangegeben werden. Alle zusätzlichen Leerzeichen, die in format nicht angegeben sind, werden beim Analysieren der Zeichenfolge ignoriert.
None Gibt an, dass in inputkein zusätzlicher Leerraum zulässig ist. Leerzeichen müssen genau wie in formatangegeben angezeigt werden. Dies ist das Standardverhalten.
RoundtripKind Hat keine Auswirkung, da die DateTimeOffset-Struktur keine Kind-Eigenschaft enthält.

Hinweise für Aufrufer

In .NET Framework 4 gibt der TryParseExactfalse zurück, wenn die zu analysierende Zeichenfolge eine Stundenkomponente und einen AM/PM-Kennzeichner enthält, der nicht in Übereinstimmung ist. In .NET Framework 3.5 und früheren Versionen wird der AM/PM-Kennzeichner ignoriert.

Weitere Informationen

Gilt für: