DateTimeOffset.ParseExact Methode

Definition

Namespace:: System

Assemblys:: mscorlib.dll, System.Runtime.dll

Assemblys:: netstandard.dll, System.Runtime.dll

Assembly:: System.Runtime.dll

Assembly:: mscorlib.dll

Assembly:: netstandard.dll

Wichtig

Einige Informationen beziehen sich auf Vorabversionen, die vor dem Release ggf. grundlegend überarbeitet werden. Microsoft übernimmt hinsichtlich der hier bereitgestellten Informationen keine Gewährleistungen, seien sie ausdrücklich oder konkludent.

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

Überlädt

Name	Beschreibung
ParseExact(String, String[], IFormatProvider, DateTimeStyles)	Konvertiert die angegebene Zeichenfolgendarstellung eines Datums und einer Uhrzeit in seine DateTimeOffset Entsprechung mithilfe der angegebenen Formate, kulturspezifischen Formatinformationen und Formatvorlagen. Das Format der Zeichenfolgendarstellung muss genau mit einem der angegebenen Formate übereinstimmen.
ParseExact(String, String, IFormatProvider, DateTimeStyles)	Wandelt die angegebene Zeichenfolgendarstellung eines Datums und einer Uhrzeit mithilfe des angegebenen Formats, der kulturspezifischen Formatinformationen und der Formatvorlage in das DateTimeOffset entsprechende Format um. Das Format der Zeichenfolgendarstellung muss exakt mit dem angegebenen Format übereinstimmen.
ParseExact(String, String, IFormatProvider)	Wandelt die angegebene Zeichenfolgendarstellung eines Datums und einer Uhrzeit mithilfe der angegebenen Format- und kulturspezifischen Formatinformationen in das DateTimeOffset entsprechende Format um. Das Format der Zeichenfolgendarstellung muss exakt mit dem angegebenen Format übereinstimmen.
ParseExact(ReadOnlySpan<Char>, ReadOnlySpan<Char>, IFormatProvider, DateTimeStyles)	Konvertiert einen Zeichenbereich, der ein Datum und eine Uhrzeit darstellt, in das DateTimeOffset entsprechende Format mit den angegebenen Formatinformationen, kulturspezifischen Formatinformationen und Formatvorlagen. Das Format der Datums- und Uhrzeitdarstellung muss exakt mit dem angegebenen Format übereinstimmen.
ParseExact(ReadOnlySpan<Char>, String[], IFormatProvider, DateTimeStyles)	Konvertiert einen Zeichenbereich, der die Zeichenfolgendarstellung eines Datums und einer Uhrzeit enthält, in dessen DateTimeOffset Äquivalent die angegebenen Formate, kulturspezifischen Formatinformationen und Formatvorlagen verwendet werden. Das Format der Datums- und Uhrzeitdarstellung muss genau mit einem der angegebenen Formate übereinstimmen.

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

Quelle:: DateTimeOffset.cs

Quelle:: DateTimeOffset.cs

Quelle:: DateTimeOffset.cs

Quelle:: DateTimeOffset.cs

Quelle:: DateTimeOffset.cs

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

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

Parameter

input: String

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

formats: String[]

Ein Array von Formatbezeichnern, die die erwarteten Formate definieren input.

formatProvider: IFormatProvider

Ein Objekt, das kulturspezifische Formatierungsinformationen zu input.

styles: DateTimeStyles

Eine bitweise Kombination von Enumerationswerten, die das zulässige Format von input.

Gibt zurück

DateTimeOffset

Ein Objekt, das dem Datum und der Uhrzeit entspricht, das im input Parameter enthalten ist, wie durch die formatsParameter , formatProviderund styles Parameter angegeben.

Ausnahmen

ArgumentException

Der Offset ist größer als 14 Stunden oder kleiner als -14 Stunden.

- oder -

styles enthält einen nicht unterstützten Wert.

- oder -

Der styles Parameter enthält DateTimeStyles Werte, die nicht zusammen verwendet werden können.

ArgumentNullException

input ist null.

FormatException

input ist eine leere Zeichenfolge ("").

- oder -

input enthält keine gültige Zeichenfolgendarstellung eines Datums und einer Uhrzeit.

- oder -

Kein Element enthält formats einen gültigen Formatbezeichner.

- oder -

Die Stundenkomponente und der AM/PM-Kennzeichner input stimmen nicht überein.

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 DateTimeOffset.ParseExact(String, String[], IFormatProvider, DateTimeStyles) 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 = 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

Hinweise

Die DateTimeOffset.ParseExact(String, String[], IFormatProvider, DateTimeStyles) Methode analysiert die Zeichenfolgendarstellung eines Datums, das einem der dem Parameter zugewiesenen formats Muster entspricht. Wenn die input Zeichenfolge keines dieser Muster mit einer der durch den styles Parameter definierten Variationen übereinstimmt, löst die Methode eine FormatException. Abgesehen vom Vergleich input mit mehreren Formatierungsmustern 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 des input Parameters definieren. Wenn die Methode aufgerufen wird, input muss eine dieser Muster übereinstimmen. Ausführliche Informationen zu gültigen Formatierungscodes finden Sie unter Standard-Datums- und Uhrzeitformatzeichenfolgen sowie benutzerdefinierte Datums- und Uhrzeitformatzeichenfolgen. Wenn das übereinstimmende Element die formatszzzBezeichner für das benutzerdefinierte Format enthält, zzz um anzugeben, dass ein Offset vorhanden inputsein muss, muss dieser Offset entweder ein negatives Zeichen oder ein positives Zeichen enthalten. Wenn das Zeichen fehlt, löst die Methode ein FormatException.

Von Bedeutung

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 formats ein Datum, aber keine Uhrzeit enthält input , wird dem resultierenden DateTimeOffset Objekt eine Mitternachtszeit zugewiesen (0:00:00:00). Wenn das übereinstimmene Element formats eine Uhrzeit, aber kein Datum enthält input , wird dem resultierenden DateTimeOffset Objekt das aktuelle Datum im lokalen System zugewiesen. Wenn für das übereinstimmene Element formats kein Offset erforderlich input ist, hängt der Offset des resultierenden DateTimeOffset Objekts vom Wert des styles Parameters ab. Wenn styles der Offset der lokalen Zeitzone enthalten AssumeLocalist, wird dem Objekt der DateTimeOffset Offset zugewiesen. Wenn styles der Offset für koordinierte Weltzeit (Coordinated Universal Time, UTC) oder +00:00 enthalten AssumeUniversalist, wird dem DateTimeOffset Objekt zugewiesen. Wenn kein Wert angegeben wird, wird der Offset der lokalen Zeitzone verwendet.

Die angegebenen Datums- und Uhrzeitsymbole und Zeichenfolgen input werden durch den formatProvider Parameter definiert. Das gleiche gilt für das genaue Format von input, wenn das übereinstimmende Element formats eine Standardformatbezeichnerzeichenfolge ist. Der formatProvider Parameter kann eine der folgenden Sein:

Ein CultureInfo Objekt, das die Kultur darstellt, auf deren input Grundlage interpretiert wird. Das DateTimeFormatInfo von der CultureInfo.DateTimeFormat Eigenschaft zurückgegebene Objekt definiert die Symbole und Formatierungen in input.
Ein DateTimeFormatInfo Objekt, das das Format von Datums- und Uhrzeitdaten definiert.

Wenn formatprovider ja null, wird das CultureInfo Objekt verwendet, das der aktuellen Kultur entspricht.

Der styles Parameter 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 Enumeration werden mit Ausnahme NoCurrentDateDefaultvon . In der folgenden Tabelle sind die Auswirkungen der einzelnen unterstützten Member aufgeführt.

`DateTimeStyles` Mitglied	Verhalten
AdjustToUniversal	Analysiert `input` und konvertiert es, falls erforderlich, in UTC. Sie entspricht dem Analysieren einer Zeichenfolge und dem Anschließenden Aufrufen der DateTimeOffset.ToUniversalTime Methode des zurückgegebenen DateTimeOffset Objekts.
AssumeLocal	Wenn für das übereinstimmene Element `formats` kein Offsetwert erforderlich `input` ist, erhält das zurückgegebene DateTimeOffset Objekt den Offset der lokalen Zeitzone. Dies ist der Standardwert.
AssumeUniversal	Wenn für das übereinstimmende Element `formats` kein Offsetwert erforderlich `input` ist, erhält das zurückgegebene DateTimeOffset Objekt den UTC-Offset (+00:00).
AllowInnerWhite	Ermöglicht `input` das Einschließen des inneren Leerraums, der nicht durch `format`. 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` das Einschließen von führenden Leerzeichen, die nicht durch `formats`. Diese werden beim Analysieren der Zeichenfolge ignoriert.
AllowTrailingWhite	Ermöglicht `input` das Einschließen nachgestellter Leerzeichen, die nicht durch `formats`. Diese werden beim Analysieren der Zeichenfolge ignoriert.
AllowWhiteSpaces	Ermöglicht `input` das Einschließen von führenden, nachgestellten und inneren Leerzeichen, die nicht durch `formats`. Alle zusätzlichen Leerzeichen, die im übereinstimmenden Element `formats` nicht angegeben sind, werden beim Analysieren der Zeichenfolge ignoriert.
None	Gibt an, dass zusätzlicher Leerraum nicht `input`zulässig ist. Leerzeichen müssen genau wie in einem bestimmten Element `formats` angegeben angezeigt werden, damit eine Übereinstimmung eintritt. Dies ist das Standardverhalten.
RoundtripKind	Hat keine Auswirkung, da die DateTimeOffset Struktur keine Eigenschaft enthält `Kind` .

Hinweise für Aufrufer

In .NET Framework 4 löst die ParseExact Methode ein FormatException , 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:

ParseExact(String, String, IFormatProvider, DateTimeStyles)

Quelle:: DateTimeOffset.cs

Quelle:: DateTimeOffset.cs

Quelle:: DateTimeOffset.cs

Quelle:: DateTimeOffset.cs

Quelle:: DateTimeOffset.cs

Wandelt die angegebene Zeichenfolgendarstellung eines Datums und einer Uhrzeit mithilfe des angegebenen Formats, der kulturspezifischen Formatinformationen und der Formatvorlage in das DateTimeOffset entsprechende Format um. Das Format der Zeichenfolgendarstellung muss exakt mit dem angegebenen Format übereinstimmen.

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

Parameter

input: String

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

format: String

Ein Formatbezeichner, der das erwartete Format von input.

formatProvider: IFormatProvider

Ein Objekt, das kulturspezifische Formatierungsinformationen zu input.

styles: DateTimeStyles

Eine bitweise Kombination von Enumerationswerten, die das zulässige Format von input.

Gibt zurück

DateTimeOffset

Ein Objekt, das dem Datum und der Uhrzeit entspricht, das im input Parameter enthalten ist, wie durch die formatParameter , formatProviderund styles Parameter angegeben.

Ausnahmen

ArgumentException

Der Offset ist größer als 14 Stunden oder kleiner als -14 Stunden.

- oder -

Der styles Parameter enthält einen nicht unterstützten Wert.

- oder -

Der styles Parameter enthält DateTimeStyles Werte, die nicht zusammen verwendet werden können.

ArgumentNullException

input ist null.

- oder -

format ist null.

FormatException

input ist eine leere Zeichenfolge ("").

- oder -

input enthält keine gültige Zeichenfolgendarstellung eines Datums und einer Uhrzeit.

- oder -

format ist eine leere Zeichenfolge.

- oder -

Die Stundenkomponente und der AM/PM-Kennzeichner input stimmen nicht überein.

Beispiele

Im folgenden Beispiel werden die DateTimeOffset.ParseExact(String, String, IFormatProvider, DateTimeStyles) 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;
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.

Im folgenden Beispiel wird eine Vielzahl von DateTimeStyles Werten verwendet, um ein Array von Zeichenfolgen zu analysieren, die mit ISO 8601 kompatibel sind. 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 Kennzeichen (z DateTimeStyles.AllowWhiteSpaces . B. 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) verwendet wird, es sei denn, das DateTimeStyles.AssumeUniversal Flag wird im Methodenaufruf angegeben. In diesem Fall wird davon ausgegangen, dass sie die koordinierte Weltzeit sind.

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'

Hinweise

Die DateTimeOffset.ParseExact(String, String, IFormatProvider, DateTimeStyles) Methode analysiert die Zeichenfolgendarstellung eines Datums, das im durch den format Parameter definierten Format vorliegen muss. Außerdem müssen die <Elemente Date>, <Time> und <Offset> der Zeichenfolgendarstellung eines Datums und einer Uhrzeit in der angegebenen formatReihenfolge angezeigt werden. Wenn die input Zeichenfolge nicht mit dem Muster des format Parameters übereinstimmt, löst styles die Methode eine FormatException. Im Gegensatz dazu analysiert die DateTimeOffset.Parse(String, IFormatProvider, DateTimeStyles) Methode die Zeichenfolgendarstellung eines Datums in einem der Formate, die vom Objekt des Formatanbieters DateTimeFormatInfo erkannt werden. Parse Ermöglicht außerdem die <Elemente "Date>", <"Time>" und <"Offset> " der Zeichenfolgendarstellung eines Datums und einer Uhrzeit in beliebiger Reihenfolge.

Der format Parameter ist eine Zeichenfolge, die entweder einen einzelnen Standardformatbezeichner oder einen oder mehrere benutzerdefinierte Formatbezeichner enthält, die das erforderliche Muster des input Parameters definieren. Ausführliche Informationen zu gültigen Formatierungscodes finden Sie unter Standard-Datums- und Uhrzeitformatzeichenfolgen sowie benutzerdefinierte Datums- und Uhrzeitformatzeichenfolgen. Wenn format die zBezeichner zzoder zzz benutzerdefinierte Formatbezeichner enthalten sind, um anzugeben, dass ein Offset vorhanden inputsein muss, muss dieser Offset entweder ein negatives Zeichen oder ein positives Zeichen enthalten. Wenn das Zeichen fehlt, löst die Methode ein FormatException.

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

Die angegebenen Datums- und Uhrzeitsymbole und Zeichenfolgen input werden durch den formatProvider Parameter definiert. Das gleiche gilt für das genaue Format von input, wenn format es sich um eine Standardformatbezeichnerzeichenfolge handelt. Der formatProvider Parameter kann eine der folgenden Sein:

Ein CultureInfo Objekt, das die Kultur darstellt, auf deren input Grundlage interpretiert wird. Das DateTimeFormatInfo von der CultureInfo.DateTimeFormat Eigenschaft zurückgegebene Objekt definiert die Symbole und Formatierungen in input.
Ein DateTimeFormatInfo Objekt, das das Format von Datums- und Uhrzeitdaten definiert.

Wenn formatprovider ja null, wird das CultureInfo Objekt verwendet, das der aktuellen Kultur entspricht.

`DateTimeStyles` Mitglied	Verhalten
AdjustToUniversal	Analysiert `input` und konvertiert es, falls erforderlich, in UTC. Sie entspricht dem Analysieren einer Zeichenfolge und dem Anschließenden Aufrufen der DateTimeOffset.ToUniversalTime Methode des zurückgegebenen DateTimeOffset Objekts.
AssumeLocal	Wenn `format` kein Offsetwert erforderlich `input` ist, erhält das zurückgegebene DateTimeOffset Objekt den Offset der lokalen Zeitzone. Dies ist der Standardwert.
AssumeUniversal	Wenn `format` kein Offsetwert erforderlich `input` ist, erhält das zurückgegebene DateTimeOffset Objekt den UTC-Offset (+00:00).
AllowInnerWhite	Ermöglicht `input` das Einschließen des inneren Leerraums, der nicht durch `format`. Zusätzlicher Leerraum kann zwischen Datums- und Uhrzeitkomponenten und innerhalb einzelner Komponenten angezeigt werden und wird beim Analysieren der Zeichenfolge ignoriert.
AllowLeadingWhite	Ermöglicht `input` das Einschließen von führenden Leerzeichen, die nicht durch `format`. Diese werden beim Analysieren der Zeichenfolge ignoriert.
AllowTrailingWhite	Ermöglicht `input` das Einschließen nachgestellter Leerzeichen, die nicht durch `format`. Diese werden beim Analysieren der Zeichenfolge ignoriert.
AllowWhiteSpaces	Ermöglicht `input` das Einschließen von führenden, nachgestellten und inneren Leerzeichen, die nicht durch `format`. Alle zusätzlichen Leerzeichen, die `format` nicht angegeben werden, werden beim Analysieren der Zeichenfolge ignoriert.
None	Gibt an, dass zusätzlicher Leerraum nicht `input`zulässig ist. Leerzeichen müssen genau wie angegeben `format`angezeigt werden. Dies ist das Standardverhalten.
RoundtripKind	Hat keine Auswirkung, da die DateTimeOffset Struktur keine Eigenschaft enthält `Kind` .

Hinweise für Aufrufer

Weitere Informationen

Gilt für:

ParseExact(String, String, IFormatProvider)

Quelle:: DateTimeOffset.cs

Quelle:: DateTimeOffset.cs

Quelle:: DateTimeOffset.cs

Quelle:: DateTimeOffset.cs

Quelle:: DateTimeOffset.cs

Wandelt die angegebene Zeichenfolgendarstellung eines Datums und einer Uhrzeit mithilfe der angegebenen Format- und kulturspezifischen Formatinformationen in das DateTimeOffset entsprechende Format um. Das Format der Zeichenfolgendarstellung muss exakt mit dem angegebenen Format übereinstimmen.

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

Parameter

input: String

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

format: String

Ein Formatbezeichner, der das erwartete Format von input.

formatProvider: IFormatProvider

Ein Objekt, das kulturspezifische Formatierungsinformationen zu input.

Gibt zurück

DateTimeOffset

Ein Objekt, das dem Datum und der Uhrzeit entspricht, das in der angegebenen input Und-Uhrzeit formatProviderenthalten format ist.

Ausnahmen

ArgumentException

Der Offset ist größer als 14 Stunden oder kleiner als -14 Stunden.

ArgumentNullException

input ist null.

- oder -

format ist null.

FormatException

input ist eine leere Zeichenfolge ("").

- oder -

input enthält keine gültige Zeichenfolgendarstellung eines Datums und einer Uhrzeit.

- oder -

format ist eine leere Zeichenfolge.

- oder -

Die Stundenkomponente und der AM/PM-Kennzeichner input stimmen nicht überein.

Beispiele

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

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.

Im folgenden Beispiel wird ein Array von Zeichenfolgen analysiert, die mit ISO 8601 kompatibel sind. Wie die Ausgabe aus dem Beispiel zeigt, können Zeichenfolgen mit führenden oder nachgestellten Leerzeichen nicht erfolgreich analysiert werden, ebenso wie Zeichenfolgen mit Datums- und Uhrzeitelementen, die außerhalb des Bereichs liegen.

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

Hinweise

Die ParseExact(String, String, IFormatProvider) Methode analysiert die Zeichenfolgendarstellung eines Datums, das im durch den format Parameter definierten Format vorliegen muss. Außerdem müssen die <Elemente Date>, <Time> und <Offset> der Zeichenfolgendarstellung eines Datums und einer Uhrzeit in der angegebenen formatReihenfolge angezeigt werden. Wenn die input Zeichenfolge nicht mit diesem format Parameter übereinstimmt, löst die Methode eine FormatException. Im Gegensatz dazu analysiert die DateTimeOffset.Parse(String, IFormatProvider) Methode die Zeichenfolgendarstellung eines Datums in einem der Formate, die vom Objekt des Formatanbieters DateTimeFormatInfo erkannt werden. Parse Ermöglicht außerdem die <Elemente "Date>", <"Time>" und <"Offset> " der Zeichenfolgendarstellung eines Datums und einer Uhrzeit in beliebiger Reihenfolge.

Der format Parameter ist eine Zeichenfolge, die entweder einen einzelnen Standardformatbezeichner oder einen oder mehrere benutzerdefinierte Formatbezeichner enthält, die das erforderliche Format des input Parameters definieren. Ausführliche Informationen zu gültigen Formatierungscodes finden Sie unter Standard-Datums- und Uhrzeitformatzeichenfolgen sowie benutzerdefinierte Datums- und Uhrzeitformatzeichenfolgen. Wenn format die zBezeichner zzoder zzz benutzerdefinierte Formatbezeichner enthalten sind, um anzugeben, dass ein Offset vorhanden inputsein muss, muss dieser Offset entweder ein negatives Zeichen oder ein positives Zeichen enthalten. Wenn das Zeichen fehlt, löst die Methode ein FormatException.

Die angegebenen Datums- und Uhrzeitsymbole und Zeichenfolgen input werden durch den formatProvider Parameter definiert, wie das genaue Format, input bei dem format es sich um eine Standardformatbezeichnerzeichenfolge handelt. Der formatProvider Parameter kann eine der folgenden Sein:

Ein CultureInfo Objekt, das die Kultur darstellt, auf deren input Grundlage interpretiert wird. Das DateTimeFormatInfo von der DateTimeFormat Eigenschaft zurückgegebene Objekt definiert die Symbole und Formatierungen in input.
Ein DateTimeFormatInfo Objekt, das das Format von Datums- und Uhrzeitdaten definiert.

Wenn formatprovider ja null, wird das CultureInfo Objekt verwendet, das der aktuellen Kultur entspricht.

Hinweise für Aufrufer

Weitere Informationen

Gilt für:

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

Quelle:: DateTimeOffset.cs

Quelle:: DateTimeOffset.cs

Quelle:: DateTimeOffset.cs

Quelle:: DateTimeOffset.cs

Quelle:: DateTimeOffset.cs

Konvertiert einen Zeichenbereich, der ein Datum und eine Uhrzeit darstellt, in das DateTimeOffset entsprechende Format mit den angegebenen Formatinformationen, kulturspezifischen Formatinformationen und Formatvorlagen. Das Format der Datums- und Uhrzeitdarstellung muss exakt mit dem angegebenen Format übereinstimmen.

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

Parameter

input: ReadOnlySpan<Char>

Ein Zeichenbereich, der ein Datum und eine Uhrzeit darstellt.

format: ReadOnlySpan<Char>

Ein Zeichenbereich, der einen Formatbezeichner enthält, der das erwartete Format von inputdefiniert.

formatProvider: IFormatProvider

Ein Objekt, das kulturspezifische Formatierungsinformationen zu input.

styles: DateTimeStyles

Eine bitweise Kombination von Enumerationswerten, die das zulässige Format von input.

Gibt zurück

DateTimeOffset

Ein Objekt, das dem Datum und der Uhrzeit entspricht, das im input Parameter enthalten ist, wie durch die formatParameter , formatProviderund styles Parameter angegeben.

Ausnahmen

ArgumentException

Der Offset ist größer als 14 Stunden oder kleiner als -14 Stunden. -or- Der styles Parameter enthält einen nicht unterstützten Wert. -or- Der styles Parameter enthält DateTimeStyles Werte, die nicht zusammen verwendet werden können.

FormatException

input ist ein leerer Zeichenbereich. -oder- input enthält keine gültige Zeichenfolgendarstellung eines Datums und einer Uhrzeit. -oder- format ist ein leerer Zeichenbereich. -oder- Die Stundenkomponente und der AM/PM-Kennzeichner input stimmen nicht überein.

Hinweise

Diese Methode analysiert einen Zeichenbereich, der ein Datum darstellt, das sich im formatieren muss, das durch den format Parameter definiert wird. Außerdem müssen die <Elemente Date>, <Time> und <Offset> der Zeichenfolgendarstellung eines Datums und einer Uhrzeit in der angegebenen formatReihenfolge angezeigt werden. Wenn input das format Muster nicht übereinstimmt, löst die Methode eine FormatException. Im Gegensatz dazu analysiert die DateTimeOffset.Parse(ReadOnlySpan<Char>, IFormatProvider, DateTimeStyles) Methode die Zeichenfolgendarstellung eines Datums in einem der Formate, die vom Objekt des Formatanbieters DateTimeFormatInfo erkannt werden. Parse Ermöglicht außerdem die <Elemente "Date>", <"Time>" und <"Offset> " der Zeichenfolgendarstellung eines Datums und einer Uhrzeit in beliebiger Reihenfolge.

Der format Parameter ist ein Zeichenbereich, der entweder einen einstelligen Standardformatbezeichner oder einen oder mehrere benutzerdefinierte Formatbezeichner enthält, die das erforderliche Format des input Parameters definieren. Ausführliche Informationen zu gültigen Formatierungscodes finden Sie unter Standard-Datums- und Uhrzeitformatzeichenfolgen sowie benutzerdefinierte Datums- und Uhrzeitformatzeichenfolgen. Wenn format die zBezeichner zzoder zzz benutzerdefinierte Formatbezeichner enthalten sind, um anzugeben, dass ein Offset vorhanden inputsein muss, muss dieser Offset entweder ein negatives Zeichen oder ein positives Zeichen enthalten. Wenn das Zeichen fehlt, löst die Methode ein FormatException.

Die angegebenen Datums- und Uhrzeitsymbole und Zeichenfolgen input werden durch den formatProvider Parameter definiert, ebenso wie das genaue Format input , wenn format es sich um einen Standardformatbezeichner handelt. Der formatProvider Parameter kann eine der folgenden Sein:

Ein CultureInfo Objekt, das die Kultur darstellt, auf deren input Grundlage interpretiert wird. Das DateTimeFormatInfo von der DateTimeFormat Eigenschaft zurückgegebene Objekt definiert die Symbole und Formatierungen in input.
Ein DateTimeFormatInfo Objekt, das das Format von Datums- und Uhrzeitdaten definiert.

Wenn formatprovider ja null, wird das CultureInfo Objekt verwendet, das der aktuellen Kultur entspricht.

Gilt für:

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

Quelle:: DateTimeOffset.cs

Quelle:: DateTimeOffset.cs

Quelle:: DateTimeOffset.cs

Quelle:: DateTimeOffset.cs

Quelle:: DateTimeOffset.cs

Konvertiert einen Zeichenbereich, der die Zeichenfolgendarstellung eines Datums und einer Uhrzeit enthält, in dessen DateTimeOffset Äquivalent die angegebenen Formate, kulturspezifischen Formatinformationen und Formatvorlagen verwendet werden. Das Format der Datums- und Uhrzeitdarstellung muss genau mit einem der angegebenen Formate übereinstimmen.

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

Parameter

input: ReadOnlySpan<Char>

Ein Zeichenbereich, der ein zu konvertierende Datum und eine Uhrzeit enthält.

formats: String[]

Ein Array von Formatbezeichnern, die die erwarteten Formate definieren input.

formatProvider: IFormatProvider

Ein Objekt, das kulturspezifische Formatierungsinformationen zu input.

styles: DateTimeStyles

Eine bitweise Kombination von Enumerationswerten, die das zulässige Format von input.

Gibt zurück

DateTimeOffset

Ein Objekt, das dem Datum und der Uhrzeit entspricht, das im input Parameter enthalten ist, wie durch die formatsParameter , formatProviderund styles Parameter angegeben.

Ausnahmen

ArgumentException

Der Offset ist größer als 14 Stunden oder kleiner als -14 Stunden. -oder- styles enthält einen nicht unterstützten Wert. -or- Der styles Parameter enthält DateTimeStyles Werte, die nicht zusammen verwendet werden können.

FormatException

input ist ein leerer Zeichenbereich. -oder- input enthält keine gültige Zeichenfolgendarstellung eines Datums und einer Uhrzeit. -oder- Kein Element enthält formats einen gültigen Formatbezeichner. -oder- Die Stundenkomponente und der AM/PM-Kennzeichner input stimmen nicht überein.

Hinweise

Diese Methode analysiert einen Zeichenbereich, der ein Datum darstellt, das einem der dem Parameter zugewiesenen formats Muster entspricht. Wenn input keiner dieser Muster mit einer der durch den styles Parameter definierten Variationen übereinstimmt, löst die Methode eine FormatException. Abgesehen vom Vergleich input mit mehreren Formatierungsmustern verhält sich diese Überladung identisch mit der DateTimeOffset.ParseExact(ReadOnlySpan<Char>, ReadOnlySpan<Char>, IFormatProvider, DateTimeStyles) Methode.

Von Bedeutung

Ein CultureInfo Objekt, das die Kultur darstellt, auf deren input Grundlage interpretiert wird. Das DateTimeFormatInfo von der CultureInfo.DateTimeFormat Eigenschaft zurückgegebene Objekt definiert die Symbole und Formatierungen in input.
Ein DateTimeFormatInfo Objekt, das das Format von Datums- und Uhrzeitdaten definiert.

Wenn formatprovider ja null, wird das CultureInfo Objekt verwendet, das der aktuellen Kultur entspricht.

`DateTimeStyles` Mitglied	Verhalten
AdjustToUniversal	Analysiert `input` und konvertiert es, falls erforderlich, in UTC. Sie entspricht dem Analysieren einer Zeichenfolge und dem Anschließenden Aufrufen der DateTimeOffset.ToUniversalTime Methode des zurückgegebenen DateTimeOffset Objekts.
AssumeLocal	Wenn für das übereinstimmene Element `formats` kein Offsetwert erforderlich `input` ist, erhält das zurückgegebene DateTimeOffset Objekt den Offset der lokalen Zeitzone. Dies ist der Standardwert.
AssumeUniversal	Wenn für das übereinstimmende Element `formats` kein Offsetwert erforderlich `input` ist, erhält das zurückgegebene DateTimeOffset Objekt den UTC-Offset (+00:00).
AllowInnerWhite	Ermöglicht `input` das Einschließen des inneren Leerraums, der nicht durch `format`. 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` das Einschließen von führenden Leerzeichen, die nicht durch `formats`. Diese werden beim Analysieren der Zeichenfolge ignoriert.
AllowTrailingWhite	Ermöglicht `input` das Einschließen nachgestellter Leerzeichen, die nicht durch `formats`. Diese werden beim Analysieren der Zeichenfolge ignoriert.
AllowWhiteSpaces	Ermöglicht `input` das Einschließen von führenden, nachgestellten und inneren Leerzeichen, die nicht durch `formats`. Alle zusätzlichen Leerzeichen, die im übereinstimmenden Element `formats` nicht angegeben sind, werden beim Analysieren der Zeichenfolge ignoriert.
None	Gibt an, dass zusätzlicher Leerraum nicht `input`zulässig ist. Leerzeichen müssen genau wie in einem bestimmten Element `formats` angegeben angezeigt werden, damit eine Übereinstimmung eintritt. Dies ist das Standardverhalten.
RoundtripKind	Hat keine Auswirkung, da die DateTimeOffset Struktur keine Eigenschaft enthält `Kind` .

Gilt für:

Feedback

War diese Seite hilfreich?

Freigeben über

DateTimeOffset.ParseExact Methode

Definition

Überlädt

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

Parameter

Gibt zurück

Ausnahmen

Beispiele

Hinweise

Hinweise für Aufrufer

Weitere Informationen

Gilt für:

ParseExact(String, String, IFormatProvider, DateTimeStyles)

Parameter

Gibt zurück

Ausnahmen

Beispiele

Hinweise

Hinweise für Aufrufer

Weitere Informationen

Gilt für:

ParseExact(String, String, IFormatProvider)

Parameter

Gibt zurück

Ausnahmen

Beispiele

Hinweise

Hinweise für Aufrufer

Weitere Informationen

Gilt für:

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

Parameter

Gibt zurück

Ausnahmen

Hinweise

Gilt für:

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

Parameter

Gibt zurück

Ausnahmen

Hinweise

Gilt für:

Feedback