DateTime.Parse Methode

Definition

Konvertiert die Zeichenfolgendarstellung einer Datums- und Uhrzeitangabe in die entsprechende DateTime.

Überlädt

Parse(String)

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

Parse(ReadOnlySpan<Char>, IFormatProvider)

Analysiert eine Spanne von Zeichen in einen Wert.

Parse(String, IFormatProvider)

Konvertiert die Zeichenfolgendarstellungen einer Datums- und Uhrzeitangabe unter Verwendung der kulturspezifischen Formatierungsinformationen in die entsprechende DateTime.

Parse(ReadOnlySpan<Char>, IFormatProvider, DateTimeStyles)

Konvertiert eine Arbeitsspeicherspanne, die eine Zeichenfolgendarstellung einer Datums- und Uhrzeitangabe enthält, unter Verwendung der kulturspezifischen Formatierungsinformationen und eines Formatierungsstil in die entsprechende DateTime.

Parse(String, IFormatProvider, DateTimeStyles)

Konvertiert die Zeichenfolgendarstellung einer Datums- und Uhrzeitangabe unter Verwendung der kulturspezifischen Formatierungsinformationen und eines Formatierungsstil in die entsprechende DateTime.

Beispiele

Zahlreiche Beispiele, die die DateTime.Parse -Methode aufrufen, sind im Abschnitt Hinweise dieses Artikels und in der Dokumentation zu den einzelnen DateTime.Parse Überladungen enthalten.

Hinweis

Einige C#-Beispiele in diesem Artikel werden in der Inlinecodeausführung und dem Playground von Try.NET ausgeführt. Klicken Sie auf die Schaltfläche Ausführen, 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 durch erneutes Anklicken der Schaltfläche Ausführen ausführen. Der geänderte Code wird entweder im interaktiven Fenster ausgeführt, oder das interaktive Fenster zeigt alle C#-Compilerfehlermeldungen an, wenn die Kompilierung fehlschlägt.

Die lokale Zeitzone der Inlinecodeausführung und dem Playground von Try.NET wird ist die Koordinierte Weltzeit (UTC). Dies kann sich auf das Verhalten und die Ausgabe von Beispielen auswirken, die die Typen DateTime, DateTimeOffset und TimeZoneInfo sowie deren Member veranschaulichen.

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

Hinweise

In diesem Abschnitt

Welche Methode rufe ich auf?

Beschreibung Aufruf
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) overload (siehe Analyse und Kulturelle Konventionen)
Analysieren Sie eine Datums- und Uhrzeitzeichenfolge mit speziellen Stilelementen (z. B. Leerraum 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 Ausnahmen zu behandeln. DateTime.TryParse-Methode
Wiederherstellen (Roundtrip) eines Datums- und Uhrzeitwerts, der durch einen Formatierungsvorgang erstellt wurde. Übergeben Sie die Standardformatzeichenfolge "o" oder "r" an die ToString(String) -Methode, und rufen Sie die Parse(String, IFormatProvider, DateTimeStyles) Überladung mit auf. 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 ihre DateTime Entsprechung zu konvertieren. Es wird versucht, die Eingabezeichenfolge vollständig zu analysieren, ohne eine Ausnahme auszulösen FormatException .

Wichtig

Wenn der Analysevorgang aufgrund eines nicht erkannten Zeichenfolgenformats fehlschlägt, löst die Parse -Methode einen aus FormatException, während die TryParse -Methode zurückgibt false. Da die Ausnahmebehandlung teuer sein kann, sollten Sie verwenden Parse , wenn der Analysevorgang voraussichtlich erfolgreich ist, 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, um Zeichenfolgen zu ersetzen, die nicht erfolgreich analysiert werden.

Die zu analysierende Zeichenfolge kann eine der folgenden Formen annehmen:

  • Eine Zeichenfolge mit einer Datums- und einer Zeitkomponente.

  • Eine Zeichenfolge mit einem Datum, aber ohne Zeitkomponente. Wenn die Zeitkomponente abwesend ist, geht die Methode von 12:00 Uhr Mitternacht aus. Wenn die Datumskomponente über ein zweistelliges Jahr verfügt, wird sie basierend auf dem Calendar.TwoDigitYearMax aktuellen Kalender der aktuellen Kultur oder dem aktuellen Kalender der angegebenen Kultur in ein Jahr konvertiert (wenn Sie eine Überladung mit einem Nicht-NULL-Argument 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 Zeit, aber ohne Datumskomponente. Die Methode nimmt das aktuelle Datum an, es sei denn, Sie rufen die Parse(String, IFormatProvider, DateTimeStyles) Überladung auf und schließen sie in das styles Argument einDateTimeStyles.NoCurrentDateDefault. In diesem Fall geht die Methode von einem Datum vom 1. Januar 0001 aus.

  • Eine Zeichenfolge mit einer Zeitkomponente, die nur die Stunde und einen AM/PM-Bezeichner 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 in das styles Argument einschließenDateTimeStyles.NoCurrentDateDefault. In diesem Fall geht die Methode von einem Datum vom 1. Januar 0001 aus.

  • Eine Zeichenfolge, die Zeitzoneninformationen enthält und ISO 8601 entspricht. In den folgenden Beispielen gibt die erste Zeichenfolge koordinierte Weltzeit (UTC) und die zweite die Zeit in einer Zeitzone an, die sieben Stunden früher als UTC liegt:

    "2008-11-01T19:35:00.0000000000Z" "2008-11-01T19:35:00.00000000-07:00"

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

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

  • Eine Zeichenfolge, die datums- und uhrzeit sowie Zeitzonenoffsetinformationen enthält; Zum Beispiel:

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

Im folgenden Beispiel werden Zeichenfolgen in jedem dieser Formate analysiert, indem die Formatierungskonventionen der aktuellen Kultur verwendet werden, 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 Analyse- und Kulturkonventionen), analysiert die Parse -Methode die Zeichenfolge erfolgreich. Wenn die Eingabezeichenfolge einen Schalttag in einem Nicht-Schaltjahr darstellt, löst die -Methode einen aus FormatException.

Da die Parse -Methode versucht, die Zeichenfolgendarstellung eines Datums und einer Uhrzeit mithilfe der Formatierungsregeln der aktuellen oder einer angegebenen Kultur zu analysieren, kann der Versuch, eine Zeichenfolge in verschiedenen Kulturen zu analysieren, fehlschlagen. Um ein bestimmtes Datums- und Uhrzeitformat über verschiedene Gebietsschemas hinweg 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 kulturabhängig, es sei denn, die zu analysierende Zeichenfolge (die in der folgenden Tabelle dargestellt wird durch s ) entspricht dem ISO 8601-Muster. Der Analysevorgang verwendet die Formatierungsinformationen in einem DateTimeFormatInfo Objekt, das wie folgt abgeleitet wird:

Wichtig

Die Zeitrechnung in japanischen Kalendern basiert auf den Regierungsperioden der Kaiser und wird sich daher erwartungsgemäß ändern. Beispiel: Der 1. Mai 2019 markiert den Beginn des Reiwa-Zeitabschnitts in den Kalendern des Typs JapaneseCalendar und JapaneseLunisolarCalendar. Eine derartige Änderung der Zeitabschnitte betrifft alle Anwendungen, die diese Kalender verwenden. Weitere Informationen und informationen zum Ermitteln, 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 der Anwendung für die Änderung der japanischen Ära. Features in .NET, die Kalender mit mehreren Epochen unterstützen, und bewährte Methoden für die Arbeit mit Kalendern, die mehrere Epochen unterstützen, finden Sie unter Arbeiten mit Epochen.

Wenn Sie anrufen Und provider ist Formatierungsinformationen werden von abgeleitet
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) Benutzerdefinierte IFormatProvider Implementierung Die IFormatProvider.GetFormat -Methode

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

Wenn Sie eine Datums- und Uhrzeitzeichenfolge analysieren, indem Sie ein DateTimeFormatInfo Objekt mit benutzerdefinierten Einstellungen verwenden, die sich von denen einer Standardkultur unterscheiden, verwenden Sie die ParseExact -Methode anstelle der Parse -Methode, um die Wahrscheinlichkeit einer erfolgreichen 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 alle möglicherweise fehlschlagen. Im Gegensatz dazu erfordert die ParseExact Methode, dass Sie explizit ein oder mehrere genaue Analysemuster angeben, die wahrscheinlich erfolgreich sein werden. Weitere Informationen finden Sie im Abschnitt "DateTimeFormatInfo und dynamische Daten" des Themas DateTimeFormatInfo .

Wichtig

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

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

Um die Schwierigkeiten bei der Analyse von Daten und Zeitzeichenfolgen zu vermeiden, die mit Änderungen in Kulturdaten verknüpft sind, können Sie Datums- und Uhrzeitzeichenfolgen mithilfe der invarianten Kultur analysieren, oder Sie können die ParseExact -Methode oder TryParseExact 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 den DateTime Wert in einem Binärformat serialisieren und deserialisieren.

Weitere Informationen finden Sie im Abschnitt "Dynamische Kulturdaten" im CultureInfo Thema und im Abschnitt "Beibehalten von DateTime-Werten" im DateTime Thema.

Analysieren und Formatieren von Elementen

Alle Parse Überladungen ignorieren führende, innere oder nachfolgende Leerzeichen in der Eingabezeichenfolge (dargestellt durch s in der folgenden Tabelle). Datum und Uhrzeit können mit einem Paar von führenden und nachgestellten ZAHLENZEICHEN ("#", U+0023) in eine Klammer geklammert und mit einem oder mehreren NULL-Zeichen (U+0000) nachgestellt werden.

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

DateTimeStyles-Element Auswirkung auf die Konvertierung
AdjustToUniversal s Analysiert und konvertiert es ggf. wie folgt in UTC:

- Wenn s einen Zeitzonenoffset enthält oder keine s Zeitzoneninformationen, 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 fest DateTimeKind.Utc.
- Wenn s angibt, dass utc dargestellt wird, oder wenn s keine Zeitzoneninformationen, aber styles das AssumeUniversal Flag enthalten, analysiert die -Methode die Zeichenfolge, führt keine Zeitzonenkonvertierung für den zurückgegebenen DateTime Wert aus und legt die Kind -Eigenschaft auf fest DateTimeKind.Utc.
- In allen anderen Fällen hat das Flag 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 in den Datums- und Uhrzeitelementen von simmer zulässig.
AllowTrailingWhite Dieser Wert wird ignoriert. Nachfolgende Leerzeichen sind in den Datums- und Uhrzeitelementen von simmer zulässig.
AllowWhiteSpaces Gibt an, dass s führende, innere und nachfolgende Leerzeichen enthalten kann. Dies ist das Standardverhalten. Sie kann nicht durch Angabe eines restriktiveren DateTimeStyles Enumerationswerts wie Noneüberschrieben werden.
AssumeLocal Gibt an, dass ortszeit vorausgesetzt wird, wenn s keine Zeitzoneninformationen vorhanden sind. Sofern das AdjustToUniversal Flag nicht vorhanden ist, wird die Kind -Eigenschaft des zurückgegebenen Werts DateTime auf DateTimeKind.Localfestgelegt.
AssumeUniversal Gibt an, dass UTC angenommen wird, wenn s keine Zeitzoneninformationen vorhanden sind. Sofern das AdjustToUniversal Flag nicht vorhanden ist, konvertiert die Methode den zurückgegebenen DateTime Wert von UTC in Ortszeit und legt ihre Kind -Eigenschaft auf fest DateTimeKind.Local.
None Obwohl dieser Wert gültig ist, wird er ignoriert.
RoundtripKind Bei Zeichenfolgen, die Zeitzoneninformationen enthalten, versucht, die Konvertierung einer Datums- und Uhrzeitzeichenfolge in einen DateTime Wert zu verhindern, der eine Ortszeit darstellt, dessen 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. Dies kann darauf hindeuten, dass die Zeit folgendes ist:

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

If 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 (UTC) konvertiert. DateTimeKind.Utc
s enthält den Z- oder GMT-Zeitzonen-Bezeichner und styles das RoundtripKind Flag. Datum und Uhrzeit werden als UTC interpretiert. DateTimeKind.Utc

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

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 Eigenschaft eines Datums Kind und einer Uhrzeit während eines Formatierungs- und Analysevorgangs beibehalten, indem Sie das DateTimeStyles.RoundtripKind Flag 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)

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

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 eine zu konvertierende Datums- und Zeitangabe enthält. Weitere Informationen finden Sie unter Die zu analysierende Zeichenfolge.

Gibt zurück

Ein Objekt, das mit der in s enthaltenen Datums- und Uhrzeitangabe identisch ist.

Ausnahmen

s ist null.

s enthält keine gültige Zeichenfolgendarstellung einer Datums- und Uhrzeitangabe.

Beispiele

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

  • Verwenden Des Standardformatanbieters, der die Formatierungskonventionen der aktuellen Kultur des Computers bereitstellt, der zum Erstellen der Beispielausgabe verwendet wird. Die Ausgabe dieses Beispiels spiegelt die Formatierungskonventionen der en-US-Kultur wider.

  • Verwenden des Standardformatwerts, der ist AllowWhiteSpaces.

Es behandelt die FormatException Ausnahme, die ausgelöst wird, wenn die Methode versucht, die Zeichenfolgendarstellung eines Datums und einer Uhrzeit mithilfe der Formatierungskonventionen einer anderen Kultur zu analysieren. Außerdem wird gezeigt, wie ein Datums- und Uhrzeitwert erfolgreich analysiert wird, der nicht die Formatierungskonventionen der aktuellen Kultur 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 enthalten, gibt diese Methode einen DateTime Wert zurück, dessen Kind Eigenschaft ist DateTimeKind.Local , und konvertiert das Datum und die Uhrzeit in s Ortszeit. Andernfalls führt er keine Zeitzonenkonvertierung durch und gibt einen DateTime Wert zurück, dessen Kind -Eigenschaft ist DateTimeKind.Unspecified.

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

Diese Überladung versucht, mithilfe des DateTimeStyles.AllowWhiteSpaces Stils zu analysierens.

Weitere Informationen

Gilt für:

Parse(ReadOnlySpan<Char>, IFormatProvider)

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 s bereitstellt.

Gibt zurück

Das Ergebnis der Analyse svon .

Implementiert

Gilt für:

Parse(String, IFormatProvider)

Konvertiert die Zeichenfolgendarstellungen einer Datums- und Uhrzeitangabe unter Verwendung der kulturspezifischen Formatierungsinformationen in die entsprechende DateTime.

public:
 static DateTime Parse(System::String ^ s, IFormatProvider ^ provider);
public:
 static DateTime Parse(System::String ^ s, IFormatProvider ^ provider) = IParsable<DateTime>::Parse;
public static DateTime Parse (string s, IFormatProvider provider);
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 eine zu konvertierende Datums- und Zeitangabe enthält. Weitere Informationen finden Sie unter Die zu analysierende Zeichenfolge.

provider
IFormatProvider

Ein Objekt, das kulturspezifische Formatierungsinformationen zu s bereitstellt. Siehe Analysieren und kulturelle Konventionen

Gibt zurück

Ein Objekt, das der in s enthaltenen Datums- und Uhrzeitangabe nach den Angaben von provider entspricht.

Implementiert

Ausnahmen

s ist null.

s enthält keine gültige Zeichenfolgendarstellung einer Datums- und Uhrzeitangabe.

Beispiele

Im folgenden Beispiel wird ein Array von Datumszeichenfolgen mithilfe der Konventionen der Kulturen en-US, fr-FR und 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 enthalten, gibt diese Methode einen DateTime Wert zurück, dessen Kind Eigenschaft ist DateTimeKind.Local , und konvertiert das Datum und die Uhrzeit in s Ortszeit. Andernfalls führt er keine Zeitzonenkonvertierung durch und gibt einen DateTime Wert zurück, dessen Kind -Eigenschaft ist DateTimeKind.Unspecified.

Diese Überladung versucht, mithilfe des Stils DateTimeStyles.AllowWhiteSpaces zu analysierens.

Weitere Informationen

Gilt für:

Parse(ReadOnlySpan<Char>, IFormatProvider, DateTimeStyles)

Konvertiert eine Arbeitsspeicherspanne, die eine Zeichenfolgendarstellung einer Datums- und Uhrzeitangabe enthält, unter Verwendung der kulturspezifischen Formatierungsinformationen und eines Formatierungsstil in die entsprechende DateTime.

public static DateTime Parse (ReadOnlySpan<char> s, IFormatProvider? provider = default, System.Globalization.DateTimeStyles styles = System.Globalization.DateTimeStyles.None);
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 Spanne des Arbeitsspeichers, die die zu analysierende Zeichenfolge enthält. Weitere Informationen finden Sie unter Die zu analysierende Zeichenfolge.

provider
IFormatProvider

Ein Objekt, das kulturspezifische Formatierungsinformationen zu s bereitstellt. Siehe Analysieren und kulturelle Konventionen

styles
DateTimeStyles

Eine bitweise Kombination der Enumerationswerte, die die Stilelemente angibt, die in s vorhanden sein können, sodass der Analysevorgang erfolgreich abgeschlossen werden kann. Zudem wird festgelegt, wie das analysierte Datum in Bezug auf die aktuelle Zeitzone oder das aktuelle Datum interpretiert werden soll. Ein häufig angegebener Wert ist None.

Gibt zurück

Ein Objekt, das der in s enthaltenen Datums- und Uhrzeitangabe nach den Angaben von provider und styles entspricht.

Ausnahmen

s enthält keine gültige Zeichenfolgendarstellung einer Datums- und Uhrzeitangabe.

styles enthält eine ungültige Kombination von DateTimeStyles-Werten. Beispielsweise sowohl AssumeLocal als auch AssumeUniversal.

Gilt für:

Parse(String, IFormatProvider, DateTimeStyles)

Konvertiert die Zeichenfolgendarstellung einer Datums- und Uhrzeitangabe unter Verwendung der kulturspezifischen Formatierungsinformationen und eines Formatierungsstil in die entsprechende DateTime.

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);
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 eine zu konvertierende Datums- und Zeitangabe enthält. Weitere Informationen finden Sie unter Die zu analysierende Zeichenfolge.

provider
IFormatProvider

Ein Objekt, das kulturspezifische Formatierungsinformationen zu s bereitstellt. Siehe Analysieren und kulturelle Konventionen

styles
DateTimeStyles

Eine bitweise Kombination der Enumerationswerte, die die Stilelemente angibt, die in s vorhanden sein können, sodass der Analysevorgang erfolgreich abgeschlossen werden kann. Zudem wird festgelegt, wie das analysierte Datum in Bezug auf die aktuelle Zeitzone oder das aktuelle Datum interpretiert werden soll. Ein häufig angegebener Wert ist None.

Gibt zurück

Ein Objekt, das der in s enthaltenen Datums- und Uhrzeitangabe nach den Angaben von provider und styles entspricht.

Ausnahmen

s ist null.

s enthält keine gültige Zeichenfolgendarstellung einer Datums- und Uhrzeitangabe.

styles enthält eine ungültige Kombination von DateTimeStyles-Werten. Beispielsweise sowohl AssumeLocal als auch 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:

If Zeitzonenkonvertierung Kind-Eigenschaft
s enthält keine Zeitzoneninformationen. Keine 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. Zur koordinierten Weltzeit (UTC) DateTimeKind.Utc
senthält den Zeitzonen-Bezeichner Z oder GMT und styles enthält .DateTimeStyles.RoundtripKind Keine DateTimeKind.Utc

Weitere Informationen

Gilt für: