DateTime.Parse DateTime.Parse DateTime.Parse DateTime.Parse Method

Definition

Konvertiert die Zeichenfolgendarstellung einer Datums- und Uhrzeitangabe in die entsprechende DateTime.Converts the string representation of a date and time to its DateTime equivalent.

Überlädt

Parse(String) Parse(String) Parse(String) Parse(String)

Konvertiert die Zeichenfolgendarstellung einer Datums- und Uhrzeitangabe anhand der Konventionen für die aktuelle Threadkultur in die entsprechende DateTime.Converts the string representation of a date and time to its DateTime equivalent by using the conventions of the current thread culture.

Parse(String, IFormatProvider) Parse(String, IFormatProvider) Parse(String, IFormatProvider) Parse(String, IFormatProvider)

Konvertiert die Zeichenfolgendarstellungen einer Datums- und Uhrzeitangabe unter Verwendung der kulturspezifischen Formatierungsinformationen in die entsprechende DateTime.Converts the string representation of a date and time to its DateTime equivalent by using culture-specific format information.

Parse(ReadOnlySpan<Char>, IFormatProvider, DateTimeStyles) Parse(ReadOnlySpan<Char>, IFormatProvider, DateTimeStyles) 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.Converts a memory span that contains string representation of a date and time to its DateTime equivalent by using culture-specific format information and a formatting style.

Parse(String, IFormatProvider, DateTimeStyles) Parse(String, IFormatProvider, DateTimeStyles) Parse(String, IFormatProvider, DateTimeStyles) Parse(String, IFormatProvider, DateTimeStyles)

Konvertiert die Zeichenfolgendarstellung einer Datums- und Uhrzeitangabe unter Verwendung der kulturspezifischen Formatierungsinformationen und eines Formatierungsstil in die entsprechende DateTime.Converts the string representation of a date and time to its DateTime equivalent by using culture-specific format information and a formatting style.

Beispiele

Zahlreiche Beispiele, die aufgerufen werden die DateTime.Parse Methode in der gesamten vermischt werden die "Hinweise" Abschnitt dieses Artikels und in der Dokumentation für die einzelnen DateTime.Parse Überladungen.Numerous examples that call the DateTime.Parse method are interspersed throughout the Remarks section of this article and in the documentation for the individual DateTime.Parse overloads.

Hinweis

Die C#-Beispiele in diesem Artikel werden in der Inlinecodeausführung und dem Playground von Try.NET ausgeführt.The C# examples in this article run in the Try.NET inline code runner and playground. Klicken Sie auf die Schaltfläche Ausführen, um ein Beispiel in einem interaktiven Fenster auszuführen.Select the Run button to run an example in an interactive window. 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.Once you execute the code, you can modify it and run the modified code by selecting Run again. 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.The modified code either runs in the interactive window or, if compilation fails, the interactive window displays all C# compiler error messages.

Die lokale Zeitzone der Inlinecodeausführung und dem Playground von Try.NET wird ist die Koordinierte Weltzeit (UTC).The local time zone of the Try.NET inline code runner and playground is Coordinated Universal Time, or UTC. Dies kann sich auf das Verhalten und die Ausgabe von Beispielen auswirken, die die Typen DateTime, DateTimeOffset und TimeZoneInfo sowie deren Member veranschaulichen.This may affect the behavior and the output of examples that illustrate the DateTime, DateTimeOffset, and TimeZoneInfo types and their members.

Sie können auch einen vollständigen Satz von DateTime.Parse Beispiele, die im enthalten sind ein .NET Core 2.0-Projekt für C#-Code und .NET Core 2.0-Projekt für Visual Basic, aus der Dotnet / GitHub-beispielrepository.You can also download a complete set of DateTime.Parse examples, which are included in a .NET Core 2.0 project for C# and a .NET Core 2.0 project for Visual Basic, from the dotnet/samples GitHub repository.

Hinweise

In diesem AbschnittIn this section:

Welche Methode rufe ich?Which method do I call?

BeschreibungTo CallCall
Analysieren Sie eine Datum und Uhrzeit-Zeichenfolge mithilfe der Konventionen der aktuellen Kultur.Parse a date and time string by using the conventions of the current culture. Parse(String)-ÜberladungParse(String) overload
Analysieren Sie eine Datum und Uhrzeit-Zeichenfolge mit den Konventionen einer bestimmten Kultur.Parse a date and time string by using the conventions of a specific culture. Parse(String, IFormatProvider) überladen (siehe analysieren und kulturelle Konventionen)Parse(String, IFormatProvider) overload (see Parsing and Cultural Conventions)
Analysieren Sie eine Datum und Uhrzeit-Zeichenfolge mit speziellen Stilelemente (z.B. Leerzeichen oder keine Leerzeichen).Parse a date and time string with special style elements (such as white space or no white space). Parse(String, IFormatProvider, DateTimeStyles)-ÜberladungParse(String, IFormatProvider, DateTimeStyles) overload
Analysieren Sie eine Datum und Uhrzeit-Zeichenfolge, die in einem bestimmten Format sein muss.Parse a date and time string that must be in a particular format. DateTime.ParseExact oder DateTime.TryParseExactDateTime.ParseExact or DateTime.TryParseExact
Analysiert eine Zeichenfolge für Datum und Uhrzeit aus, und führen Sie eine Konvertierung in UTC-Zeit oder Ortszeit.Parse a date and time string and perform a conversion to UTC or local time. Parse(String, IFormatProvider, DateTimeStyles)-ÜberladungParse(String, IFormatProvider, DateTimeStyles) overload
Analysieren Sie eine Datum und Uhrzeit-Zeichenfolge ohne Ausnahmebehandlung.Parse a date and time string without handling exceptions. DateTime.TryParse-MethodeDateTime.TryParse method
Stellen Sie wieder her (Roundtrip) ein Datum und Uhrzeit-Wert erstellt, durch einen Formatierungsvorgang.Restore (round-trip) a date and time value created by a formatting operation. Übergeben Sie die "o" oder "R" Standardformat-Zeichenfolge, die ToString(String) -Methode, und rufen die Parse(String, IFormatProvider, DateTimeStyles) -Überladung mit DateTimeStyles.RoundtripKindPass the "o" or "r" standard format string to the ToString(String) method, and call the Parse(String, IFormatProvider, DateTimeStyles) overload with DateTimeStyles.RoundtripKind
Analysieren einer Datums- und Uhrzeitzeichenfolge in einem festen Format Computer (und möglicherweise kulturellen) hinweg.Parse a date and time string in a fixed format across machine (and possibly cultural) boundaries. DateTime.ParseExact oder DateTime.TryParseExact MethodeDateTime.ParseExact or DateTime.TryParseExact method

Die zu analysierende ZeichenfolgeThe string to parse

Die Parse -Methode versucht, die Zeichenfolgendarstellung eines Werts für Datum und Uhrzeit, konvertieren die DateTime entspricht.The Parse method tries to convert the string representation of a date and time value to its DateTime equivalent. Er versucht, die Eingabezeichenfolge vollständig ohne auszulösen Analysieren einer FormatException Ausnahme.It tries to parse the input string completely without throwing a FormatException exception.

Wichtig

Fällt der Analysevorgang aufgrund einer nicht erkannten Zeichenfolgenformat der Parse -Methode löst eine FormatException, während die TryParse Methodenrückgabe false.If the parsing operation fails because of an unrecognized string format, the Parse method throws a FormatException, whereas the TryParse method returns false. Da die Ausnahmebehandlung teuer sein kann, sollten Sie verwenden Parse bei wird der Analysevorgang erfolgreich ist, da die Eingabequelle als vertrauenswürdig eingestuft wird erwartet.Because exception handling can be expensive, you should use Parse when the parsing operation is expected to succeed because the input source is trusted. TryParse ist vorzuziehen, wenn Fehler bei der Analyse wahrscheinlich sind, insbesondere deshalb, weil eine Eingabequelle nicht vertrauenswürdig ist, oder Sie sinnvolle Standardwerte als Ersatz für Zeichenfolgen, die nicht erfolgreich analysiert haben.TryParse is preferable when parsing failures are likely, particularly because an input source is not trusted, or you have reasonable default values to substitute for strings that do not parse successfully.

Die zu analysierende Zeichenfolge kann eines der folgenden Formen annehmen:The string to be parsed can take any of the following forms:

  • Eine Zeichenfolge mit einer Datums- und Zeitangabe.A string with a date and a time component.

  • Eine Zeichenfolge mit der ein Datum, aber keine Komponente.A string with a date but no time component. Wenn die Komponente nicht vorhanden ist, nimmt die Methode 00:00 Uhr an.If the time component is absent, the method assumes 12:00 midnight. Wenn die Datumskomponente auf eine zweistellige Jahresangabe verfügt, wird eine Konvertierung in ein Jahr auf der Grundlage der Calendar.TwoDigitYearMax aktueller Kalender der aktuellen Kultur oder der angegebenen Kultur des aktuellen Kalenders (Wenn Sie eine Überladung mit einer nicht-Null verwenden provider Argument).If the date component has a two-digit year, it is converted to a year based on the Calendar.TwoDigitYearMax of the current culture's current calendar or the specified culture's current calendar (if you use an overload with a non-null provider argument).

  • Eine Zeichenfolge mit einer Datumskomponente, die nur den Monat und Jahr enthält, aber keine Komponente "Tag".A string with a date component that includes only the month and the year but no day component. Die Methode wird der erste Tag des Monats angenommen.The method assumes the first day of the month.

  • Eine Zeichenfolge mit der eine Datumskomponente, die nur den Monat und Tag enthält jedoch keine Komponente "Jahr".A string with a date component that includes only the month and the day but no year component. Die Methode wird das aktuelle Jahr angenommen.The method assumes the current year.

  • Eine Zeichenfolge mit einer Uhrzeit, aber ohne Datumskomponente.A string with a time but no date component. Die Methode wird das aktuelle Datum angenommen, es sei denn, Sie rufen die Parse(String, IFormatProvider, DateTimeStyles) überladen und umfassen DateTimeStyles.NoCurrentDateDefault in die styles -Argument, in dem Fall die Methode geht davon aus einem Datum des 1. Januars 0001.The method assumes the current date unless you call the Parse(String, IFormatProvider, DateTimeStyles) overload and include DateTimeStyles.NoCurrentDateDefault in the styles argument, in which case the method assumes a date of January 1, 0001.

  • Eine Zeichenfolge mit einer Komponente, die nur die Stunde und einer AM/PM-Kennzeichner, mit ohne Datumskomponente enthält.A string with a time component that includes only the hour and an AM/PM designator, with no date component. Die Methode setzt voraus, das aktuelle Datum und eine Uhrzeit mit keine Minuten und ohne Sekunden.The method assumes the current date and a time with no minutes and no seconds. Sie können dieses Verhalten ändern, durch den Aufruf der Parse(String, IFormatProvider, DateTimeStyles) überladen und umfassen DateTimeStyles.NoCurrentDateDefault in die styles -Argument, in dem Fall die Methode geht davon aus einem Datum des 1. Januars 0001.You can change this behavior by calling the Parse(String, IFormatProvider, DateTimeStyles) overload and include DateTimeStyles.NoCurrentDateDefault in the styles argument, in which case the method assumes a date of January 1, 0001.

  • Eine Zeichenfolge, die Zeitzoneninformationen enthält und ISO 8601 entspricht.A string that includes time zone information and conforms to ISO 8601. In den folgenden Beispielen wird die erste Zeichenfolge kennzeichnet den Coordinated Universal Time (UTC), und die zweite bezieht sich auf die Zeit in einer Zeitzone, die sieben Stunden vor UTC:In the following examples, the first string designates Coordinated Universal Time (UTC), and the second designates the time in a time zone that's seven hours earlier than UTC:

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

  • Eine Zeichenfolge, die den GMT-Bezeichner enthält und das RFC 1123-Zeitformat entspricht; Zum Beispiel:A string that includes the GMT designator and conforms to the RFC 1123 time format; for example:

    "SA, 01. November 2008 19:35:00 GMT""Sat, 01 Nov 2008 19:35:00 GMT"

  • Eine Zeichenfolge, die das Datum und Uhrzeit sowie Zeitzone Offsetinformationen enthält. Zum Beispiel:A string that includes the date and time along with time zone offset information; for example:

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

Im folgenden Beispiel werden Zeichenfolgen in jeder der folgenden Formate mithilfe der Formatierungskonventionen der aktuellen Kultur, die in diesem Fall wird von der Kultur En-US analysiert:The following example parses strings in each of these formats by using the formatting conventions of the current culture, which in this case is the en-US culture:

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


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 ein Schalttag in einem Schaltjahr im Kalender ein, die die Methode darstellt (finden Sie unter analysieren und kulturelle Konventionen), wird die Parse Methode die Zeichenfolge erfolgreich analysiert.If the input string represents a leap day in a leap year in the calendar used by the parsing method (see Parsing and cultural conventions), the Parse method parses the string successfully. Wenn die Eingabezeichenfolge einen Schalttag in einem nicht-Schaltjahr darstellt, löst die Methode eine FormatException.If the input string represents a leap day in a non-leap year, the method throws a FormatException.

Da die Parse Methode versucht, die Zeichenfolgendarstellung eines Datums zu analysieren und anhand der Regeln zur Formatierung der aktuellen oder einer angegebenen Kultur, die beim Analysieren einer Zeichenfolge in verschiedenen Kulturen kann ein Fehler auftreten.Because the Parse method tries to parse the string representation of a date and time by using the formatting rules of the current or a specified culture, trying to parse a string across different cultures can fail. Um ein bestimmtes Datum und Uhrzeit-Format in verschiedenen Gebietsschemas zu analysieren, verwenden Sie eine der Überladungen der DateTime.ParseExact Methode, und geben Sie einen Formatbezeichner.To parse a specific date and time format across different locales, use one of the overloads of the DateTime.ParseExact method and provide a format specifier.

Analysieren und kulturelle KonventionenParsing and cultural conventions

Alle Überladungen der der Parse Methode sind kulturabhängig, wenn die Zeichenfolge analysiert werden soll (dargestellt durch s in der folgenden Tabelle) entspricht dem ISO 8601-Muster.All overloads of the Parse method are culture-sensitive unless the string to be parsed (which is represented by s in the following table) conforms to the ISO 8601 pattern. Der Analysevorgang verwendet den Formatierungsinformationen in eine DateTimeFormatInfo -Objekt, das wie folgt abgeleitet ist:The parsing operation uses the formatting information in a DateTimeFormatInfo object that is derived as follows:

Wichtig

Die Zeitrechnung in japanischen Kalendern basiert auf den Regierungsperioden der Kaiser und wird sich daher erwartungsgemäß ändern.Eras in the Japanese calendars are based on the emperor's reign and are therefore expected to change. Beispiel: Der 1. Mai 2019 markiert den Beginn des Reiwa-Zeitabschnitts in den Kalendern des Typs JapaneseCalendar und JapaneseLunisolarCalendar.For example, May 1, 2019 marked the beginning of the Reiwa era in the JapaneseCalendar and JapaneseLunisolarCalendar. Eine derartige Änderung der Zeitabschnitte betrifft alle Anwendungen, die diese Kalender verwenden.Such a change of era affects all applications that use these calendars. Unter Handling a new era in the Japanese calendar in .NET (Umgang mit einem neuen Zeitabschnitt im japanischen Kalender in .NET) finden Sie weiter Informationen und wie Sie bestimmen können, ob Ihre Anwendungen ebenfalls betroffen sind.See Handling a new era in the Japanese calendar in .NET for more information and to determine whether your applications are affected. Unter Prepare your application for the Japanese era change (Vorbereiten Ihrer Anwendung für die Änderung des Zeitabschnitts im japanischen Kalender) finden Sie Informationen zum Testen Ihrer Anwendungen auf Windows-Systemen, um deren Bereitschaft für die Änderung im Zeitabschnitt sicherzustellen.See Prepare your application for the Japanese era change for information on testing your applications on Windows systems to ensure their readiness for the era change. Unter Arbeiten mit Zeiträumen finden Sie Informationen zu Funktionen in .NET, die Kalender mit mehreren Zeitabschnitten unterstützen, sowie bewährte Vorgehensweisen bei der Arbeit mit solchen Kalendern.See Working with eras for features in .NET that support calendars with multiple eras and for best practices when working with calendars that support multiple eras.

Wenn Sie aufrufenIf you call Und provider istAnd provider is Informationen über die Formatierung wird von abgeleitet.Formatting information is derived from
Parse(String) - Die aktuelle Threadkultur (DateTimeFormatInfo.CurrentInfo Eigenschaft)The current thread culture (DateTimeFormatInfo.CurrentInfo property)
Parse(String, IFormatProvider) oder Parse(String, IFormatProvider, DateTimeStyles)Parse(String, IFormatProvider) or Parse(String, IFormatProvider, DateTimeStyles) Ein DateTimeFormatInfo Objekta DateTimeFormatInfo object Das angegebene DateTimeFormatInfo ObjektThe specified DateTimeFormatInfo object
Parse(String, IFormatProvider) oder Parse(String, IFormatProvider, DateTimeStyles)Parse(String, IFormatProvider) or Parse(String, IFormatProvider, DateTimeStyles) null Die aktuelle Threadkultur (DateTimeFormatInfo.CurrentInfo Eigenschaft)The current thread culture (DateTimeFormatInfo.CurrentInfo property)
Parse(String, IFormatProvider) oder Parse(String, IFormatProvider, DateTimeStyles)Parse(String, IFormatProvider) or Parse(String, IFormatProvider, DateTimeStyles) Ein CultureInfo Objekta CultureInfo object Die CultureInfo.DateTimeFormat-Eigenschaft.The CultureInfo.DateTimeFormat property
Parse(String, IFormatProvider) oder Parse(String, IFormatProvider, DateTimeStyles)Parse(String, IFormatProvider) or Parse(String, IFormatProvider, DateTimeStyles) Benutzerdefinierte IFormatProvider ImplementierungCustom IFormatProvider implementation Die IFormatProvider.GetFormat -MethodeThe IFormatProvider.GetFormat method

Wenn die Informationen zur Formatierung von abgeleitet ist eine DateTimeFormatInfo Objekt der DateTimeFormatInfo.Calendar Eigenschaft definiert, den Kalender, die in den Analysevorgang verwendet.When formatting information is derived from a DateTimeFormatInfo object, the DateTimeFormatInfo.Calendar property defines the calendar used in the parsing operation.

Wenn Sie mit eine Datums- und Uhrzeitzeichenfolge Analysieren einer DateTimeFormatInfo Objekt mit benutzerdefinierten Einstellungen, die sich von denen einer standardmäßigen Kultur unterscheiden, verwenden Sie die ParseExact -Methode anstelle der Parse Methode, um die Wahrscheinlichkeit für eine erfolgreiche Konvertierung zu verbessern.If you parse a date and time string by using a DateTimeFormatInfo object with customized settings that are different from those of a standard culture, use the ParseExact method instead of the Parse method to improve the chances for a successful conversion. Eine nicht standardmäßige Datums- und Zeitzeichenfolge möglich komplizierten und schwer zu analysieren.A non-standard date and time string can be complicated and difficult to parse. Die Parse Methode versucht, eine Zeichenfolge mit mehrerer impliziter Analysemuster analysieren alle möglicherweise fehlschlagen.The Parse method tries to parse a string with several implicit parse patterns, all of which might fail. Im Gegensatz dazu die ParseExact Methode müssen Sie mindestens eine exakte Analysemuster angeben, die voraussichtlich erfolgreich sein werden.In contrast, the ParseExact method requires you to explicitly designate one or more exact parse patterns that are likely to succeed. Weitere Informationen finden Sie im Abschnitt "DateTimeFormatInfo und dynamischer Daten" in der DateTimeFormatInfo Thema.For more information, see the "DateTimeFormatInfo and Dynamic Data" section in the DateTimeFormatInfo topic.

Wichtig

Beachten Sie, dass die Formatierungskonventionen für eine bestimmte Kultur dynamisch sind und können jederzeit geändert werden.Note that the formatting conventions for a particular culture are dynamic and can be subject to change. Dies bedeutet, die angeben, Analyseoperationen, die abhängig von der Formatierungskonventionen der die Standardkultur (aktuellen) oder dass eine IFormatProvider -Objekt, das eine Kultur als der invarianten Kultur darstellt kann unerwartet fehlschlagen, wenn eine der folgenden auftritt:This means that parsing operations that depend on the formatting conventions of the default (current) culture or that specify an IFormatProvider object that represents a culture other than the invariant culture can unexpectedly fail if any of the following occurs:

  • Die kulturspezifische Daten zwischen Haupt- oder Nebenversion von Versionen von .NET Framework oder als Ergebnis ein Update der vorhandenen Version von .NET Framework geändert.The culture-specific data has changed between major or minor versions of the .NET Framework or as the result of an update to the existing version of the .NET Framework.
  • Die kulturspezifische Daten widerspiegelt, benutzereinstellungen, die von Computer zu Computer oder die Sitzung variieren können.The culture-specific data reflects user preferences, which can vary from machine to machine or session to session.
  • Die kulturspezifische Daten darstellt, eine Ersatzkultur, die die Einstellungen der eine Standardkultur oder eine benutzerdefinierte Kultur überschreibt.The culture-specific data represents a replacement culture that overrides the settings of a standard culture or a custom culture.

Um zu verhindern, dass die schwierigkeiten bei der Analyse von Daten und die Uhrzeit-Zeichenfolgen, die Änderungen in den kulturellen Daten zugeordnet sind, können Sie Zeichenfolgen für Datum und Uhrzeit mit der invarianten Kultur analysieren, oder Sie rufen die ParseExact oder TryParseExact Methode, und geben Sie das genaue Format der zu analysierende Zeichenfolge.To prevent the difficulties in parsing data and time strings that are associated with changes in cultural data, you can parse date and time strings by using the invariant culture, or you can call the ParseExact or TryParseExact method and specify the exact format of the string to be parsed. Wenn Sie sind serialisieren und Deserialisieren von Datums-und Uhrzeitdaten, Sie die Formatierungskonventionen der invarianten Kultur verwenden können, oder Sie serialisieren und Deserialisieren können die DateTime Wert in einem binären Format.If you are serializing and deserializing date and time data, you can either use the formatting conventions of the invariant culture, or you can serialize and deserialize the DateTime value in a binary format.

Weitere Informationen finden Sie im Abschnitt "dynamische Kulturdaten" in der CultureInfo Thema und die "beibehalten" DateTime "Werte" im Abschnitt der DateTime Thema.For more information see the "Dynamic culture data" section in the CultureInfo topic and the "Persisting DateTime values" section in the DateTime topic.

Elemente analysieren und formatierenParsing and style elements

Alle Parse Überladungen ignorieren führende, interne und nachfolgende Leerzeichen in der Eingabezeichenfolge (dargestellt durch s in der folgenden Tabelle).All Parse overloads ignore leading, inner, or trailing white-space characters in the input string (which is represented by s in the following table). Datum und Uhrzeit können mit einem Paar aus der führende und nachfolgende Nummernzeichen-Zeichen ("#", U + 0023) gekennzeichnet werden und eingeschlossen werden können, mit einem oder mehreren NULL-Zeichen (U + 0000).The date and time can be bracketed with a pair of leading and trailing NUMBER SIGN characters ("#", U+0023), and can be trailed with one or more NULL characters (U+0000).

Darüber hinaus die Parse(String, IFormatProvider, DateTimeStyles) Überladung hat eine styles Parameter, der eine oder mehrere Member besteht aus den DateTimeStyles Enumeration.In addition, the Parse(String, IFormatProvider, DateTimeStyles) overload has a styles parameter that consists of one or more members of the DateTimeStyles enumeration. Dieser Parameter definiert wie s interpretiert werden soll und wie der Analysevorgang konvertieren soll s in ein Datum und Uhrzeit.This parameter defines how s should be interpreted and how the parse operation should convert s to a date and time. Die folgende Tabelle beschreibt die Auswirkungen der einzelnen DateTimeStyles Element in den Analysevorgang.The following table describes the effect of each DateTimeStyles member on the parse operation.

DateTimeStyles-ElementDateTimeStyles member Auswirkungen auf die KonvertierungEffect on conversion
AdjustToUniversal Analysiert s und, falls erforderlich, eine Konvertierung in UTC, wie folgt:Parses s and, if necessary, converts it to UTC, as follows:

-If s einen Zeitzonenoffset umfasst oder wenn s enthält keine Zeitzoneninformationen aber styles enthält die AssumeLocal Flag, das die Methode analysiert die Zeichenfolge, ruft ToUniversalTime zurückgegebenen konvertieren DateTime Wert UTC-Zeit, und legt die Kind Eigenschaft DateTimeKind.Utc.- If s includes a time zone offset, or if s contains no time zone information but styles includes the AssumeLocal flag, the method parses the string, calls ToUniversalTime to convert the returned DateTime value to UTC, and sets the Kind property to DateTimeKind.Utc.
-If s gibt an, dass es sich um UTC, darstellt oder wenn s enthält keine Informationen zur Zeitzone aber styles enthält die AssumeUniversal Flag Methode analysiert die Zeichenfolge, die keine zeitzonenkonvertierung ausführt, für das zurückgegebene DateTime Wert und legt die Kind Eigenschaft DateTimeKind.Utc.- If s indicates that it represents UTC, or if s does not contain time zone information but styles includes the AssumeUniversal flag, the method parses the string, performs no time zone conversion on the returned DateTime value, and sets the Kind property to DateTimeKind.Utc.
-In allen anderen Fällen hat das Flag keine Auswirkungen.- In all other cases, the flag has no effect.
AllowInnerWhite Dieser Wert wird ignoriert.This value is ignored. Interne Leerzeichen sind immer zulässig, in den Elementen für Datum und Uhrzeit des s.Inner white space is always permitted in the date and time elements of s.
AllowLeadingWhite Dieser Wert wird ignoriert.This value is ignored. Führendes Leerzeichen ist immer zulässig, in den Elementen für Datum und Uhrzeit des s.Leading white space is always permitted in the date and time elements of s.
AllowTrailingWhite Dieser Wert wird ignoriert.This value is ignored. Nachfolgende Leerzeichen ist immer zulässig, in den Elementen für Datum und Uhrzeit des s.Trailing white space is always permitted in the date and time elements of s.
AllowWhiteSpaces Gibt an, dass s führenden, inneren und nachgestellte Leerzeichen enthalten kann.Specifies that s may contain leading, inner, and trailing white spaces. Dies ist das Standardverhalten.This is the default behavior. Es kann nicht überschrieben werden, durch Angeben eines restriktiveren DateTimeStyles Enumerationswert wie z. B. None.It cannot be overridden by supplying a more restrictive DateTimeStyles enumeration value such as None.
AssumeLocal Gibt an, dass bei s Zeitzoneninformation, lokale Zeit wird davon ausgegangen, dass fehlt.Specifies that if s lacks any time zone information, local time is assumed. Wenn die AdjustToUniversal Flag vorhanden ist, ist die Kind -Eigenschaft des zurückgegebenen DateTime Wert wird festgelegt, um DateTimeKind.Local.Unless the AdjustToUniversal flag is present, the Kind property of the returned DateTime value is set to DateTimeKind.Local.
AssumeUniversal Gibt an, dass bei s besitzt Informationen zur Zeitzone auf UTC wird angenommen.Specifies that if s lacks any time zone information, UTC is assumed. Wenn die AdjustToUniversal Flag vorhanden ist, wird die Methode konvertiert die zurückgegebene DateTime Wert zwischen UTC und Ortszeit und legt seine Kind Eigenschaft DateTimeKind.Local.Unless the AdjustToUniversal flag is present, the method converts the returned DateTime value from UTC to local time and sets its Kind property to DateTimeKind.Local.
None Obwohl gültig ist, wird dieser Wert ignoriert.Although valid, this value is ignored.
RoundtripKind Für Zeichenfolgen, die Zeitzoneninformationen enthalten wird versucht, um zu verhindern, dass die Konvertierung einer Zeichenfolge für Datum und Uhrzeit in eine DateTime -Wert, der eine lokale Zeit mit der Kind -Eigenschaft auf festgelegt DateTimeKind.Local.For strings that contain time zone information, tries to prevent the conversion of a date and time string to a DateTime value that represents a local time with its Kind property set to DateTimeKind.Local. In der Regel wird durch Aufrufen eine solchen Zeichenfolge erstellt die DateTime.ToString(String) Methode und mithilfe der Standardformatbezeichner "o", "R" oder "u".Typically, such a string is created by calling the DateTime.ToString(String) method and by using the "o", "r", or "u" standard format specifier.

Der Rückgabewert und DateTime.KindThe return value and DateTime.Kind

Die DateTime.Parse überlädt die Rückgabe einer DateTime , deren Wert Kind Eigenschaft enthält Informationen zur Zeitzone.The DateTime.Parse overloads return a DateTime value whose Kind property includes time zone information. Es kann darauf hinweisen, dass die Zeit:It can indicate that the time is:

Im Allgemeinen die Parse Methode gibt eine DateTime Objekt, dessen Kind Eigenschaft DateTimeKind.Unspecified.Generally, the Parse method returns a DateTime object whose Kind property is DateTimeKind.Unspecified. Allerdings die Parse Methode kann auch zeitzonenkonvertierung durchführen, und legen Sie den Wert des der Kind Eigenschaft unterschiedlich, je nach den Werten der der s und styles Parameter:However, the Parse method may also perform time zone conversion and set the value of the Kind property differently, depending on the values of the s and styles parameters:

IfIf ZeitzonenkonvertierungTime zone conversion Kind-EigenschaftKind property
s enthält Informationen zur Zeitzone an.s contains time zone information. Das Datum und die Uhrzeit wird auf die Zeit in die lokale Zeitzone konvertiert.The date and time is converted to the time in the local time zone. DateTimeKind.Local
s enthält Informationen, die Zeitzone und styles enthält die AdjustToUniversal Flag.s contains time zone information, and styles includes the AdjustToUniversal flag. Das Datum und die Uhrzeit wird in die koordinierte Weltzeit (UTC) konvertiert.The date and time is converted to Coordinated Universal Time (UTC). DateTimeKind.Utc
s Der Kennzeichner des Z oder GMT-Zeitzone enthält und styles enthält die RoundtripKind Flag.s contains the Z or GMT time zone designator, and styles includes the RoundtripKind flag. Datum und Uhrzeit interpretiert werden als UTC.The date and time are interpreted as UTC. DateTimeKind.Utc

Im folgende Beispiel wird die Datumszeichenfolgen, die auf die Zeit in die lokale Zeitzone Zeitzoneninformationen konvertiert:The following example converts date strings that contain time zone information to the time in the local time zone:

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                                             
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 beibehalten, den Wert von Datum und Uhrzeit Kind -Eigenschaft während einer Formatierung und Analyse Vorgang unter Verwendung der DateTimeStyles.RoundtripKind Flag.You can also preserve the value of a date and time's Kind property during a formatting and parsing operation by using the DateTimeStyles.RoundtripKind flag. Im folgende Beispiel wird veranschaulicht, wie die RoundtripKind Flag wirkt sich auf den Analysevorgang auf DateTime Werte, die in Zeichenfolgen konvertiert werden, indem Sie mit dem Formatbezeichner "o", "R" oder "u".The following example illustrates how the RoundtripKind flag affects the parsing operation on DateTime values that are converted to strings by using the "o", "r", or "u" format specifier.

   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.      
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) Parse(String) Parse(String) Parse(String)

Konvertiert die Zeichenfolgendarstellung einer Datums- und Uhrzeitangabe anhand der Konventionen für die aktuelle Threadkultur in die entsprechende DateTime.Converts the string representation of a date and time to its DateTime equivalent by using the conventions of the current thread culture.

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 String String String

Eine Zeichenfolge, die eine zu konvertierende Datums- und Zeitangabe enthält.A string that contains a date and time to convert. Weitere Informationen finden Sie unter Die zu analysierende Zeichenfolge.See The string to parse for more information.

Gibt zurück

Ein Objekt, das mit der in s enthaltenen Datums- und Uhrzeitangabe identisch ist.An object that is equivalent to the date and time contained in s.

Ausnahmen

s enthält keine gültige Zeichenfolgendarstellung einer Datums- und Uhrzeitangabe.s does not contain a valid string representation of a date and time.

Hinweise

Wenn s Zeitzoneninformationen, enthält diese Methode gibt eine DateTime , deren Wert Kind -Eigenschaft ist DateTimeKind.Local und konvertiert die Datums- und Uhrzeitangabe im s in die lokale Zeit.If s contains time zone information, this method returns a DateTime value whose Kind property is DateTimeKind.Local and converts the date and time in s to local time. Andernfalls führt keine Konvertierung Zeitzone aus und gibt eine DateTime , deren Wert Kind Eigenschaft DateTimeKind.Unspecified.Otherwise, it performs no time zone conversion and returns a DateTime value whose Kind property is DateTimeKind.Unspecified.

Diese Überladung versucht, zu analysieren s unter Verwendung der Formatierungskonventionen der aktuellen Kultur.This overload attempts to parse s by using the formatting conventions of the current culture. Die aktuelle Kultur wird angegeben, indem die CurrentCulture Eigenschaft.The current culture is indicated by the CurrentCulture property. Um eine Zeichenfolge, die Verwendung der Formatierungskonventionen einer bestimmten Kultur zu analysieren, rufen Sie die Parse(String, IFormatProvider) oder Parse(String, IFormatProvider, DateTimeStyles) Überladungen.To parse a string using the formatting conventions of a specific culture, call the Parse(String, IFormatProvider) or the Parse(String, IFormatProvider, DateTimeStyles) overloads.

Diese Überladung versucht, zu analysieren s mit DateTimeStyles.AllowWhiteSpaces Stil.This overload attempts to parse s by using DateTimeStyles.AllowWhiteSpaces style.

BeispielExample

Im folgenden Beispiel analysiert die angegebene Zeichenfolgendarstellung mehrere Datum und Uhrzeit-Werte von:The following example parses the string representation of several date and time values by:

  • Verwenden den Standardanbieter für die Format, bietet das die Formatierungskonventionen der aktuellen Threadkultur des Computers verwendet, um die Beispielausgabe zu erzeugen.Using the default format provider, which provides the formatting conventions of the current thread culture of the computer used to produce the example output. Die Ausgabe in diesem Beispiel gibt die Formatierungskonventionen der Kultur En-US.The output from this example reflects the formatting conventions of the en-US culture.

  • Mit dem Standardwert für die Formatvorlage, handelt es sich AllowWhiteSpaces.Using the default style value, which is AllowWhiteSpaces.

Es behandelt die FormatException Ausnahme wird ausgelöst, wenn die Methode versucht, die Zeichenfolgendarstellung einer Datums- und Uhrzeitangabe unter Verwendung von anderen Kultur analysiert die Formatierungskonventionen.It handles the FormatException exception that is thrown when the method tries to parse the string representation of a date and time by using some other culture's formatting conventions. Es wird gezeigt, wie erfolgreich einen Datum und Uhrzeit-Wert analysiert werden, der nicht die Formatierungskonventionen der aktuellen Threadkultur verwendet.It also shows how to successfully parse a date and time value that does not use the formatting conventions of the current thread culture.

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.
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.
Siehe auch

Parse(String, IFormatProvider) Parse(String, IFormatProvider) Parse(String, IFormatProvider) Parse(String, IFormatProvider)

Konvertiert die Zeichenfolgendarstellungen einer Datums- und Uhrzeitangabe unter Verwendung der kulturspezifischen Formatierungsinformationen in die entsprechende DateTime.Converts the string representation of a date and time to its DateTime equivalent by using culture-specific format information.

public:
 static DateTime Parse(System::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 String String String

Eine Zeichenfolge, die eine zu konvertierende Datums- und Zeitangabe enthält.A string that contains a date and time to convert. Weitere Informationen finden Sie unter Die zu analysierende Zeichenfolge.See The string to parse for more information.

provider
IFormatProvider IFormatProvider IFormatProvider IFormatProvider

Ein Objekt, das kulturspezifische Formatierungsinformationen zu s bereitstellt.An object that supplies culture-specific format information about s. Siehe Analysieren und kulturelle KonventionenSee Parsing and cultural conventions

Gibt zurück

Ein Objekt, das der in s enthaltenen Datums- und Uhrzeitangabe nach den Angaben von provider entspricht.An object that is equivalent to the date and time contained in s as specified by provider.

Ausnahmen

s enthält keine gültige Zeichenfolgendarstellung einer Datums- und Uhrzeitangabe.s does not contain a valid string representation of a date and time.

Hinweise

Wenn s Zeitzoneninformationen, enthält diese Methode gibt eine DateTime , deren Wert Kind -Eigenschaft ist DateTimeKind.Local und konvertiert die Datums- und Uhrzeitangabe im s in die lokale Zeit.If s contains time zone information, this method returns a DateTime value whose Kind property is DateTimeKind.Local and converts the date and time in s to local time. Andernfalls führt keine Konvertierung Zeitzone aus und gibt eine DateTime , deren Wert Kind Eigenschaft DateTimeKind.Unspecified.Otherwise, it performs no time zone conversion and returns a DateTime value whose Kind property is DateTimeKind.Unspecified.

Diese Überladung versucht, zu analysieren s mithilfe der DateTimeStyles.AllowWhiteSpaces Stil.This overload attempts to parse s by using the DateTimeStyles.AllowWhiteSpaces style.

BeispielExample

Im folgende Beispiel werden ein Array von Zeichenfolgen mithilfe der Konventionen von der En-US, fr-FR und de-DE Kulturen analysiert.The following example parses an array of date strings by using the conventions of the en-US, fr-FR, and de-DE cultures. Es zeigt, dass die zeichenfolgendarstellungen für ein einzelnes Datum in verschiedenen Kulturen unterschiedlich interpretiert werden können.It demonstrates that the string representations of a single date can be interpreted differently across different cultures.

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.
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.
Siehe auch

Parse(ReadOnlySpan<Char>, IFormatProvider, DateTimeStyles) Parse(ReadOnlySpan<Char>, IFormatProvider, DateTimeStyles) 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.Converts a memory span that contains string representation of a date and time to its DateTime equivalent by using culture-specific format information and a formatting style.

public static DateTime Parse (ReadOnlySpan<char> s, IFormatProvider provider = null, 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 = null, 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.The memory span that contains the string to parse. Weitere Informationen finden Sie unter Die zu analysierende Zeichenfolge.See The string to parse for more information.

provider
IFormatProvider IFormatProvider IFormatProvider IFormatProvider

Ein Objekt, das kulturspezifische Formatierungsinformationen zu s bereitstellt.An object that supplies culture-specific format information about s. Siehe Analysieren und kulturelle KonventionenSee Parsing and cultural conventions

styles
DateTimeStyles DateTimeStyles DateTimeStyles 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.A bitwise combination of the enumeration values that indicates the style elements that can be present in s for the parse operation to succeed, and that defines how to interpret the parsed date in relation to the current time zone or the current date. Ein häufig angegebener Wert ist None.A typical value to specify is None.

Gibt zurück

Ein Objekt, das der in s enthaltenen Datums- und Uhrzeitangabe nach den Angaben von provider und styles entspricht.An object that is equivalent to the date and time contained in s, as specified by provider and styles.

Ausnahmen

s enthält keine gültige Zeichenfolgendarstellung einer Datums- und Uhrzeitangabe.s does not contain a valid string representation of a date and time.

styles enthält eine ungültige Kombination von DateTimeStyles-Werten.styles contains an invalid combination of DateTimeStyles values. Beispielsweise sowohl AssumeLocal als auch AssumeUniversal.For example, both AssumeLocal and AssumeUniversal.

Parse(String, IFormatProvider, DateTimeStyles) Parse(String, IFormatProvider, DateTimeStyles) Parse(String, IFormatProvider, DateTimeStyles) Parse(String, IFormatProvider, DateTimeStyles)

Konvertiert die Zeichenfolgendarstellung einer Datums- und Uhrzeitangabe unter Verwendung der kulturspezifischen Formatierungsinformationen und eines Formatierungsstil in die entsprechende DateTime.Converts the string representation of a date and time to its DateTime equivalent by using culture-specific format information and a formatting style.

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 String String String

Eine Zeichenfolge, die eine zu konvertierende Datums- und Zeitangabe enthält.A string that contains a date and time to convert. Weitere Informationen finden Sie unter Die zu analysierende Zeichenfolge.See The string to parse for more information.

provider
IFormatProvider IFormatProvider IFormatProvider IFormatProvider

Ein Objekt, das kulturspezifische Formatierungsinformationen zu s bereitstellt.An object that supplies culture-specific formatting information about s. Siehe Analysieren und kulturelle KonventionenSee Parsing and cultural conventions

styles
DateTimeStyles DateTimeStyles DateTimeStyles 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.A bitwise combination of the enumeration values that indicates the style elements that can be present in s for the parse operation to succeed, and that defines how to interpret the parsed date in relation to the current time zone or the current date. Ein häufig angegebener Wert ist None.A typical value to specify is None.

Gibt zurück

Ein Objekt, das der in s enthaltenen Datums- und Uhrzeitangabe nach den Angaben von provider und styles entspricht.An object that is equivalent to the date and time contained in s, as specified by provider and styles.

Ausnahmen

s enthält keine gültige Zeichenfolgendarstellung einer Datums- und Uhrzeitangabe.s does not contain a valid string representation of a date and time.

styles enthält eine ungültige Kombination von DateTimeStyles-Werten.styles contains an invalid combination of DateTimeStyles values. Beispielsweise sowohl AssumeLocal als auch AssumeUniversal.For example, both AssumeLocal and AssumeUniversal.

Hinweise

Diese methodenüberladung konvertiert, das Datum und Uhrzeit im s und legt die Kind -Eigenschaft des zurückgegebenen DateTime -Wert wie folgt:This method overload converts the date and time in s and sets the Kind property of the returned DateTime value as follows:

IfIf ZeitzonenkonvertierungTime zone conversion Kind-EigenschaftKind property
s enthält keine Zeitzoneninformationen.s contains no time zone information. KeineNone. DateTimeKind.Unspecified
s enthält Informationen zur Zeitzone an.s contains time zone information. Um die Zeit in die lokale ZeitzoneTo the time in the local time zone DateTimeKind.Local
s enthält Informationen, die Zeitzone und "Styles enthält die DateTimeStyles.AdjustToUniversal Flag.s contains time zone information, and `styles includes the DateTimeStyles.AdjustToUniversal flag. Zu koordinierter Weltzeit (UTC)To Coordinated Universal Time (UTC) DateTimeKind.Utc
s Der Kennzeichner des Z oder GMT-Zeitzone enthält und styles enthält die DateTimeStyles.RoundtripKind.s contains the Z or GMT time zone designator, and styles includes the DateTimeStyles.RoundtripKind. KeineNone. Utc

BeispielExample

Das folgende Beispiel zeigt die Parse(String, IFormatProvider, DateTimeStyles) Methode und zeigt den Wert der Kind -Eigenschaft des resultierenden DateTime Werte.The following example demonstrates the Parse(String, IFormatProvider, DateTimeStyles) method and displays the value of the Kind property of the resulting DateTime values.

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.
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.
Siehe auch

Gilt für: