DateTime.Parse Methode

Definition

Namespace:

System

Assembly:

System.Runtime.dll

Konvertiert die Zeichenfolgendarstellung eines Datums und einer Uhrzeit in dessen DateTime Äquivalent.

Überlädt

Parse(String)	Konvertiert die Zeichenfolgendarstellung eines Datums und einer Uhrzeit in seine DateTime Entsprechung mithilfe der Konventionen der aktuellen Kultur.
Parse(ReadOnlySpan<Char>, IFormatProvider)	Analysiert eine Spanne von Zeichen in einen Wert.
Parse(String, IFormatProvider)	Konvertiert die Zeichenfolgendarstellung eines Datums und einer Uhrzeit in dessen DateTime Äquivalent mithilfe von kulturspezifischen Formatinformationen.
Parse(ReadOnlySpan<Char>, IFormatProvider, DateTimeStyles)	Konvertiert eine Speicherspanne, die eine Zeichenfolgendarstellung eines Datums und einer Uhrzeit enthält, in dessen DateTime entspreche, indem kulturspezifische Formatinformationen und eine Formatierungsformatvorlage verwendet werden.
Parse(String, IFormatProvider, DateTimeStyles)	Konvertiert die Zeichenfolgendarstellung eines Datums und einer Uhrzeit in seine DateTime Entsprechung mithilfe kulturspezifischer Formatinformationen und einer Formatierungsformatvorlage.

Beispiele

Zahlreiche Beispiele, in denen die DateTime.Parse-Methode aufgerufen wird, werden im gesamten abschnitt Anmerkungen abschnitt dieses Artikels und in der Dokumentation für die einzelnen DateTime.Parse-Überladungen interspersiert.

Anmerkung

Einige C#-Beispiele in diesem Artikel werden im Try.NET Inlinecode-Runner und Playground ausgeführt. Wählen Sie Ausführen aus, um ein Beispiel in einem interaktiven Fenster auszuführen. Nachdem Sie den Code ausgeführt haben, können Sie ihn ändern und den geänderten Code ausführen, indem Sie Ausführen erneut auswählen. Der geänderte Code wird entweder im interaktiven Fenster ausgeführt, oder, wenn die Kompilierung fehlschlägt, zeigt das interaktive Fenster alle C#-Compilerfehlermeldungen an.

Die lokalen Zeitzone des Try.NET Inlinecodeläufers und Playgrounds ist koordinierte Weltzeit oder UTC. Dies kann sich auf das Verhalten und die Ausgabe von Beispielen auswirken, die die DateTime, DateTimeOffsetund TimeZoneInfo Typen und deren Member veranschaulichen.

Sie können auch einen vollständigen Satz von DateTime.Parse Beispielen herunterladen, die in einem .NET Core-Projekt für C#-enthalten sind.

Hinweise

In diesem Abschnitt:

• Welche Methode wird aufgerufen?
• Die zu analysierende Zeichenfolge
• Parsing und kulturelle Konventionen
• Analyse- und Formatelemente
• Der Rückgabewert und dateTime.Kind-

Welche Methode wird aufgerufen?

An	Rufen
Analysieren Sie eine Datums- und Uhrzeitzeichenfolge mithilfe der Konventionen der aktuellen Kultur.	Parse(String) Überladung
Analysieren Sie eine Datums- und Uhrzeitzeichenfolge mithilfe der Konventionen einer bestimmten Kultur.	Parse(String, IFormatProvider) Überladung (siehe Parsing and Cultural Conventions)
Analysieren Sie eine Datums- und Uhrzeitzeichenfolge mit speziellen Formatvorlagenelementen (z. B. Leerzeichen oder keine Leerzeichen).	Parse(String, IFormatProvider, DateTimeStyles) Überladung
Analysieren Sie eine Datums- und Uhrzeitzeichenfolge, die in einem bestimmten Format vorliegen muss.	DateTime.ParseExact oder DateTime.TryParseExact
Analysieren Sie eine Datums- und Uhrzeitzeichenfolge, und führen Sie eine Konvertierung in UTC- oder Ortszeit durch.	Parse(String, IFormatProvider, DateTimeStyles) Überladung
Analysieren Sie eine Datums- und Uhrzeitzeichenfolge ohne Ausnahmebehandlung.	DateTime.TryParse-Methode
Wiederherstellen (Roundtrip) eines Datums- und Uhrzeitwerts, der durch einen Formatierungsvorgang erstellt wird.	Übergeben Sie die Standardformatzeichenfolge "o" oder "r" an die ToString(String)-Methode, und rufen Sie die Parse(String, IFormatProvider, DateTimeStyles)-Überladung mit DateTimeStyles.RoundtripKind
Analysieren Sie eine Datums- und Uhrzeitzeichenfolge in einem festen Format über computerübergreifende (und möglicherweise kulturelle) Grenzen hinweg.	DateTime.ParseExact- oder DateTime.TryParseExact-Methode

Die zu analysierende Zeichenfolge

Die Parse-Methode versucht, die Zeichenfolgendarstellung eines Datums- und Uhrzeitwerts in das DateTime Äquivalent zu konvertieren. Es versucht, die Eingabezeichenfolge vollständig zu analysieren, ohne eine FormatException Ausnahme auszuwerfen.

Wichtig

Wenn der Analysevorgang aufgrund eines unbekannten Zeichenfolgenformats fehlschlägt, löst die Parse-Methode eine FormatExceptionaus, während die TryParse-Methode falsezurückgibt. Da die Ausnahmebehandlung teuer sein kann, sollten Sie Parse verwenden, wenn der Analysevorgang erfolgreich ausgeführt werden soll, da die Eingabequelle vertrauenswürdig ist. TryParse ist vorzuziehen, wenn Analysefehler wahrscheinlich sind, insbesondere weil eine Eingabequelle nicht vertrauenswürdig ist, oder Sie über angemessene Standardwerte verfügen, die durch Zeichenfolgen ersetzt werden, die nicht erfolgreich analysiert werden.

Die zu analysierende Zeichenfolge kann eine der folgenden Formen annehmen:

• Eine Zeichenfolge mit einer Datums- und Einer Uhrzeitkomponente.

• Eine Zeichenfolge mit einem Datum, aber keine Zeitkomponente. Wenn die Zeitkomponente nicht vorhanden ist, geht die Methode von 12:00 Mitternacht aus. Wenn die Datumskomponente ein zweistelliges Jahr aufweist, wird sie basierend auf dem Calendar.TwoDigitYearMax des aktuellen Kalenders der aktuellen Kultur oder des aktuellen Kalenders der angegebenen Kultur in ein Jahr konvertiert (wenn Sie eine Überladung mit einem Argument ungleich Null provider verwenden).

• Eine Zeichenfolge mit einer Datumskomponente, die nur den Monat und das Jahr, aber keine Tageskomponente enthält. Die Methode setzt den ersten Tag des Monats voraus.

• Eine Zeichenfolge mit einer Datumskomponente, die nur den Monat und den Tag, aber keine Jahreskomponente enthält. Die Methode geht vom aktuellen Jahr aus.

• Eine Zeichenfolge mit einer Uhrzeit, aber keine Datumskomponente. Die Methode setzt das aktuelle Datum voraus, es sei denn, Sie rufen die Parse(String, IFormatProvider, DateTimeStyles) Überladung auf und schließen DateTimeStyles.NoCurrentDateDefault in das Argument styles ein, in diesem Fall wird von der Methode ein Datum vom 1. Januar 0001 angenommen.

• Eine Zeichenfolge mit einer Zeitkomponente, die nur die Stunde und einen AM/PM-Kennzeichner ohne Datumskomponente enthält. Die Methode setzt das aktuelle Datum und eine Uhrzeit ohne Minuten und keine Sekunden voraus. Sie können dieses Verhalten ändern, indem Sie die Parse(String, IFormatProvider, DateTimeStyles)-Überladung aufrufen und DateTimeStyles.NoCurrentDateDefault in das argument styles einschließen, in diesem Fall wird von der Methode ein Datum vom 1. Januar 0001 angenommen.

• Eine Zeichenfolge, die Zeitzoneninformationen enthält und iso 8601 entspricht. In den folgenden Beispielen bezeichnet die erste Zeichenfolge koordinierte Weltzeit (COORDINATED Universal Time, UTC) und die zweite die Uhrzeit in einer Zeitzone, die sieben Stunden vor UTC liegt:

  "2008-11-01T19:35:00.0000000Z" "2008-11-01T19:35:00.0000000-07:00"

• Eine Zeichenfolge, die den GMT-Kennzeichner enthält und dem RFC 1123-Zeitformat entspricht; Zum Beispiel:

  "Sa, 01 Nov 2008 19:35:00 GMT"

• Eine Zeichenfolge, die das Datum und die Uhrzeit zusammen mit Informationen zum Offset der Zeitzone enthält; Zum Beispiel:

  "03/01/2009 05:42:00 -5:00"

Im folgenden Beispiel werden Zeichenfolgen in jedem dieser Formate mithilfe der Formatierungskonventionen der aktuellen Kultur analysiert, die in diesem Fall die en-US Kultur ist:

using System;

public class Example
{
   public static void Main()
   {
      (string dateAsString, string description)[]  dateInfo = { ("08/18/2018 07:22:16", "String with a date and time component"),
                                                                ("08/18/2018", "String with a date component only"),
                                                                ("8/2018", "String with a month and year component only"),
                                                                ("8/18", "String with a month and day component only"),
                                                                ("07:22:16", "String with a time component only"),
                                                                ("7 PM", "String with an hour and AM/PM designator only"),
                                                                ("2018-08-18T07:22:16.0000000Z", "UTC string that conforms to ISO 8601"),
                                                                ("2018-08-18T07:22:16.0000000-07:00", "Non-UTC string that conforms to ISO 8601"),
                                                                ("Sat, 18 Aug 2018 07:22:16 GMT", "String that conforms to RFC 1123"),
                                                                ("08/18/2018 07:22:16 -5:00", "String with date, time, and time zone information" ) };

      Console.WriteLine($"Today is {DateTime.Now:d}\n");

      foreach (var item in dateInfo) {
         Console.WriteLine($"{item.description + ":",-52} '{item.dateAsString}' --> {DateTime.Parse(item.dateAsString)}");
      }
   }
}
// The example displays output like the following:
//   Today is 2/22/2018
//
//   String with a date and time component:               '08/18/2018 07:22:16' --> 8/18/2018 7:22:16 AM
//   String with a date component only:                   '08/18/2018' --> 8/18/2018 12:00:00 AM
//   String with a month and year component only:         '8/2018' --> 8/1/2018 12:00:00 AM
//   String with a month and day component only:          '8/18' --> 8/18/2018 12:00:00 AM
//   String with a time component only:                   '07:22:16' --> 2/22/2018 7:22:16 AM
//   String with an hour and AM/PM designator only:       '7 PM' --> 2/22/2018 7:00:00 PM
//   UTC string that conforms to ISO 8601:                '2018-08-18T07:22:16.0000000Z' --> 8/18/2018 12:22:16 AM
//   Non-UTC string that conforms to ISO 8601:            '2018-08-18T07:22:16.0000000-07:00' --> 8/18/2018 7:22:16 AM
//   String that conforms to RFC 1123:                    'Sat, 18 Aug 2018 07:22:16 GMT' --> 8/18/2018 12:22:16 AM
//   String with date, time, and time zone information:   '08/18/2018 07:22:16 -5:00' --> 8/18/2018 5:22:16 AM

module Parse6

open System

let  dateInfo = 
    [ "08/18/2018 07:22:16", "String with a date and time component"
      "08/18/2018", "String with a date component only"
      "8/2018", "String with a month and year component only"
      "8/18", "String with a month and day component only"
      "07:22:16", "String with a time component only"
      "7 PM", "String with an hour and AM/PM designator only"
      "2018-08-18T07:22:16.0000000Z", "UTC string that conforms to ISO 8601"
      "2018-08-18T07:22:16.0000000-07:00", "Non-UTC string that conforms to ISO 8601"
      "Sat, 18 Aug 2018 07:22:16 GMT", "String that conforms to RFC 1123"
      "08/18/2018 07:22:16 -5:00", "String with date, time, and time zone information" ]

printfn $"Today is {DateTime.Now:d}\n"

for dateAsString, description in dateInfo do
    printfn $"""{description + ":",-52} '{dateAsString}' --> {DateTime.Parse(dateAsString)}"""


// The example displays output like the following:
//   Today is 2/22/2018
//
//   String with a date and time component:               '08/18/2018 07:22:16' --> 8/18/2018 7:22:16 AM
//   String with a date component only:                   '08/18/2018' --> 8/18/2018 12:00:00 AM
//   String with a month and year component only:         '8/2018' --> 8/1/2018 12:00:00 AM
//   String with a month and day component only:          '8/18' --> 8/18/2018 12:00:00 AM
//   String with a time component only:                   '07:22:16' --> 2/22/2018 7:22:16 AM
//   String with an hour and AM/PM designator only:       '7 PM' --> 2/22/2018 7:00:00 PM
//   UTC string that conforms to ISO 8601:                '2018-08-18T07:22:16.0000000Z' --> 8/18/2018 12:22:16 AM
//   Non-UTC string that conforms to ISO 8601:            '2018-08-18T07:22:16.0000000-07:00' --> 8/18/2018 7:22:16 AM
//   String that conforms to RFC 1123:                    'Sat, 18 Aug 2018 07:22:16 GMT' --> 8/18/2018 12:22:16 AM
//   String with date, time, and time zone information:   '08/18/2018 07:22:16 -5:00' --> 8/18/2018 5:22:16 AM

Public Module Strings
   Public Sub Main()
      Dim dateInfo() As (dateAsString As String, description As String) = 
                     { ("08/18/2018 07:22:16", "String with a date and time component"),
                       ("08/18/2018", "String with a date component only"),
                       ("8/2018", "String with a month and year component only"),
                       ("8/18", "String with a month and day component only"),
                       ("07:22:16", "String with a time component only"),
                       ("7 PM", "String with an hour and AM/PM designator only"),
                       ("2018-08-18T07:22:16.0000000Z", "UTC string that conforms to ISO 8601"),   
                       ("2018-08-18T07:22:16.0000000-07:00", "Non-UTC string that conforms to ISO 8601"),
                       ("Sat, 18 Aug 2018 07:22:16 GMT", "String that conforms to RFC 1123"),
                       ("08/18/2018 07:22:16 -5:00", "String with date, time, and time zone information" ) }
   
      Console.WriteLine($"Today is {Date.Now:d}{vbCrLf}")
      
      For Each item in dateInfo
         Console.WriteLine($"{item.description + ":",-52} '{item.dateAsString}' --> {DateTime.Parse(item.dateAsString)}")        
      Next
   End Sub
End Module
' The example displays output like the following:
'   Today is 2/22/2018
'   
'   String with a date and time component:               '08/18/2018 07:22:16' --> 8/18/2018 7:22:16 AM
'   String with a date component only:                   '08/18/2018' --> 8/18/2018 12:00:00 AM
'   String with a month and year component only:         '8/2018' --> 8/1/2018 12:00:00 AM
'   String with a month and day component only:          '8/18' --> 8/18/2018 12:00:00 AM
'   String with a time component only:                   '07:22:16' --> 2/22/2018 7:22:16 AM
'   String with an hour and AM/PM designator only:       '7 PM' --> 2/22/2018 7:00:00 PM
'   UTC string that conforms to ISO 8601:                '2018-08-18T07:22:16.0000000Z' --> 8/18/2018 12:22:16 AM
'   Non-UTC string that conforms to ISO 8601:            '2018-08-18T07:22:16.0000000-07:00' --> 8/18/2018 7:22:16 AM
'   String that conforms to RFC 1123:                    'Sat, 18 Aug 2018 07:22:16 GMT' --> 8/18/2018 12:22:16 AM
'   String with date, time, and time zone information:   '08/18/2018 07:22:16 -5:00' --> 8/18/2018 5:22:16 AM

Wenn die Eingabezeichenfolge einen Schalttag in einem Schaltjahr im Von der Analysemethode verwendeten Kalender darstellt (siehe Parsing und kulturelle Konventionen), analysiert die Parse-Methode die Zeichenfolge erfolgreich. Wenn die Eingabezeichenfolge einen Schalttag in einem Nicht-Schaltjahr darstellt, löst die Methode eine FormatExceptionaus.

Da die Parse-Methode versucht, die Zeichenfolgendarstellung eines Datums und einer Uhrzeit mithilfe der Formatierungsregeln der aktuellen oder einer angegebenen Kultur zu analysieren, kann das Analysieren einer Zeichenfolge in verschiedenen Kulturen fehlschlagen. Um ein bestimmtes Datums- und Uhrzeitformat in verschiedenen Gebietsschemas zu analysieren, verwenden Sie eine der Überladungen der DateTime.ParseExact-Methode, und stellen Sie einen Formatbezeichner bereit.

Analyse und kulturelle Konventionen

Alle Überladungen der Parse-Methode sind kulturempfindlich, es sei denn, die zu analysierende Zeichenfolge (dargestellt durch s in der folgenden Tabelle) entspricht dem ISO 8601-Muster. Der Analysevorgang verwendet die Formatierungsinformationen in einem DateTimeFormatInfo-Objekt, das wie folgt abgeleitet wird:

Wichtig

Äran in den japanischen Kalendern basieren auf der Herrschaft des Kaisers und werden daher voraussichtlich geändert. Beispielsweise markierte der 1. Mai 2019 den Anfang der Reiwa-Ära in der JapaneseCalendar und JapaneseLunisolarCalendar. Eine solche Änderung des Zeitalters wirkt sich auf alle Anwendungen aus, die diese Kalender verwenden. Weitere Informationen und informationen dazu, ob Ihre Anwendungen betroffen sind, finden Sie unter Behandeln einer neuen Ära im japanischen Kalender in .NET. Informationen zum Testen Ihrer Anwendungen auf Windows-Systemen, um ihre Bereitschaft für die Änderung der Ära sicherzustellen, finden Sie unter Vorbereiten Ihrer Anwendung für die Änderung im japanischen Zeitalter. Features in .NET, die Kalender mit mehreren Epochen unterstützen und bewährte Methoden beim Arbeiten mit Kalendern, die mehrere Epochen unterstützen, finden Sie unter Arbeiten mit Eras.

Wenn Sie anrufen	Und provider ist	Formatierungsinformationen werden von
Parse(String)	-	Die aktuelle Kultur (DateTimeFormatInfo.CurrentInfo-Eigenschaft)
Parse(String, IFormatProvider) oder Parse(String, IFormatProvider, DateTimeStyles)	ein DateTimeFormatInfo-Objekt	Das angegebene DateTimeFormatInfo-Objekt
Parse(String, IFormatProvider) oder Parse(String, IFormatProvider, DateTimeStyles)	null	Die aktuelle Kultur (DateTimeFormatInfo.CurrentInfo-Eigenschaft)
Parse(String, IFormatProvider) oder Parse(String, IFormatProvider, DateTimeStyles)	ein CultureInfo-Objekt	Die CultureInfo.DateTimeFormat-Eigenschaft
Parse(String, IFormatProvider) oder Parse(String, IFormatProvider, DateTimeStyles)	Implementierung benutzerdefinierter IFormatProvider	Die IFormatProvider.GetFormat-Methode

Wenn Formatierungsinformationen von einem DateTimeFormatInfo-Objekt abgeleitet werden, definiert die DateTimeFormatInfo.Calendar-Eigenschaft den im Analysevorgang verwendeten Kalender.

Wenn Sie eine Datums- und Uhrzeitzeichenfolge mithilfe eines DateTimeFormatInfo-Objekts mit angepassten Einstellungen analysieren, die sich von denen einer Standardkultur unterscheiden, verwenden Sie die ParseExact-Methode anstelle der Parse-Methode, um die Chancen für eine erfolgreiche Konvertierung zu verbessern. Eine nicht standardmäßige Datums- und Uhrzeitzeichenfolge kann kompliziert und schwierig zu analysieren sein. Die Parse-Methode versucht, eine Zeichenfolge mit mehreren impliziten Analysemustern zu analysieren, die möglicherweise fehlschlagen. Im Gegensatz dazu müssen Sie mit der ParseExact-Methode explizit ein oder mehrere genaue Analysemuster festlegen, die wahrscheinlich erfolgreich sind. Weitere Informationen finden Sie im Abschnitt "DateTimeFormatInfo und Dynamic Data" im thema DateTimeFormatInfo.

Wichtig

Beachten Sie, dass die Formatierungskonventionen für eine bestimmte Kultur dynamisch sind und änderungen unterliegen können. Dies bedeutet, dass Analysevorgänge, die von den Formatierungskonventionen der Standardkultur (aktuellen) Kultur abhängen oder ein IFormatProvider-Objekt angeben, das eine andere Kultur als die invariante Kultur darstellt, unerwartet fehlschlagen kann, wenn eine der folgenden Ereignisse auftritt:

• Die kulturspezifischen Daten wurden zwischen Haupt- oder Nebenversionen von .NET Framework oder als Ergebnis einer Aktualisierung auf die vorhandene Version von .NET Framework geändert.
• Die kulturspezifischen Daten spiegeln die Benutzereinstellungen wider, die von Computer zu Computer oder Sitzung variieren können.
• Die kulturspezifischen Daten stellen eine Ersetzungskultur dar, die die Einstellungen einer Standardkultur oder einer benutzerdefinierten Kultur außer Kraft setzt.

Um die Schwierigkeiten beim Analysieren von Daten- und Zeitzeichenfolgen zu verhindern, die mit Änderungen in Kulturdaten verbunden sind, können Sie Datums- und Uhrzeitzeichenfolgen mithilfe der invarianten Kultur analysieren, oder Sie können die ParseExact- oder TryParseExact-Methode aufrufen und das genaue Format der zu analysierenden Zeichenfolge angeben. Wenn Sie Datums- und Uhrzeitdaten serialisieren und deserialisieren, können Sie entweder die Formatierungskonventionen der invarianten Kultur verwenden, oder Sie können den DateTime Wert in einem Binärformat serialisieren und deserialisieren.

Weitere Informationen finden Sie im Abschnitt "Dynamische Kulturdaten" im CultureInfo Thema und im Abschnitt "Persisting DateTime values" im DateTime Thema.

Analysieren und Formatvorlagenelemente

Alle Parse Überladungen ignorieren führende, innere oder nachfolgende Leerzeichen in der Eingabezeichenfolge (die durch s in der folgenden Tabelle dargestellt wird). Das Datum und die Uhrzeit können mit einem Paar vorangestellter und nachgestellter ZAHLZEICHEN ("#", U+0023) in Klammern gesetzt werden und kann mit einem oder mehreren NULL-Zeichen (U+0000) nachgestellt werden.

Darüber hinaus weist die Parse(String, IFormatProvider, DateTimeStyles) überladung einen styles Parameter auf, der aus einem oder mehreren Membern der DateTimeStyles-Enumeration besteht. Dieser Parameter definiert, wie s interpretiert werden soll und wie der Analysevorgang s in ein Datum und eine Uhrzeit konvertiert werden soll. In der folgenden Tabelle wird die Auswirkung jedes DateTimeStyles Elements auf den Analysevorgang beschrieben.

DateTimeStyles-Mitglied	Auswirkung auf die Konvertierung
AdjustToUniversal	Analysiert s und konvertiert sie bei Bedarf wie folgt in UTC: - Wenn s einen Zeitzonenoffset enthält oder wenn s keine Zeitzoneninformationen enthält, aber styles das AssumeLocal Flag enthält, analysiert die Methode die Zeichenfolge, ruft ToUniversalTime auf, um den zurückgegebenen DateTime Wert in UTC zu konvertieren, und legt die Kind Eigenschaft auf DateTimeKind.Utcfest. - Wenn s angibt, dass es UTC darstellt, oder wenn s keine Zeitzoneninformationen enthält, aber styles das AssumeUniversal Flag enthält, analysiert die Methode die Zeichenfolge, führt keine Zeitzonenkonvertierung für den zurückgegebenen DateTime-Wert aus und legt die Kind Eigenschaft auf DateTimeKind.Utcfest. - In allen anderen Fällen hat die Kennzeichnung keine Auswirkung.
AllowInnerWhite	Dieser Wert wird ignoriert. Innerer Leerraum ist in den Datums- und Uhrzeitelementen von simmer zulässig.
AllowLeadingWhite	Dieser Wert wird ignoriert. Führende Leerzeichen sind immer in den Datums- und Uhrzeitelementen von szulässig.
AllowTrailingWhite	Dieser Wert wird ignoriert. Nachfolgende Leerzeichen sind immer in den Datums- und Uhrzeitelementen von szulässig.
AllowWhiteSpaces	Gibt an, dass s führende, innere und nachfolgende Leerzeichen enthalten kann. Dies ist das Standardverhalten. Es kann nicht außer Kraft gesetzt werden, indem ein restriktiverer DateTimeStyles Enumerationswert wie Nonebereitgestellt wird.
AssumeLocal	Gibt an, dass bei fehlenden Zeitzoneninformationen s lokale Uhrzeit angenommen wird. Sofern das AdjustToUniversal Flag nicht vorhanden ist, wird die Kind Eigenschaft des zurückgegebenen DateTime Werts auf DateTimeKind.Localfestgelegt.
AssumeUniversal	Gibt an, dass bei fehlenden Zeitzoneninformationen s UTC angenommen wird. Sofern das AdjustToUniversal Flag nicht vorhanden ist, konvertiert die Methode den zurückgegebenen DateTime Wert von UTC in die Ortszeit und legt seine Kind Eigenschaft auf DateTimeKind.Localfest.
None	Obwohl gültig, wird dieser Wert ignoriert.
RoundtripKind	Bei Zeichenfolgen, die Zeitzoneninformationen enthalten, wird versucht, die Konvertierung einer Datums- und Uhrzeitzeichenfolge in einen DateTime Wert zu verhindern, der eine lokale Uhrzeit darstellt, deren Kind-Eigenschaft auf DateTimeKind.Localfestgelegt ist. In der Regel wird eine solche Zeichenfolge durch Aufrufen der DateTime.ToString(String)-Methode und mithilfe des Standardformatbezeichners "o", "r" oder "u" erstellt.

Der Rückgabewert und DateTime.Kind

Die DateTime.Parse Überladungen geben einen DateTime Wert zurück, dessen Kind-Eigenschaft Zeitzoneninformationen enthält. Es kann darauf hinweisen, dass die Uhrzeit lautet:

• Koordinierte Weltzeit (System.DateTimeKind.Utc).
• Die Uhrzeit in der lokalen Zeitzone (System.DateTimeKind.Local).
• Die Uhrzeit in einer unbekannten Zeitzone (System.DateTimeKind.Unspecified).

Im Allgemeinen gibt die Parse-Methode ein DateTime Objekt zurück, dessen Kind Eigenschaft DateTimeKind.Unspecifiedist. Die methode Parse kann jedoch auch zeitzonenkonvertierung durchführen und den Wert der Kind Eigenschaft je nach den Werten der parameter s und styles anders festlegen:

Wenn	Zeitzonenkonvertierung	Kind-Eigenschaft
s enthält Zeitzoneninformationen.	Das Datum und die Uhrzeit werden in die Uhrzeit in der lokalen Zeitzone konvertiert.	DateTimeKind.Local
s enthält Zeitzoneninformationen, und styles enthält das AdjustToUniversal Flag.	Datum und Uhrzeit werden in koordinierte Weltzeit (COORDINATED Universal Time, UTC) konvertiert.	DateTimeKind.Utc
s enthält den Z- oder GMT-Zeitzonen-Kennzeichner, und styles enthält das RoundtripKind Flag.	Datum und Uhrzeit werden als UTC interpretiert.	DateTimeKind.Utc

Im folgenden Beispiel werden Datumszeichenfolgen konvertiert, die Zeitzoneninformationen enthalten, in die Uhrzeit in der lokalen Zeitzone:

using System;

public class Example
{
   public static void Main()
   {
      string[] dateStrings = {"2008-05-01T07:34:42-5:00",
                              "2008-05-01 7:34:42Z",
                              "Thu, 01 May 2008 07:34:42 GMT"};
      foreach (string dateString in dateStrings)
      {
         DateTime convertedDate = DateTime.Parse(dateString);
         Console.WriteLine($"Converted {dateString} to {convertedDate.Kind} time {convertedDate}");
      }
   }
}
// These calls to the DateTime.Parse method display the following output:
//  Converted 2008-05-01T07:34:42-5:00 to Local time 5/1/2008 5:34:42 AM
//  Converted 2008-05-01 7:34:42Z to Local time 5/1/2008 12:34:42 AM
//  Converted Thu, 01 May 2008 07:34:42 GMT to Local time 5/1/2008 12:34:42 AM

open System

let dateStrings = 
    [ "2008-05-01T07:34:42-5:00"
      "2008-05-01 7:34:42Z"
      "Thu, 01 May 2008 07:34:42 GMT" ]

for dateString in dateStrings do
    let convertedDate = DateTime.Parse dateString
    printfn $"Converted {dateString} to {convertedDate.Kind} time {convertedDate}"

// These calls to the DateTime.Parse method display the following output:
//  Converted 2008-05-01T07:34:42-5:00 to Local time 5/1/2008 5:34:42 AM
//  Converted 2008-05-01 7:34:42Z to Local time 5/1/2008 12:34:42 AM
//  Converted Thu, 01 May 2008 07:34:42 GMT to Local time 5/1/2008 12:34:42 AM

Module Example
   Public Sub Main()
      Dim dateStrings() As String = {"2008-05-01T07:34:42-5:00", 
                                     "2008-05-01 7:34:42Z", 
                                     "Thu, 01 May 2008 07:34:42 GMT"}
      
      For Each dateStr In dateStrings
         Dim convertedDate As Date = Date.Parse(dateStr)
         Console.WriteLine($"Converted {dateStr} to {convertedDate.Kind} time {convertedDate}")
      Next 
   End Sub
End Module
' These calls to the DateTime.Parse method display the following output:
'   Converted 2008-05-01T07:34:42-5:00 to Local time 5/1/2008 5:34:42 AM
'   Converted 2008-05-01 7:34:42Z to Local time 5/1/2008 12:34:42 AM
'   Converted Thu, 01 May 2008 07:34:42 GMT to Local time 5/1/2008 12:34:42 AM

Sie können auch den Wert der Kind Eigenschaft eines Datums und einer Uhrzeit während eines Formatierungs- und Analysevorgangs beibehalten, indem Sie die DateTimeStyles.RoundtripKind-Kennzeichnung verwenden. Im folgenden Beispiel wird veranschaulicht, wie sich das RoundtripKind Flag auf den Analysevorgang auf DateTime Werte auswirkt, die mithilfe des Formatbezeichners "o", "r" oder "u" in Zeichenfolgen konvertiert werden.

   string[] formattedDates = { "2008-09-15T09:30:41.7752486-07:00",
                               "2008-09-15T09:30:41.7752486Z",
                               "2008-09-15T09:30:41.7752486",
                               "2008-09-15T09:30:41.7752486-04:00",
                               "Mon, 15 Sep 2008 09:30:41 GMT" };
   foreach (string formattedDate in formattedDates)
   {
      Console.WriteLine(formattedDate);
      DateTime roundtripDate = DateTime.Parse(formattedDate, null,
                                              DateTimeStyles.RoundtripKind);
      Console.WriteLine($"   With RoundtripKind flag: {roundtripDate} {roundtripDate.Kind} time.");

      DateTime noRoundtripDate = DateTime.Parse(formattedDate, null,
                                                DateTimeStyles.None);
      Console.WriteLine($"   Without RoundtripKind flag: {noRoundtripDate} {noRoundtripDate.Kind} time.");
   }
// The example displays the following output:
//       2008-09-15T09:30:41.7752486-07:00
//          With RoundtripKind flag: 9/15/2008 9:30:41 AM Local time.
//          Without RoundtripKind flag: 9/15/2008 9:30:41 AM Local time.
//       2008-09-15T09:30:41.7752486Z
//          With RoundtripKind flag: 9/15/2008 9:30:41 AM Utc time.
//          Without RoundtripKind flag: 9/15/2008 2:30:41 AM Local time.
//       2008-09-15T09:30:41.7752486
//          With RoundtripKind flag: 9/15/2008 9:30:41 AM Unspecified time.
//          Without RoundtripKind flag: 9/15/2008 9:30:41 AM Unspecified time.
//       2008-09-15T09:30:41.7752486-04:00
//          With RoundtripKind flag: 9/15/2008 6:30:41 AM Local time.
//          Without RoundtripKind flag: 9/15/2008 6:30:41 AM Local time.
//       Mon, 15 Sep 2008 09:30:41 GMT
//          With RoundtripKind flag: 9/15/2008 9:30:41 AM Utc time.
//          Without RoundtripKind flag: 9/15/2008 2:30:41 AM Local time.

let formattedDates = 
    [ "2008-09-15T09:30:41.7752486-07:00"
      "2008-09-15T09:30:41.7752486Z"
      "2008-09-15T09:30:41.7752486"
      "2008-09-15T09:30:41.7752486-04:00"
      "Mon, 15 Sep 2008 09:30:41 GMT" ]

for formattedDate in formattedDates do
    printfn $"{formattedDate}"
    let roundtripDate = DateTime.Parse(formattedDate, null, DateTimeStyles.RoundtripKind)
    printfn $"   With RoundtripKind flag: {roundtripDate} {roundtripDate.Kind} time."

    let noRoundtripDate = DateTime.Parse(formattedDate, null, DateTimeStyles.None)
    printfn $"   Without RoundtripKind flag: {noRoundtripDate} {noRoundtripDate.Kind} time."

// The example displays the following output:
//       2008-09-15T09:30:41.7752486-07:00
//          With RoundtripKind flag: 9/15/2008 9:30:41 AM Local time.
//          Without RoundtripKind flag: 9/15/2008 9:30:41 AM Local time.
//       2008-09-15T09:30:41.7752486Z
//          With RoundtripKind flag: 9/15/2008 9:30:41 AM Utc time.
//          Without RoundtripKind flag: 9/15/2008 2:30:41 AM Local time.
//       2008-09-15T09:30:41.7752486
//          With RoundtripKind flag: 9/15/2008 9:30:41 AM Unspecified time.
//          Without RoundtripKind flag: 9/15/2008 9:30:41 AM Unspecified time.
//       2008-09-15T09:30:41.7752486-04:00
//          With RoundtripKind flag: 9/15/2008 6:30:41 AM Local time.
//          Without RoundtripKind flag: 9/15/2008 6:30:41 AM Local time.
//       Mon, 15 Sep 2008 09:30:41 GMT
//          With RoundtripKind flag: 9/15/2008 9:30:41 AM Utc time.
//          Without RoundtripKind flag: 9/15/2008 2:30:41 AM Local time.

Dim formattedDates() = { "2008-09-15T09:30:41.7752486-07:00", 
                           "2008-09-15T09:30:41.7752486Z",  
                           "2008-09-15T09:30:41.7752486",  
                           "2008-09-15T09:30:41.7752486-04:00", 
                           "Mon, 15 Sep 2008 09:30:41 GMT" }
For Each formattedDate In formattedDates
   Console.WriteLine(formattedDate)
   Dim roundtripDate = DateTime.Parse(formattedDate, Nothing,  
                                      DateTimeStyles.RoundtripKind)                        
   Console.WriteLine($"   With RoundtripKind flag: {roundtripDate} {roundtripDate.Kind} time.")                                          
   Dim noRoundtripDate = DateTime.Parse(formattedDate, Nothing,                                                                                                  DateTimeStyles.None)
   Console.WriteLine($"   Without RoundtripKind flag: {noRoundtripDate} {noRoundtripDate.Kind} time.")
Next         
' The example displays the following output:
'       2008-09-15T09:30:41.7752486-07:00
'          With RoundtripKind flag: 9/15/2008 9:30:41 AM Local time.
'          Without RoundtripKind flag: 9/15/2008 9:30:41 AM Local time.
'       2008-09-15T09:30:41.7752486Z
'          With RoundtripKind flag: 9/15/2008 9:30:41 AM Utc time.
'          Without RoundtripKind flag: 9/15/2008 2:30:41 AM Local time.
'       2008-09-15T09:30:41.7752486
'          With RoundtripKind flag: 9/15/2008 9:30:41 AM Unspecified time.
'          Without RoundtripKind flag: 9/15/2008 9:30:41 AM Unspecified time.
'       2008-09-15T09:30:41.7752486-04:00
'          With RoundtripKind flag: 9/15/2008 6:30:41 AM Local time.
'          Without RoundtripKind flag: 9/15/2008 6:30:41 AM Local time.
'       Mon, 15 Sep 2008 09:30:41 GMT
'          With RoundtripKind flag: 9/15/2008 9:30:41 AM Utc time.
'          Without RoundtripKind flag: 9/15/2008 2:30:41 AM Local time.

Parse(String)

Quelle:

DateTime.cs

Konvertiert die Zeichenfolgendarstellung eines Datums und einer Uhrzeit in seine DateTime Entsprechung mithilfe der Konventionen der aktuellen Kultur.

public:
 static DateTime Parse(System::String ^ s);

public static DateTime Parse (string s);

static member Parse : string -> DateTime

Public Shared Function Parse (s As String) As DateTime

Parameter

s

String

Eine Zeichenfolge, die ein Datum und eine Uhrzeit enthält, die konvertiert werden soll. Weitere Informationen finden Sie unter Die Zeichenfolge zum Analysieren.

Gibt zurück

DateTime

Ein Objekt, das dem in senthaltenen Datum und Uhrzeit entspricht.

Ausnahmen

ArgumentNullException

s ist null.

FormatException

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

Beispiele

Im folgenden Beispiel wird die Zeichenfolgendarstellung mehrerer Datums- und Uhrzeitwerte analysiert:

• Die Verwendung des Standardformatanbieters, der die Formatierungskonventionen der aktuellen Kultur des Computers bereitstellt, mit dem die Beispielausgabe erzeugt wird. Die Ausgabe aus diesem Beispiel spiegelt die Formatierungskonventionen der en-US Kultur wider.

• Verwenden sie den Standardformatvorlagenwert, der AllowWhiteSpaces.

Sie behandelt die FormatException Ausnahme, die ausgelöst wird, wenn die Methode versucht, die Zeichenfolgendarstellung eines Datums und einer Uhrzeit mithilfe der Formatierungskonventionen anderer Kultur zu analysieren. Außerdem wird gezeigt, wie Sie einen Datums- und Uhrzeitwert erfolgreich analysieren, der die Formatierungskonventionen der aktuellen Kultur nicht verwendet.

using System;
using System.Globalization;

public class DateTimeParser
{
   public static void Main()
   {
      // Assume the current culture is en-US.
      // The date is February 16, 2008, 12 hours, 15 minutes and 12 seconds.

      // Use standard en-US date and time value
      DateTime dateValue;
      string dateString = "2/16/2008 12:15:12 PM";
      try {
         dateValue = DateTime.Parse(dateString);
         Console.WriteLine("'{0}' converted to {1}.", dateString, dateValue);
      }
      catch (FormatException) {
         Console.WriteLine("Unable to convert '{0}'.", dateString);
      }

      // Reverse month and day to conform to the fr-FR culture.
      // The date is February 16, 2008, 12 hours, 15 minutes and 12 seconds.
      dateString = "16/02/2008 12:15:12";
      try {
         dateValue = DateTime.Parse(dateString);
         Console.WriteLine("'{0}' converted to {1}.", dateString, dateValue);
      }
      catch (FormatException) {
         Console.WriteLine("Unable to convert '{0}'.", dateString);
      }

      // Call another overload of Parse to successfully convert string
      // formatted according to conventions of fr-FR culture.
      try {
         dateValue = DateTime.Parse(dateString, new CultureInfo("fr-FR", false));
         Console.WriteLine("'{0}' converted to {1}.", dateString, dateValue);
      }
      catch (FormatException) {
         Console.WriteLine("Unable to convert '{0}'.", dateString);
      }

      // Parse string with date but no time component.
      dateString = "2/16/2008";
      try {
         dateValue = DateTime.Parse(dateString);
         Console.WriteLine("'{0}' converted to {1}.", dateString, dateValue);
      }
      catch (FormatException) {
         Console.WriteLine("Unable to convert '{0}'.", dateString);
      }
   }
}
// The example displays the following output to the console:
//       '2/16/2008 12:15:12 PM' converted to 2/16/2008 12:15:12 PM.
//       Unable to convert '16/02/2008 12:15:12'.
//       '16/02/2008 12:15:12' converted to 2/16/2008 12:15:12 PM.
//       '2/16/2008' converted to 2/16/2008 12:00:00 AM.

open System
open System.Globalization

[<EntryPoint>]
let main _ =
    // Assume the current culture is en-US.
    // The date is February 16, 2008, 12 hours, 15 minutes and 12 seconds.

    // Use standard en-US date and time value
    let dateString = "2/16/2008 12:15:12 PM"
    try
        let dateValue = DateTime.Parse dateString
        printfn $"'{dateString}' converted to {dateValue}."
    with :? FormatException ->
        printfn $"Unable to convert '{dateString}'."

    // Reverse month and day to conform to the fr-FR culture.
    // The date is February 16, 2008, 12 hours, 15 minutes and 12 seconds.
    let dateString = "16/02/2008 12:15:12"
    try
        let dateValue = DateTime.Parse dateString
        printfn $"'{dateString}' converted to {dateValue}."
    with :? FormatException ->
        Console.WriteLine("Unable to convert '{0}'.", dateString)

    // Call another overload of Parse to successfully convert string
    // formatted according to conventions of fr-FR culture.
    try
        let dateValue = DateTime.Parse(dateString, CultureInfo("fr-FR", false))
        printfn $"'{dateString}' converted to {dateValue}."
    with :? FormatException ->
        printfn $"Unable to convert '{dateString}'."

    // Parse string with date but no time component.
    let dateString = "2/16/2008"
    try
        let dateValue = DateTime.Parse dateString
        printfn $"'{dateString}' converted to {dateValue}."
    with :? FormatException ->
        printfn $"Unable to convert '{dateString}'."

    0

// The example displays the following output to the console:
//       '2/16/2008 12:15:12 PM' converted to 2/16/2008 12:15:12 PM.
//       Unable to convert '16/02/2008 12:15:12'.
//       '16/02/2008 12:15:12' converted to 2/16/2008 12:15:12 PM.
//       '2/16/2008' converted to 2/16/2008 12:00:00 AM.

Imports System.Globalization

Class DateTimeParser
   Public Shared Sub Main()
      ' Assume the current culture is en-US. 
      ' The date is February 16, 2008, 12 hours, 15 minutes and 12 seconds.

      ' Use standard en-US date and time value
      Dim dateValue As Date
      Dim dateString As String = "2/16/2008 12:15:12 PM"
      Try
         dateValue = Date.Parse(dateString)
         Console.WriteLine("'{0}' converted to {1}.", dateString, dateValue)
      Catch e As FormatException
         Console.WriteLine("Unable to convert '{0}'.", dateString)
      End Try
            
      ' Reverse month and day to conform to the fr-FR culture.
      ' The date is February 16, 2008, 12 hours, 15 minutes and 12 seconds.
      dateString = "16/02/2008 12:15:12"
      Try
         dateValue = Date.Parse(dateString)
         Console.WriteLine("'{0}' converted to {1}.", dateString, dateValue)
      Catch e As FormatException
         Console.WriteLine("Unable to convert '{0}'.", dateString)
      End Try

      ' Call another overload of Parse to successfully convert string
      ' formatted according to conventions of fr-FR culture.      
      Try
         dateValue = Date.Parse(dateString, New CultureInfo("fr-FR", False))
         Console.WriteLine("'{0}' converted to {1}.", dateString, dateValue)
      Catch e As FormatException
         Console.WriteLine("Unable to convert '{0}'.", dateString)
      End Try
      
      ' Parse string with date but no time component.
      dateString = "2/16/2008"
      Try
         dateValue = Date.Parse(dateString)
         Console.WriteLine("'{0}' converted to {1}.", dateString, dateValue)
      Catch e As FormatException
         Console.WriteLine("Unable to convert '{0}'.", dateString)
      End Try
   End Sub 
End Class 
' The example displays the following output to the console:
'       '2/16/2008 12:15:12 PM' converted to 2/16/2008 12:15:12 PM.
'       Unable to convert '16/02/2008 12:15:12'.
'       '16/02/2008 12:15:12' converted to 2/16/2008 12:15:12 PM.
'       '2/16/2008' converted to 2/16/2008 12:00:00 AM.

Hinweise

Wenn s Zeitzoneninformationen enthält, gibt diese Methode einen DateTime Wert zurück, dessen Kind Eigenschaft DateTimeKind.Local ist und das Datum und die Uhrzeit in s in lokale Uhrzeit konvertiert. Andernfalls wird keine Zeitzonenkonvertierung ausgeführt und ein DateTime Wert zurückgegeben, dessen Kind Eigenschaft DateTimeKind.Unspecifiedist.

Diese Überladung versucht, s mithilfe der Formatierungskonventionen der aktuellen Kultur zu analysieren. Die aktuelle Kultur wird durch die eigenschaft CurrentCulture angegeben. Um eine Zeichenfolge mithilfe der Formatierungskonventionen einer bestimmten Kultur zu analysieren, rufen Sie die Parse(String, IFormatProvider) oder die Parse(String, IFormatProvider, DateTimeStyles) Überladungen auf.

Diese Überladung versucht, s mithilfe DateTimeStyles.AllowWhiteSpaces Formatvorlage zu analysieren.

Weitere Informationen

• TryParse
• CultureInfo
• DateTimeFormatInfo
• Analysieren von Datums- und Uhrzeitzeichenfolgen im .NET Framework-
• Standard-Datums- und Uhrzeitformatzeichenfolgen
• benutzerdefinierte Datums- und Uhrzeitformatzeichenfolgen

Parse(ReadOnlySpan<Char>, IFormatProvider)

Quelle:

DateTime.cs

Analysiert eine Spanne von Zeichen in einen Wert.

public:
 static DateTime Parse(ReadOnlySpan<char> s, IFormatProvider ^ provider) = ISpanParsable<DateTime>::Parse;

public static DateTime Parse (ReadOnlySpan<char> s, IFormatProvider? provider);

static member Parse : ReadOnlySpan<char> * IFormatProvider -> DateTime

Public Shared Function Parse (s As ReadOnlySpan(Of Char), provider As IFormatProvider) As DateTime

Parameter

s

ReadOnlySpan<Char>

Die Spanne der zu analysierenden Zeichen.

provider

IFormatProvider

Ein Objekt, das kulturspezifische Formatierungsinformationen zu sbereitstellt.

Gibt zurück

DateTime

Das Ergebnis der Analyse s.

Implementiert

Parse(ReadOnlySpan<Char>, IFormatProvider)

Parse(String, IFormatProvider)

Quelle:

DateTime.cs

Konvertiert die Zeichenfolgendarstellung eines Datums und einer Uhrzeit in dessen DateTime Äquivalent mithilfe von kulturspezifischen Formatinformationen.

public:
 static DateTime Parse(System::String ^ s, IFormatProvider ^ provider) = IParsable<DateTime>::Parse;

public static DateTime Parse (string s, IFormatProvider? provider);

static member Parse : string * IFormatProvider -> DateTime

Public Shared Function Parse (s As String, provider As IFormatProvider) As DateTime

Parameter

s

String

Eine Zeichenfolge, die ein Datum und eine Uhrzeit enthält, die konvertiert werden soll. Weitere Informationen finden Sie unter Die Zeichenfolge zum Analysieren.

provider

IFormatProvider

Ein Objekt, das kulturspezifische Formatinformationen zu sbereitstellt. Siehe Parsing und kulturelle Konventionen

Gibt zurück

DateTime

Ein Objekt, das dem Datum und der Uhrzeit entspricht, das in s enthalten ist, wie durch providerangegeben.

Implementiert

Parse(String, IFormatProvider)

Ausnahmen

ArgumentNullException

s ist null.

FormatException

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

Beispiele

Im folgenden Beispiel wird ein Array von Datumszeichenfolgen mithilfe der Konventionen der kulturen en-US, fr-FRund de-DE analysiert. Es zeigt, dass die Zeichenfolgendarstellungen eines einzelnen Datums in verschiedenen Kulturen unterschiedlich interpretiert werden können.

using System;
using System.Globalization;

public class ParseDate
{
   public static void Main()
   {
      // Define cultures to be used to parse dates.
      CultureInfo[] cultures = {CultureInfo.CreateSpecificCulture("en-US"),
                                CultureInfo.CreateSpecificCulture("fr-FR"),
                                CultureInfo.CreateSpecificCulture("de-DE")};
      // Define string representations of a date to be parsed.
      string[] dateStrings = {"01/10/2009 7:34 PM",
                              "10.01.2009 19:34",
                              "10-1-2009 19:34" };
      // Parse dates using each culture.
      foreach (CultureInfo culture in cultures)
      {
         DateTime dateValue;
         Console.WriteLine("Attempted conversions using {0} culture.",
                           culture.Name);
         foreach (string dateString in dateStrings)
         {
            try {
               dateValue = DateTime.Parse(dateString, culture);
               Console.WriteLine("   Converted '{0}' to {1}.",
                                 dateString, dateValue.ToString("f", culture));
            }
            catch (FormatException) {
               Console.WriteLine("   Unable to convert '{0}' for culture {1}.",
                                 dateString, culture.Name);
            }
         }
         Console.WriteLine();
      }
   }
}
// The example displays the following output to the console:
//       Attempted conversions using en-US culture.
//          Converted '01/10/2009 7:34 PM' to Saturday, January 10, 2009 7:34 PM.
//          Converted '10.01.2009 19:34' to Thursday, October 01, 2009 7:34 PM.
//          Converted '10-1-2009 19:34' to Thursday, October 01, 2009 7:34 PM.
//
//       Attempted conversions using fr-FR culture.
//          Converted '01/10/2009 7:34 PM' to jeudi 1 octobre 2009 19:34.
//          Converted '10.01.2009 19:34' to samedi 10 janvier 2009 19:34.
//          Converted '10-1-2009 19:34' to samedi 10 janvier 2009 19:34.
//
//       Attempted conversions using de-DE culture.
//          Converted '01/10/2009 7:34 PM' to Donnerstag, 1. Oktober 2009 19:34.
//          Converted '10.01.2009 19:34' to Samstag, 10. Januar 2009 19:34.
//          Converted '10-1-2009 19:34' to Samstag, 10. Januar 2009 19:34.

open System
open System.Globalization

// Define cultures to be used to parse dates.
let cultures = 
    [ CultureInfo.CreateSpecificCulture "en-US"
      CultureInfo.CreateSpecificCulture "fr-FR"
      CultureInfo.CreateSpecificCulture "de-DE" ]

// Define string representations of a date to be parsed.
let dateStrings = 
    [ "01/10/2009 7:34 PM"
      "10.01.2009 19:34"
      "10-1-2009 19:34" ]

// Parse dates using each culture.
for culture in cultures do
    printfn $"Attempted conversions using {culture.Name} culture."
    for dateString in dateStrings do
        try
            let dateValue = DateTime.Parse(dateString, culture)
            printfn $"""   Converted '{dateString}' to {dateValue.ToString("f", culture)}."""
        with :? FormatException ->
            printfn $"   Unable to convert '{dateString}' for culture {culture.Name}." 
    printfn ""


// The example displays the following output to the console:
//       Attempted conversions using en-US culture.
//          Converted '01/10/2009 7:34 PM' to Saturday, January 10, 2009 7:34 PM.
//          Converted '10.01.2009 19:34' to Thursday, October 01, 2009 7:34 PM.
//          Converted '10-1-2009 19:34' to Thursday, October 01, 2009 7:34 PM.
//
//       Attempted conversions using fr-FR culture.
//          Converted '01/10/2009 7:34 PM' to jeudi 1 octobre 2009 19:34.
//          Converted '10.01.2009 19:34' to samedi 10 janvier 2009 19:34.
//          Converted '10-1-2009 19:34' to samedi 10 janvier 2009 19:34.
//
//       Attempted conversions using de-DE culture.
//          Converted '01/10/2009 7:34 PM' to Donnerstag, 1. Oktober 2009 19:34.
//          Converted '10.01.2009 19:34' to Samstag, 10. Januar 2009 19:34.
//          Converted '10-1-2009 19:34' to Samstag, 10. Januar 2009 19:34.

Imports System.Globalization

Module ParseDate
   Public Sub Main()
      ' Define cultures to be used to parse dates.
      Dim cultures() As CultureInfo = {CultureInfo.CreateSpecificCulture("en-US"), _
                                       CultureInfo.CreateSpecificCulture("fr-FR"), _
                                       CultureInfo.CreateSpecificCulture("de-DE")}
      ' Define string representations of a date to be parsed.
      Dim dateStrings() As String = {"01/10/2009 7:34 PM", _
                                     "10.01.2009 19:34", _
                                     "10-1-2009 19:34" }
      ' Parse dates using each culture.
      For Each culture In cultures
         Dim dateValue As Date
         Console.WriteLine("Attempted conversions using {0} culture.", culture.Name)
         For Each dateString As String In dateStrings
            Try
               dateValue = Date.Parse(dateString, culture)
               Console.WriteLine("   Converted '{0}' to {1}.", _
                                 dateString, dateValue.ToString("f", culture))
            Catch e As FormatException
               Console.WriteLine("   Unable to convert '{0}' for culture {1}.", _
                                 dateString, culture.Name)
            End Try                                                
         Next
         Console.WriteLine()
      Next                                                                                     
   End Sub
End Module
' The example displays the following output to the console:
'       Attempted conversions using en-US culture.
'          Converted '01/10/2009 7:34 PM' to Saturday, January 10, 2009 7:34 PM.
'          Converted '10.01.2009 19:34' to Thursday, October 01, 2009 7:34 PM.
'          Converted '10-1-2009 19:34' to Thursday, October 01, 2009 7:34 PM.
'       
'       Attempted conversions using fr-FR culture.
'          Converted '01/10/2009 7:34 PM' to jeudi 1 octobre 2009 19:34.
'          Converted '10.01.2009 19:34' to samedi 10 janvier 2009 19:34.
'          Converted '10-1-2009 19:34' to samedi 10 janvier 2009 19:34.
'       
'       Attempted conversions using de-DE culture.
'          Converted '01/10/2009 7:34 PM' to Donnerstag, 1. Oktober 2009 19:34.
'          Converted '10.01.2009 19:34' to Samstag, 10. Januar 2009 19:34.
'          Converted '10-1-2009 19:34' to Samstag, 10. Januar 2009 19:34.

Hinweise

Wenn s Zeitzoneninformationen enthält, gibt diese Methode einen DateTime Wert zurück, dessen Kind Eigenschaft DateTimeKind.Local ist und das Datum und die Uhrzeit in s in lokale Uhrzeit konvertiert. Andernfalls wird keine Zeitzonenkonvertierung ausgeführt und ein DateTime Wert zurückgegeben, dessen Kind Eigenschaft DateTimeKind.Unspecifiedist.

Diese Überladung versucht, s mithilfe der DateTimeStyles.AllowWhiteSpaces-Formatvorlage zu analysieren.

Weitere Informationen

• TryParse
• CultureInfo
• DateTimeFormatInfo
• Analysieren von Datums- und Uhrzeitzeichenfolgen im .NET Framework-
• Standard-Datums- und Uhrzeitformatzeichenfolgen
• benutzerdefinierte Datums- und Uhrzeitformatzeichenfolgen

Parse(ReadOnlySpan<Char>, IFormatProvider, DateTimeStyles)

Quelle:

DateTime.cs

Konvertiert eine Speicherspanne, die eine Zeichenfolgendarstellung eines Datums und einer Uhrzeit enthält, in dessen DateTime entspreche, indem kulturspezifische Formatinformationen und eine Formatierungsformatvorlage verwendet werden.

public static DateTime Parse (ReadOnlySpan<char> s, IFormatProvider? provider = default, System.Globalization.DateTimeStyles styles = System.Globalization.DateTimeStyles.None);

static member Parse : ReadOnlySpan<char> * IFormatProvider * System.Globalization.DateTimeStyles -> DateTime

Public Shared Function Parse (s As ReadOnlySpan(Of Char), Optional provider As IFormatProvider = Nothing, Optional styles As DateTimeStyles = System.Globalization.DateTimeStyles.None) As DateTime

Parameter

s

ReadOnlySpan<Char>

Die Speicherspanne, die die zu analysierende Zeichenfolge enthält. Weitere Informationen finden Sie unter Die Zeichenfolge zum Analysieren.

provider

IFormatProvider

Ein Objekt, das kulturspezifische Formatinformationen zu sbereitstellt. Siehe Parsing und kulturelle Konventionen

styles

DateTimeStyles

Eine bitweise Kombination der Enumerationswerte, die die Formatvorlagenelemente angibt, die in s vorhanden sein können, damit der Analysevorgang erfolgreich ausgeführt werden kann, und das definiert, wie das analysierte Datum in Bezug auf die aktuelle Zeitzone oder das aktuelle Datum interpretiert wird. Ein typischer Wert, der angegeben werden soll, ist None.

Gibt zurück

DateTime

Ein Objekt, das dem in senthaltenen Datum und Uhrzeit entspricht, wie durch provider und stylesangegeben.

Ausnahmen

FormatException

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

ArgumentException

styles enthält eine ungültige Kombination aus DateTimeStyles Werten. Beispielsweise AssumeLocal und AssumeUniversal.

Parse(String, IFormatProvider, DateTimeStyles)

Quelle:

DateTime.cs

Konvertiert die Zeichenfolgendarstellung eines Datums und einer Uhrzeit in seine DateTime Entsprechung mithilfe kulturspezifischer Formatinformationen und einer Formatierungsformatvorlage.

public:
 static DateTime Parse(System::String ^ s, IFormatProvider ^ provider, System::Globalization::DateTimeStyles styles);

public static DateTime Parse (string s, IFormatProvider? provider, System.Globalization.DateTimeStyles styles);

static member Parse : string * IFormatProvider * System.Globalization.DateTimeStyles -> DateTime

Public Shared Function Parse (s As String, provider As IFormatProvider, styles As DateTimeStyles) As DateTime

Parameter

s

String

Eine Zeichenfolge, die ein Datum und eine Uhrzeit enthält, die konvertiert werden soll. Weitere Informationen finden Sie unter Die Zeichenfolge zum Analysieren.

provider

IFormatProvider

Ein Objekt, das kulturspezifische Formatierungsinformationen zu sbereitstellt. Siehe Parsing und kulturelle Konventionen

styles

DateTimeStyles

Eine bitweise Kombination der Enumerationswerte, die die Formatvorlagenelemente angibt, die in s vorhanden sein können, damit der Analysevorgang erfolgreich ausgeführt werden kann, und das definiert, wie das analysierte Datum in Bezug auf die aktuelle Zeitzone oder das aktuelle Datum interpretiert wird. Ein typischer Wert, der angegeben werden soll, ist None.

Gibt zurück

DateTime

Ein Objekt, das dem in senthaltenen Datum und Uhrzeit entspricht, wie durch provider und stylesangegeben.

Ausnahmen

ArgumentNullException

s ist null.

FormatException

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

ArgumentException

styles enthält eine ungültige Kombination aus DateTimeStyles Werten. Beispielsweise AssumeLocal und AssumeUniversal.

Beispiele

Das folgende Beispiel veranschaulicht die Parse(String, IFormatProvider, DateTimeStyles)-Methode und zeigt den Wert der Kind Eigenschaft der resultierenden DateTime Werte an.

using System;
using System.Globalization;

public class ParseDateExample
{
   public static void Main()
   {
      string dateString;
      CultureInfo culture ;
      DateTimeStyles styles;
      DateTime result;

      // Parse a date and time with no styles.
      dateString = "03/01/2009 10:00 AM";
      culture = CultureInfo.CreateSpecificCulture("en-US");
      styles = DateTimeStyles.None;
      try {
         result = DateTime.Parse(dateString, culture, styles);
         Console.WriteLine("{0} converted to {1} {2}.",
                           dateString, result, result.Kind.ToString());
      }
      catch (FormatException) {
         Console.WriteLine("Unable to convert {0} to a date and time.",
                           dateString);
      }

      // Parse the same date and time with the AssumeLocal style.
      styles = DateTimeStyles.AssumeLocal;
      try {
         result = DateTime.Parse(dateString, culture, styles);
         Console.WriteLine("{0} converted to {1} {2}.",
                           dateString, result, result.Kind.ToString());
      }
      catch (FormatException) {
         Console.WriteLine("Unable to convert {0} to a date and time.", dateString);
      }

      // Parse a date and time that is assumed to be local.
      // This time is five hours behind UTC. The local system's time zone is
      // eight hours behind UTC.
      dateString = "2009/03/01T10:00:00-5:00";
      styles = DateTimeStyles.AssumeLocal;
      try {
         result = DateTime.Parse(dateString, culture, styles);
         Console.WriteLine("{0} converted to {1} {2}.",
                           dateString, result, result.Kind.ToString());
      }
      catch (FormatException) {
         Console.WriteLine("Unable to convert {0} to a date and time.", dateString);
      }

      // Attempt to convert a string in improper ISO 8601 format.
      dateString = "03/01/2009T10:00:00-5:00";
      try {
         result = DateTime.Parse(dateString, culture, styles);
         Console.WriteLine("{0} converted to {1} {2}.",
                           dateString, result, result.Kind.ToString());
      }
      catch (FormatException) {
         Console.WriteLine("Unable to convert {0} to a date and time.", dateString);
      }

      // Assume a date and time string formatted for the fr-FR culture is the local
      // time and convert it to UTC.
      dateString = "2008-03-01 10:00";
      culture = CultureInfo.CreateSpecificCulture("fr-FR");
      styles = DateTimeStyles.AdjustToUniversal | DateTimeStyles.AssumeLocal;
      try {
         result = DateTime.Parse(dateString, culture, styles);
         Console.WriteLine("{0} converted to {1} {2}.",
                           dateString, result, result.Kind.ToString());
      }
      catch (FormatException) {
         Console.WriteLine("Unable to convert {0} to a date and time.", dateString);
      }
   }
}
// The example displays the following output to the console:
//       03/01/2009 10:00 AM converted to 3/1/2009 10:00:00 AM Unspecified.
//       03/01/2009 10:00 AM converted to 3/1/2009 10:00:00 AM Local.
//       2009/03/01T10:00:00-5:00 converted to 3/1/2009 7:00:00 AM Local.
//       Unable to convert 03/01/2009T10:00:00-5:00 to a date and time.
//       2008-03-01 10:00 converted to 3/1/2008 6:00:00 PM Utc.

open System
open System.Globalization

[<EntryPoint>]
let main _ =
    // Parse a date and time with no styles.
    let dateString = "03/01/2009 10:00 AM"
    let culture = CultureInfo.CreateSpecificCulture "en-US"
    let styles = DateTimeStyles.None
    try
        let result = DateTime.Parse(dateString, culture, styles)
        printfn $"{dateString} converted to {result} {result.Kind}."
    with :? FormatException ->
        printfn $"Unable to convert {dateString} to a date and time."

    // Parse the same date and time with the AssumeLocal style.
    let styles = DateTimeStyles.AssumeLocal
    try
        let result = DateTime.Parse(dateString, culture, styles)
        printfn $"{dateString} converted to {result} {result.Kind}."
    with :? FormatException ->
        printfn $"Unable to convert {dateString} to a date and time."

    // Parse a date and time that is assumed to be local.
    // This time is five hours behind UTC. The local system's time zone is
    // eight hours behind UTC.
    let dateString = "2009/03/01T10:00:00-5:00"
    let styles = DateTimeStyles.AssumeLocal
    try
        let result = DateTime.Parse(dateString, culture, styles)
        printfn $"{dateString} converted to {result} {result.Kind}."
    with :? FormatException ->
        printfn $"Unable to convert {dateString} to a date and time."

    // Attempt to convert a string in improper ISO 8601 format.
    let dateString = "03/01/2009T10:00:00-5:00"
    try
        let result = DateTime.Parse(dateString, culture, styles)
        printfn $"{dateString} converted to {result} {result.Kind}."
    with :? FormatException ->
        printfn $"Unable to convert {dateString} to a date and time."

    // Assume a date and time string formatted for the fr-FR culture is the local
    // time and convert it to UTC.
    let dateString = "2008-03-01 10:00"
    let culture = CultureInfo.CreateSpecificCulture "fr-FR"
    let styles = DateTimeStyles.AdjustToUniversal ||| DateTimeStyles.AssumeLocal
    try
        let result = DateTime.Parse(dateString, culture, styles)
        printfn $"{dateString} converted to {result} {result.Kind}."
    with :? FormatException ->
        printfn $"Unable to convert {dateString} to a date and time."

    0

// The example displays the following output to the console:
//       03/01/2009 10:00 AM converted to 3/1/2009 10:00:00 AM Unspecified.
//       03/01/2009 10:00 AM converted to 3/1/2009 10:00:00 AM Local.
//       2009/03/01T10:00:00-5:00 converted to 3/1/2009 7:00:00 AM Local.
//       Unable to convert 03/01/2009T10:00:00-5:00 to a date and time.
//       2008-03-01 10:00 converted to 3/1/2008 6:00:00 PM Utc.

Imports System.Globalization

Module ParseDateExample
   Public Sub Main()
      Dim dateString As String  
      Dim culture As CultureInfo
      Dim styles As DateTimeStyles 
      Dim result As DateTime
      
      ' Parse a date and time with no styles.
      dateString = "03/01/2009 10:00 AM"
      culture = CultureInfo.CreateSpecificCulture("en-US")
      styles = DateTimeStyles.None
      Try
         result = DateTime.Parse(dateString, culture, styles)
         Console.WriteLine("{0} converted to {1} {2}.", _
                           dateString, result, result.Kind.ToString())
      Catch e As FormatException
         Console.WriteLine("Unable to convert {0} to a date and time.", dateString)
      End Try      
      
      ' Parse the same date and time with the AssumeLocal style.
      styles = DateTimeStyles.AssumeLocal
      Try
         result = DateTime.Parse(dateString, culture, styles)
         Console.WriteLine("{0} converted to {1} {2}.", _
                           dateString, result, result.Kind.ToString())
      Catch e As FormatException
         Console.WriteLine("Unable to convert {0} to a date and time.", dateString)
      End Try      
      
      ' Parse a date and time that is assumed to be local.
      ' This time is five hours behind UTC. The local system's time zone is 
      ' eight hours behind UTC.
      dateString = "2009/03/01T10:00:00-5:00"
      styles = DateTimeStyles.AssumeLocal
      Try
         result = DateTime.Parse(dateString, culture, styles)
         Console.WriteLine("{0} converted to {1} {2}.", _
                           dateString, result, result.Kind.ToString())
      Catch e As FormatException
         Console.WriteLine("Unable to convert {0} to a date and time.", dateString)
      End Try      
      
      ' Attempt to convert a string in improper ISO 8601 format.
      dateString = "03/01/2009T10:00:00-5:00"
      Try
         result = DateTime.Parse(dateString, culture, styles)
         Console.WriteLine("{0} converted to {1} {2}.", _
                           dateString, result, result.Kind.ToString())
      Catch e As FormatException
         Console.WriteLine("Unable to convert {0} to a date and time.", dateString)
      End Try      

      ' Assume a date and time string formatted for the fr-FR culture is the local 
      ' time and convert it to UTC.
      dateString = "2008-03-01 10:00"
      culture = CultureInfo.CreateSpecificCulture("fr-FR")
      styles = DateTimeStyles.AdjustToUniversal Or DateTimeStyles.AssumeLocal
      Try
         result = DateTime.Parse(dateString, culture, styles)
         Console.WriteLine("{0} converted to {1} {2}.", _
                           dateString, result, result.Kind.ToString())
      Catch e As FormatException
         Console.WriteLine("Unable to convert {0} to a date and time.", dateString)
      End Try      
   End Sub
End Module
'
' The example displays the following output to the console:
'       03/01/2009 10:00 AM converted to 3/1/2009 10:00:00 AM Unspecified.
'       03/01/2009 10:00 AM converted to 3/1/2009 10:00:00 AM Local.
'       2009/03/01T10:00:00-5:00 converted to 3/1/2009 7:00:00 AM Local.
'       Unable to convert 03/01/2009T10:00:00-5:00 to a date and time.
'       2008-03-01 10:00 converted to 3/1/2008 6:00:00 PM Utc.

Hinweise

Diese Methodenüberladung konvertiert das Datum und die Uhrzeit in s und legt die Kind Eigenschaft des zurückgegebenen DateTime Werts wie folgt fest:

Wenn	Zeitzonenkonvertierung	Kind-Eigenschaft
s enthält keine Zeitzoneninformationen.	Nichts.	DateTimeKind.Unspecified
s enthält Zeitzoneninformationen.	Zur Uhrzeit in der lokalen Zeitzone	DateTimeKind.Local
s enthält Zeitzoneninformationen, und styles enthält das DateTimeStyles.AdjustToUniversal Flag.	Koordinierte Weltzeit (UTC)	DateTimeKind.Utc
s enthält den Z- oder GMT-Zeitzonen-Kennzeichner, und styles enthält die DateTimeStyles.RoundtripKind.	Nichts.	DateTimeKind.Utc

Weitere Informationen

• TryParse
• CultureInfo
• DateTimeFormatInfo
• Analysieren von Datums- und Uhrzeitzeichenfolgen im .NET Framework-
• Standard-Datums- und Uhrzeitformatzeichenfolgen
• benutzerdefinierte Datums- und Uhrzeitformatzeichenfolgen
• How to: Roundtrip Date and Time Values