DateTimeOffset.ParseExact Methode

Referenz

Definition

Namespace:: System

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 einer Datums- und Uhrzeitangabe in die DateTimeOffset-Entsprechung. Das Format der Zeichenfolgendarstellung muss einem angegebenen Format genau entsprechen.

Überlädt

ParseExact(String, String[], IFormatProvider, DateTimeStyles)	Konvertiert die angegebene Zeichenfolgendarstellung einer Datums- und Uhrzeitangabe unter Verwendung der angegebenen Formate, kulturspezifischen Formatierungsinformationen und des Stils in den entsprechenden DateTimeOffset. Das Format der Zeichenfolgendarstellung muss einem der angegebenen Formate genau entsprechen.
ParseExact(String, String, IFormatProvider, DateTimeStyles)	Konvertiert die angegebene Zeichenfolgenentsprechung einer Datums- und Uhrzeitangabe unter Verwendung der Angaben über Format, kulturabhängige Formatierungsinformationen und Stil in die entsprechende DateTimeOffset. Das Format der Zeichenfolgendarstellung muss dem angegebenen Format genau entsprechen.
ParseExact(String, String, IFormatProvider)	Konvertiert die angegebene Zeichenfolgenentsprechung einer Datums- und Uhrzeitangabe unter Verwendung des angegebenen Formats und der angegebenen kulturabhängigen Formatierungsinformationen in die entsprechende DateTimeOffset. Das Format der Zeichenfolgendarstellung muss dem angegebenen Format genau entsprechen.
ParseExact(ReadOnlySpan<Char>, ReadOnlySpan<Char>, IFormatProvider, DateTimeStyles)	Konvertiert einen Zeichenbereich, der eine Datums- und Uhrzeitangabe darstellt, unter Verwendung der Angaben über Format, kulturabhängige Formatierungsinformationen und Stil in den entsprechenden DateTimeOffset. Das Format der Darstellung von Datum und Uhrzeit muss dem angegebenen Format genau entsprechen.
ParseExact(ReadOnlySpan<Char>, String[], IFormatProvider, DateTimeStyles)	Konvertiert einen Zeichenbereich mit der Zeichenfolgendarstellung einer Datums- und Uhrzeitangabe unter Verwendung der Angaben über Format, kulturabhängige Formatierungsinformationen und Stil in den entsprechenden DateTimeOffset. Das Format der Darstellung von Datum und Uhrzeit muss einem der angegebenen Formate genau entsprechen.

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

Konvertiert die angegebene Zeichenfolgendarstellung einer Datums- und Uhrzeitangabe unter Verwendung der angegebenen Formate, kulturspezifischen Formatierungsinformationen und des Stils in den entsprechenden DateTimeOffset. Das Format der Zeichenfolgendarstellung muss einem der angegebenen Formate genau entsprechen.

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 eine zu konvertierende Datums- und Zeitangabe enthält.

formats: String[]

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

formatProvider: IFormatProvider

Ein Objekt, das kulturspezifische Formatierungsinformationen zu input bereitstellt.

styles: DateTimeStyles

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

Gibt zurück

DateTimeOffset

Ein Objekt, das der im input-Parameter enthaltenen Datums- und Uhrzeitangabe nach den Angaben der Parameter formats, formatProvider und styles entspricht.

Ausnahmen

ArgumentException

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

- oder -

styles beinhaltet 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 einer Datums- und Uhrzeitangabe.

- oder -

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

oder -

Die Komponente für Stunden und der AM/PM-Kennzeichner in input stimmen nicht überein.

Beispiele

Im folgenden Beispiel werden mehrere Eingabeformate für die Zeichenfolgendarstellung eines Datums- und Uhrzeit- und Offsetwerts definiert und dann die Zeichenfolge übergeben, die vom Benutzer an die DateTimeOffset.ParseExact(String, String[], IFormatProvider, DateTimeStyles) Methode eingegeben wird.

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 formats Parameter zugewiesenen Muster entspricht. Wenn die input Zeichenfolge keine dieser Muster mit einer der vom styles Parameter definierten Variationen übereinstimmt, löst die Methode eine FormatException. Abgesehen vom Vergleich input zu 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 Standarddatums- und Uhrzeitformatzeichenfolgen und benutzerdefinierte Datums- und Uhrzeitformatzeichenfolgen. Wenn das übereinstimmende Element formats die z``zzBezeichner oder zzz benutzerdefinierte Formatbezeichner enthält, 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 eine FormatException.

Wichtig

Die Verwendung des formats Parameters dieser Überladung zum Angeben mehrerer Formate kann dazu beitragen, die Frustration vieler Benutzer zu verringern, wenn sie Datums- und Uhrzeitangaben eingeben. Insbesondere ermöglicht die Definition mehrerer Eingabemuster eine Anwendung, Datums- und Uhrzeitdarstellungen zu verarbeiten, die entweder führende Nullen in Monaten, Tagen, Stunden, Minuten und Sekunden enthalten oder fehlen können. Im Beispiel wird dies veranschaulicht.

Wenn das übereinstimmene Element formats ein input Datum, aber keine Uhrzeit enthält, wird dem resultierenden DateTimeOffset Objekt eine Mitternachtszeit (0:00:00:00) zugewiesen. Wenn das übereinstimmene Element formats erforderlich ist, das input eine Uhrzeit, aber kein Datum enthält, wird dem resultierenden DateTimeOffset Objekt das aktuelle Datum im lokalen System zugewiesen. Wenn das übereinstimmene Element formats in keinem Offset erfordert input , hängt der Offset des resultierenden DateTimeOffset Objekts vom Wert des styles Parameters ab. Wenn styles der Offset der lokalen Zeitzone eingeschlossen AssumeLocalist, wird dem Objekt der DateTimeOffset Offset zugewiesen. Wenn styles der Utc-Offset (Coordinated Universal Time) oder +00:00 enthalten AssumeUniversalist, wird dem Objekt zugewiesen DateTimeOffset . Wenn kein Wert angegeben wird, wird der Offset der lokalen Zeitzone verwendet.

Die angegebenen Datums- und Uhrzeitsymbole und Zeichenfolgen input werden vom 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 das ist 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 Aufzählung werden außer unterstützt NoCurrentDateDefault. In der folgenden Tabelle sind die Auswirkungen der einzelnen unterstützten Member aufgeführt.

`DateTimeStyles` -Member	Verhalten
AdjustToUniversal	`input` Analysiert und konvertiert sie ggf. in UTC. Es entspricht der Analyse einer Zeichenfolge und dem Aufrufen der DateTimeOffset.ToUniversalTime Methode des zurückgegebenen DateTimeOffset Objekts.
AssumeLocal	Wenn das übereinstimmene Element in `formats` nicht erfordert, dass `input` ein Offsetwert enthalten ist, erhält das zurückgegebene DateTimeOffset Objekt den Offset der lokalen Zeitzone. Dies ist der Standardwert.
AssumeUniversal	Wenn das übereinstimmende Element `formats` nicht erfordert, dass `input` ein Offsetwert enthalten ist, erhält das zurückgegebene DateTimeOffset Objekt den UTC-Offset (+00:00).
AllowInnerWhite	Ermöglicht `input` es, inneren Leerraum einzuschließen, 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 es `input` , führende Leerzeichen einzuschließen, die nicht durch `formats`. Diese werden beim Analysieren der Zeichenfolge ignoriert.
AllowTrailingWhite	Ermöglicht `input` das Einschließen von nachgestellten Leerzeichen, die nicht durch `formats`. Diese werden beim Analysieren der Zeichenfolge ignoriert.
AllowWhiteSpaces	Ermöglicht es `input` , führende, nachgestellte und innere Leerzeichen einzuschließen, 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 zulässig `input`ist. Leerzeichen müssen genau wie in einem bestimmten Element `formats` angegeben angezeigt werden, damit eine Übereinstimmung auftritt. Dies ist das Standardverhalten.
RoundtripKind	Hat keine Auswirkung, da die DateTimeOffset Struktur keine Eigenschaft enthält `Kind` .

Hinweise für Aufrufer

In der .NET Framework 4 löst die ParseExact Methode einFormatException, wenn die zu analysierende Zeichenfolge eine Stundenkomponente und einen AM/PM-Designator enthält, der nicht in Übereinstimmung steht. In den .NET Framework 3.5 und früheren Versionen wird der AM/PM-Designator ignoriert.

Siehe auch

Gilt für

ParseExact(String, String, IFormatProvider, DateTimeStyles)

Konvertiert die angegebene Zeichenfolgenentsprechung einer Datums- und Uhrzeitangabe unter Verwendung der Angaben über Format, kulturabhängige Formatierungsinformationen und Stil in die entsprechende DateTimeOffset. Das Format der Zeichenfolgendarstellung muss dem angegebenen Format genau entsprechen.

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 eine zu konvertierende Datums- und Zeitangabe enthält.

format: String

Ein Formatbezeichner, der das erwartete Format von input definiert.

formatProvider: IFormatProvider

Ein Objekt, das kulturspezifische Formatierungsinformationen zu input bereitstellt.

styles: DateTimeStyles

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

Gibt zurück

DateTimeOffset

Ein Objekt, das der im input-Parameter enthaltenen Datums- und Uhrzeitangabe nach den Angaben der Parameter format, formatProvider und styles entspricht.

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 einer Datums- und Uhrzeitangabe.

- oder -

format ist eine leere Zeichenfolge.

- oder -

Die Komponente für Stunden und der AM/PM-Kennzeichner in input stimmen nicht überein.

Beispiele

Im folgenden Beispiel wird die DateTimeOffset.ParseExact(String, String, IFormatProvider, DateTimeStyles) Methode mit Standard- und benutzerdefinierten Formatbezeichnern, der invarianten Kultur und verschiedenen Werten verwendet, um mehrere DateTimeStyles 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 der ISO 8601 entsprechen sollen. Wie die Ausgabe aus dem Beispiel gezeigt wird, können Zeichenfolgen, die sich im richtigen Format befinden, nicht analysiert werden, wenn:

sie enthalten Leerzeichen und ein entsprechendes DateTimeStyles Flag (z DateTimeStyles.AllowWhiteSpaces . B. nicht im Methodenaufruf angegeben).
sie enthalten Datums- und Uhrzeitelemente, die außerhalb des Bereichs liegen.

Zeichenfolgen, die keinen UTC-Offset angeben, werden angenommen, dass der Offset der lokalen Zeitzone (in diesem Fall -07:00) vorhanden ist, sofern das DateTimeStyles.AssumeUniversal Flag im Methodenaufruf angegeben wird. In diesem Fall wird davon ausgegangen, dass sie universelle koordinierte Zeit sein.

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 sich im format, das vom format Parameter definiert ist. Außerdem ist erforderlich, dass die <Time><Date>Zeichenfolgendarstellung eines Datums und <Offset> der Uhrzeit in der angegebenen formatReihenfolge angezeigt wird. Wenn die input Zeichenfolge nicht mit dem styles Muster des format Parameters übereinstimmt, mit beliebigen Variationen, die vom Parameter definiert sind, löst die Methode eine FormatException. Im Gegensatz dazu analysiert die DateTimeOffset.Parse(String, IFormatProvider, DateTimeStyles) Methode die Zeichenfolgendarstellung eines Datums in einem der von dem Objekt des Formatanbieters DateTimeFormatInfo erkannten Formate. Parse Ermöglicht auch die <Date>Darstellung <Time>der Zeichenfolgendarstellung eines Datums und <Offset> einer Uhrzeit in beliebiger Reihenfolge.

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

Wenn format erforderlich ist, dass input ein Datum, aber keine Uhrzeit enthalten ist, wird dem resultierenden DateTimeOffset Objekt eine Mitternachtszeit zugewiesen (0:00:00). Wenn format erforderlich ist, dass eine input Uhrzeit, aber kein Datum enthalten ist, wird das resultierende DateTimeOffset Objekt dem aktuellen 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 sie enthalten AssumeLocalist, wird der Offset der lokalen Zeitzone dem DateTimeOffset Objekt zugewiesen. Wenn styles sie enthalten AssumeUniversalist, wird DateTimeOffset dem Objekt der koordinierten Universellen Zeit (UTC)-Offset oder +00:00 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. Dasselbe gilt für das genaue Format von input, wenn format es sich um eine Standardformat-Zeichenfolge handelt. Der formatProvider Parameter kann eine der folgenden Sein:

Ein CultureInfo Objekt, das die Kultur darstellt input , auf deren 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 es formatprovider nullsich um ein CultureInfo Objekt handelt, das der aktuellen Kultur entspricht, wird verwendet.

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. Alle Elemente der DateTimeStyles Aufzählung werden unterstützt, außer NoCurrentDateDefault. In der folgenden Tabelle wird der Effekt jedes unterstützten Elements aufgelistet.

`DateTimeStyles` -Member	Verhalten
AdjustToUniversal	`input` Analysiert und konvertiert sie bei Bedarf in UTC. Es entspricht dem Analysieren einer Zeichenfolge, und rufen Sie dann die DateTimeOffset.ToUniversalTime Methode des zurückgegebenen DateTimeOffset Objekts auf.
AssumeLocal	Wenn `format` kein Offsetwert erforderlich `input` ist, wird das zurückgegebene DateTimeOffset Objekt dem Offset der lokalen Zeitzone zugeordnet. 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`angegeben wird. Zusätzliche Leerzeichen können zwischen Datums- und Uhrzeitkomponenten und innerhalb einzelner Komponenten angezeigt werden und beim Analysieren der Zeichenfolge ignoriert werden.
AllowLeadingWhite	Ermöglicht `input` das Einschließen von führenden Leerzeichen, die nicht durch `format`angegeben werden. Diese werden beim Analysieren der Zeichenfolge ignoriert.
AllowTrailingWhite	Ermöglicht `input` es, nachgestellte Leerzeichen nicht angegeben `format`zu enthalten. 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`angegeben werden. Alle zusätzlichen Leerzeichen, die nicht angegeben `format` sind, werden beim Analysieren der Zeichenfolge ignoriert.
None	Gibt an, dass zusätzlicher Leerraum nicht zulässig `input`ist. Leerzeichen müssen genau wie in `format`angegeben angezeigt werden. Dies ist das Standardverhalten.
RoundtripKind	Hat keinen Effekt, da die DateTimeOffset Struktur keine Eigenschaft enthält `Kind` .

Hinweise für Aufrufer

In der .NET Framework 4 wird eine FormatException Methode ausgelöst, wenn die ParseExact zu analysierende Zeichenfolge eine Stundenkomponente und ein AM/PM-Designator enthält, der nicht in Übereinstimmung ist. Im .NET Framework 3.5 und früheren Versionen wird der AM/PM-Designator ignoriert.

Siehe auch

Gilt für

ParseExact(String, String, IFormatProvider)

Konvertiert die angegebene Zeichenfolgenentsprechung einer Datums- und Uhrzeitangabe unter Verwendung des angegebenen Formats und der angegebenen kulturabhängigen Formatierungsinformationen in die entsprechende DateTimeOffset. Das Format der Zeichenfolgendarstellung muss dem angegebenen Format genau entsprechen.

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 eine zu konvertierende Datums- und Zeitangabe enthält.

format: String

Ein Formatbezeichner, der das erwartete Format von input definiert.

formatProvider: IFormatProvider

Ein Objekt, das kulturspezifische Formatierungsinformationen zu input bereitstellt.

Gibt zurück

DateTimeOffset

Ein Objekt, das der in input enthaltenen Datums- und Uhrzeitangabe nach den Angaben von format und formatProvider entspricht.

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 einer Datums- und Uhrzeitangabe.

- oder -

format ist eine leere Zeichenfolge.

- oder -

Die Komponente für Stunden und der AM/PM-Kennzeichner in input stimmen nicht überein.

Beispiele

Im folgenden Beispiel wird 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 voraussichtlich iso 8601 entsprechen. Wie die Ausgabe aus dem Beispiel zeigt, können Zeichenfolgen mit führenden oder nachgestellten Leerzeichen nicht erfolgreich analysiert werden, 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 enthalten sein muss. Außerdem ist erforderlich, dass die <Date>Elemente <Time>und <Offset> Elemente 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. Parseermöglicht auch die <Date><Time><Offset> Darstellung der Zeichenfolgendarstellung eines Datums und der Uhrzeit in einer beliebigen 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 Standarddatums- und Uhrzeitformatzeichenfolgen und benutzerdefinierte Datums- und Uhrzeitformatzeichenfolgen. Wenn format die z``zzBezeichner oder 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 eine FormatException.

Wenn format erforderlich ist, dass ein input Datum, aber keine Uhrzeit enthalten ist, wird dem resultierenden DateTimeOffset Objekt eine Mitternachtszeit zugewiesen (0:00:00). Wenn format erforderlich ist, dass eine input Uhrzeit, aber kein Datum enthalten ist, wird dem resultierenden DateTimeOffset Objekt das aktuelle Datum im lokalen System zugewiesen. Wenn format kein Offset erforderlich input ist, wird dem resultierenden DateTimeOffset Objekt der Zeitzonenversatz des lokalen Systems zugewiesen.

Die angegebenen Datums- und Uhrzeitsymbole und Zeichenfolgen input werden durch den formatProvider Parameter definiert, wie das genaue Format, 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 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 das ist null, wird das CultureInfo Objekt verwendet, das der aktuellen Kultur entspricht.

Hinweise für Aufrufer

Siehe auch

Gilt für

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

Konvertiert einen Zeichenbereich, der eine Datums- und Uhrzeitangabe darstellt, unter Verwendung der Angaben über Format, kulturabhängige Formatierungsinformationen und Stil in den entsprechenden DateTimeOffset. Das Format der Darstellung von Datum und Uhrzeit muss dem angegebenen Format genau entsprechen.

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 mit einem Formatspezifizierer, der das erwartete Format von input definiert.

formatProvider: IFormatProvider

Ein Objekt, das kulturspezifische Formatierungsinformationen zu input bereitstellt.

styles: DateTimeStyles

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

Gibt zurück

DateTimeOffset

Ein Objekt, das der im input-Parameter enthaltenen Datums- und Uhrzeitangabe nach den Angaben der Parameter format, formatProvider und styles entspricht.

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 einer leerer Zeichenbereich. oder input enthält keine gültige Zeichenfolgendarstellung eines Datums und einer Uhrzeit. oder format ist einer leerer Zeichenbereich. -oder- Die Stundenkomponente und der AM/PM-Designator input stimmen nicht überein.

Hinweise

Diese Methode analysiert einen Zeichenbereich, der ein Datum darstellt, das im durch den format Parameter definierten Format enthalten sein muss. Außerdem ist erforderlich, dass die <Date>Elemente <Time>und <Offset> Elemente 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. Parseermöglicht auch die <Date><Time><Offset> Darstellung der Zeichenfolgendarstellung eines Datums und der Uhrzeit in einer beliebigen Reihenfolge.

Der format Parameter ist ein Zeichenbereich, der entweder einen 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 Standarddatums- und Uhrzeitformatzeichenfolgen und benutzerdefinierte Datums- und Uhrzeitformatzeichenfolgen. Wenn format die z``zzBezeichner oder 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 eine FormatException.

Die angegebenen Datums- und Uhrzeitsymbole und Zeichenfolgen input werden durch den formatProvider Parameter definiert, 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 das ist null, wird das CultureInfo Objekt verwendet, das der aktuellen Kultur entspricht.

Gilt für

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

Konvertiert einen Zeichenbereich mit der Zeichenfolgendarstellung einer Datums- und Uhrzeitangabe unter Verwendung der Angaben über Format, kulturabhängige Formatierungsinformationen und Stil in den entsprechenden DateTimeOffset. Das Format der Darstellung von Datum und Uhrzeit muss einem der angegebenen Formate genau entsprechen.

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 die zu konvertierende Datums- und Zeitangabe enthält.

formats: String[]

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

formatProvider: IFormatProvider

Ein Objekt, das kulturspezifische Formatierungsinformationen zu input bereitstellt.

styles: DateTimeStyles

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

Gibt zurück

DateTimeOffset

Ein Objekt, das der im input-Parameter enthaltenen Datums- und Uhrzeitangabe nach den Angaben der Parameter formats, formatProvider und styles entspricht.

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 einer 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-Designator stimmen input nicht überein.

Hinweise

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

Wichtig

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 das ist null, wird das CultureInfo Objekt verwendet, das der aktuellen Kultur entspricht.

`DateTimeStyles` -Member	Verhalten
AdjustToUniversal	`input` Analysiert und konvertiert sie bei Bedarf in UTC. Es entspricht dem Analysieren einer Zeichenfolge, und rufen Sie dann die DateTimeOffset.ToUniversalTime Methode des zurückgegebenen DateTimeOffset Objekts auf.
AssumeLocal	Wenn das übereinstimmene Element in `formats` nicht erforderlich ist, dass `input` ein Offsetwert enthalten ist, wird das zurückgegebene DateTimeOffset Objekt dem Offset der lokalen Zeitzone zugeordnet. Dies ist der Standardwert.
AssumeUniversal	Wenn das übereinstimmende Element in `formats` nicht erforderlich ist, dass `input` ein Offsetwert enthalten 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`angegeben wird. Zusätzliche Leerzeichen können 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` das Einschließen von führenden Leerzeichen, die nicht durch `formats`angegeben werden. Diese werden beim Analysieren der Zeichenfolge ignoriert.
AllowTrailingWhite	Ermöglicht `input` es, nachgestellte Leerzeichen nicht angegeben `formats`zu enthalten. 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`angegeben werden. 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 zulässig `input`ist. Leerzeichen müssen genau wie in einem bestimmten Element `formats` für eine Übereinstimmung angezeigt werden, die auftreten soll. Dies ist das Standardverhalten.
RoundtripKind	Hat keinen Effekt, da die DateTimeOffset Struktur keine Eigenschaft enthält `Kind` .

Gilt für

Freigeben über

DateTimeOffset.ParseExact Methode

Definition

Überlädt

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

Parameter

Gibt zurück

Ausnahmen

Beispiele

Hinweise

Hinweise für Aufrufer

Siehe auch

Gilt für

ParseExact(String, String, IFormatProvider, DateTimeStyles)

Parameter

Gibt zurück

Ausnahmen

Beispiele

Hinweise

Hinweise für Aufrufer

Siehe auch

Gilt für

ParseExact(String, String, IFormatProvider)

Parameter

Gibt zurück

Ausnahmen

Beispiele

Hinweise

Hinweise für Aufrufer

Siehe auch

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

Zusätzliche Ressourcen