DateTime.Parse Methode

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)

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)

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)

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)

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

Viele Beispiele, die die DateTime.Parse-Methode aufzurufen, werden im Abschnitt " Hinweise " in diesem Artikel und in der Dokumentation für die einzelnen DateTime.Parse-über Ladungen vermischt.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

Einige C#-Beispiele in diesem Artikel werden in der Inlinecodeausführung und dem Playground von Try.NET ausgeführt.Some 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 kompletten Satz von DateTime.Parse-Beispielen herunterladen, die in einem .net Core 2,0-Projekt C# für und ein .net Core 2,0-Projekt für Visual Basicenthalten sind, aus dem GitHub-Repository "dotnet/Samples".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 auf?Which method do I call?

BeschreibungTo CallCall
Analysieren Sie eine Datums-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 Datums-und Uhrzeit Zeichenfolge mithilfe der Konventionen einer bestimmten Kultur.Parse a date and time string by using the conventions of a specific culture. Parse(String, IFormatProvider)-Überladung (siehe "auswerten und kulturelle Konventionen")Parse(String, IFormatProvider) overload (see Parsing and Cultural Conventions)
Analysieren Sie eine Datums-und Uhrzeit Zeichenfolge mit speziellen Stilelementen (z. b. Leerzeichen oder 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 Datums-und Uhrzeit Zeichenfolge, die in einem bestimmten Format vorliegen muss.Parse a date and time string that must be in a particular format. DateTime.ParseExact oder DateTime.TryParseExactDateTime.ParseExact or DateTime.TryParseExact
Analysieren Sie eine Datums-und Uhrzeit Zeichenfolge, und führen Sie eine Konvertierung in UTC oder Ortszeit durch.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 Datums-und Uhrzeit Zeichenfolge, ohne Ausnahmen zu behandeln.Parse a date and time string without handling exceptions. DateTime.TryParse-MethodeDateTime.TryParse method
Stellen Sie einen von einem Formatierungs Vorgang erstellten Datums-und Uhrzeitwert wieder her (Roundtrip).Restore (round-trip) a date and time value created by a formatting operation. Übergeben Sie die Standardformat Zeichenfolge "o" oder "r" an die ToString(String)-Methode, und nennen Sie die Überladung "Parse(String, IFormatProvider, DateTimeStyles)" 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 Sie eine Datums-und Uhrzeit Zeichenfolge in einem bestimmten Format (und möglicherweise an Kultur Grenzen).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 über teilbare Zeichenfolge.The string to parse

Die Parse-Methode versucht, die Zeichen folgen Darstellung eines Datums-und Uhrzeitwerts in die entsprechende DateTime-Entsprechung zu konvertieren.The Parse method tries to convert the string representation of a date and time value to its DateTime equivalent. Es wird versucht, die Eingabe Zeichenfolge vollständig zu analysieren, ohne eine FormatException-Ausnahme auszulösen.It tries to parse the input string completely without throwing a FormatException exception.

Wichtig

Wenn der Fehler bei der Ausführung aufgrund eines nicht erkannten Zeichen folgen Formats fehlschlägt, löst die Parse-Methode eine FormatException aus, während die TryParse-Methode false zurückgibt.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 Parse verwenden, wenn erwartet wird, dass der Verarbeitungsvorgang erfolgreich ist, da die Eingabe Quelle vertrauenswürdig ist.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 Analysefehler wahrscheinlich auftreten, insbesondere weil eine Eingabe Quelle nicht vertrauenswürdig ist, oder wenn Sie über angemessene Standardwerte verfügen, um Zeichen folgen zu ersetzen, die nicht erfolgreich analysiert werden.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 erteilende Zeichenfolge kann eine der folgenden Formen aufweisen:The string to be parsed can take any of the following forms:

  • Eine Zeichenfolge mit einem Datum und einer Zeitkomponente.A string with a date and a time component.

  • Eine Zeichenfolge mit einem Datum, aber keiner Zeitkomponente.A string with a date but no time component. Wenn die Zeitkomponente fehlt, geht die Methode von 12:00 Mitternacht aus.If the time component is absent, the method assumes 12:00 midnight. Wenn die Datums Komponente eine zweistellige Jahres Angabe aufweist, wird Sie basierend auf dem Calendar.TwoDigitYearMax des aktuellen Kalenders der aktuellen Kultur oder dem aktuellen Kalender der angegebenen Kultur in ein Jahr konvertiert (wenn Sie eine Überladung mit einem provider-Argument verwenden, das nicht NULL ist).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 Datums Komponente, die nur den Monat und das Jahr, aber keine Tages Komponente enthält.A string with a date component that includes only the month and the year but no day component. Die-Methode nimmt den ersten Tag des Monats an.The method assumes the first day of the month.

  • Eine Zeichenfolge mit einer Datums Komponente, die nur den Monat und den Tag, aber keine Jahres Komponente enthält.A string with a date component that includes only the month and the day but no year component. Die-Methode setzt das aktuelle Jahr voraus.The method assumes the current year.

  • Eine Zeichenfolge mit einer Zeit, aber ohne Datums Komponente.A string with a time but no date component. Die Methode nimmt das aktuelle Datum an, es sei denn, Sie geben die Überladung Parse(String, IFormatProvider, DateTimeStyles) an und schließen DateTimeStyles.NoCurrentDateDefault in das Argument styles ein. in diesem Fall geht die Methode von einem Datum ab dem 1. Januar 0001 aus.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 Zeitkomponente, die nur die Stunde und einen am/pm-Kenn Zeichner ohne Datums Komponente umfasst.A string with a time component that includes only the hour and an AM/PM designator, with no date component. Die-Methode nimmt das aktuelle Datum und eine Uhrzeit ohne Minuten und ohne Sekunden an.The method assumes the current date and a time with no minutes and no seconds. Sie können dieses Verhalten ändern, indem Sie die Überladung Parse(String, IFormatProvider, DateTimeStyles) aufrufen und DateTimeStyles.NoCurrentDateDefault in das Argument styles einschließen. in diesem Fall geht die Methode von einem Datum ab dem 1. Januar 0001 aus.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 gibt die erste Zeichenfolge die koordinierte Weltzeit (UTC) an, und die zweite Zeichenfolge gibt die Zeit in einer Zeitzone an, die sieben Stunden vor UTC liegt: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-Kenn Zeichner enthält und dem RFC 1123-Zeitformat entspricht. Zum Beispiel:A string that includes the GMT designator and conforms to the RFC 1123 time format; for example:

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

  • Eine Zeichenfolge, die das Datum und die Uhrzeit zusammen mit Zeit Zonen Offset-Informationen 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 Zeichen folgen in jedem dieser Formate mithilfe der Formatierungs Konventionen der aktuellen Kultur analysiert, die in diesem Fall die Kultur "en-US" ist: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 Eingabe Zeichenfolge einen Schalttag in einem Schaltjahr im Kalender darstellt, der von der Analysemethode verwendet wird (siehe analysieren und Kultur Konventionen), analysiert die Parse-Methode die Zeichenfolge erfolgreich.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 Eingabe Zeichenfolge einen Schalttag in einem nicht-Schaltjahr darstellt, löst die Methode eine FormatException aus.If the input string represents a leap day in a non-leap year, the method throws a FormatException.

Da die Parse-Methode versucht, die Zeichen folgen Darstellung eines Datums und einer Uhrzeit mithilfe der Formatierungs Regeln der aktuellen oder einer angegebenen Kultur zu analysieren, kann der Versuch, eine Zeichenfolge über verschiedene Kulturen hinweg zu analysieren, fehlschlagen.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 Datums-und Uhrzeit Format über verschiedene Gebiets Schemas zu analysieren, verwenden Sie eine der über Ladungen der DateTime.ParseExact-Methode, und geben Sie einen Format Bezeichner an.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.

Und kulturelle KonventionenParsing and cultural conventions

Alle über Ladungen der Parse-Methode sind Kultur abhängig, es sei denn, die Zeichenfolge, die durch s in der folgenden Tabelle dargestellt wird, 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-erteilungsvorgang verwendet die Formatierungsinformationen in einem DateTimeFormatInfo-Objekt, das wie folgt abgeleitet wird: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 SieIf you call Und provider istAnd provider is Formatierungsinformationen werden von abgeleitetFormatting information is derived from
Parse(String) - Die aktuelle Thread Kultur (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-Objekt.The specified DateTimeFormatInfo object
Parse(String, IFormatProvider) oder Parse(String, IFormatProvider, DateTimeStyles)Parse(String, IFormatProvider) or Parse(String, IFormatProvider, DateTimeStyles) null Die aktuelle Thread Kultur (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 Formatierungsinformationen von einem DateTimeFormatInfo-Objekt abgeleitet werden, definiert die Eigenschaft DateTimeFormatInfo.Calendar den Kalender, der beim Verarbeitungsvorgang verwendet wird.When formatting information is derived from a DateTimeFormatInfo object, the DateTimeFormatInfo.Calendar property defines the calendar used in the parsing operation.

Wenn Sie eine Datums-und Uhrzeit Zeichenfolge mithilfe eines DateTimeFormatInfo-Objekts mit angepassten Einstellungen analysieren, die sich von denen einer Standard Kultur unterscheiden, verwenden Sie die Methode ParseExact anstelle der Parse-Methode, um die Wahrscheinlichkeit einer erfolgreichen 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 Uhrzeit Zeichenfolge kann kompliziert und schwer zu analysieren sein.A non-standard date and time string can be complicated and difficult to parse. Die Parse-Methode versucht, eine Zeichenfolge mit mehreren impliziten Analyse Mustern zu analysieren, die möglicherweise fehlschlagen.The Parse method tries to parse a string with several implicit parse patterns, all of which might fail. Im Gegensatz dazu erfordert die ParseExact-Methode, dass Sie explizit ein oder mehrere exakte Analyse Muster festlegen, die wahrscheinlich erfolgreich sind.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 dynamische Daten" im Thema "DateTimeFormatInfo".For more information, see the "DateTimeFormatInfo and Dynamic Data" section in the DateTimeFormatInfo topic.

Wichtig

Beachten Sie, dass die Formatierungs Konventionen für eine bestimmte Kultur dynamisch sind und geändert werden können.Note that the formatting conventions for a particular culture are dynamic and can be subject to change. Dies bedeutet, dass bei der Ausführung von Vorgängen, die von den Formatierungs Konventionen der Standard Kultur (Current) abhängig sind oder die ein IFormatProvider-Objekt angeben, das eine andere Kultur als die invariante Kultur darstellt, unerwartet ein Fehler auftreten kann, wenn eine der folgenden Bedingungen zutrifft: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 kulturspezifischen Daten wurden zwischen der Haupt-oder neben Version des .NET Framework oder als Ergebnis einer Aktualisierung der vorhandenen Version des .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 kulturspezifischen Daten spiegeln die Benutzereinstellungen wider, die von Computer zu Computer oder Sitzung zu Sitzung variieren können.The culture-specific data reflects user preferences, which can vary from machine to machine or session to session.
  • Die kulturspezifischen Daten repräsentieren eine Ersatz Kultur, die die Einstellungen einer Standard Kultur oder einer benutzerdefinierten Kultur überschreibt.The culture-specific data represents a replacement culture that overrides the settings of a standard culture or a custom culture.

Um die Schwierigkeiten beim Analysieren von Daten und Zeit Zeichenfolgen zu vermeiden, die Änderungen in kulturellen Daten zugeordnet sind, können Sie Datums-und Uhrzeit Zeichenfolgen mithilfe der invarianten Kultur analysieren, oder Sie können die ParseExact-oder TryParseExact-Methode und das genaue Format der Zeichenfolge angeben. zu analysieren.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 Datums-und Uhrzeitdaten serialisieren und deserialisieren, können Sie entweder die Formatierungs Konventionen der invarianten Kultur verwenden, oder Sie können den DateTime-Wert in einem binären Format serialisieren und deserialisieren.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 Kultur Daten" im Thema CultureInfo und im Abschnitt "persistente DateTime-Werte" im Thema "DateTime".For more information see the "Dynamic culture data" section in the CultureInfo topic and the "Persisting DateTime values" section in the DateTime topic.

Formatieren und Formatieren von ElementenParsing and style elements

Alle Parse-über Ladungen ignorieren führende, innere oder nachfolgende Leerzeichen in der Eingabe Zeichenfolge (die durch s in der folgenden Tabelle dargestellt wird).All Parse overloads ignore leading, inner, or trailing white-space characters in the input string (which is represented by s in the following table). Das Datum und die Uhrzeit können mit einem Paar von führenden und nachfolgenden Nummern Zeichen ("#", U + 0023) in Klammern gesetzt werden, und Sie können mit einem oder mehreren NULL-Zeichen (u + 0000) abgezogen werden.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).

Außerdem verfügt die Parse(String, IFormatProvider, DateTimeStyles)-Überladung über einen styles-Parameter, der aus einem oder mehreren Membern der DateTimeStyles-Enumeration besteht.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 Analyse Vorgang s in ein Datum und eine Uhrzeit konvertieren soll.This parameter defines how s should be interpreted and how the parse operation should convert s to a date and time. In der folgenden Tabelle werden die Auswirkungen der einzelnen DateTimeStyles-Member auf den Analyse Vorgang beschrieben.The following table describes the effect of each DateTimeStyles member on the parse operation.

DateTimeStyles-MemberDateTimeStyles member Auswirkung auf KonvertierungEffect on conversion
AdjustToUniversal Analysiert s und konvertiert Sie ggf. wie folgt in UTC:Parses s and, if necessary, converts it to UTC, as follows:

Wenn s einen Zeit Zonen Offset enthält, oder wenn s keine Zeitzoneninformationen enthält, aber styles das AssumeLocal-Flag enthält, analysiert die-Methode die Zeichenfolge, ruft ToUniversalTime auf, um den zurückgegebenen DateTime-Wert in UTC zu konvertieren, und legt die Kind-Eigenschaft auf DateTimeKind.Utc fest.- 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.
-Wenn s angibt, dass es sich um UTC handelt, oder wenn s keine Zeitzoneninformationen enthält, aber styles das AssumeUniversal-Flag enthält, analysiert die-Methode die Zeichenfolge, führt keine Zeit Zonen Konvertierung für den zurückgegebenen DateTime-Wert aus und legt den Kind -Eigenschaft auf 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 Auswirkung.- In all other cases, the flag has no effect.
AllowInnerWhite Dieser Wert wird ignoriert.This value is ignored. Innere Leerzeichen sind in den Datums-und Uhrzeit Elementen von s immer zulässig.Inner white space is always permitted in the date and time elements of s.
AllowLeadingWhite Dieser Wert wird ignoriert.This value is ignored. Führende Leerzeichen sind in den Datums-und Uhrzeit Elementen von s immer zulässig.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 sind in den Datums-und Uhrzeit Elementen von s immer zulässig.Trailing white space is always permitted in the date and time elements of s.
AllowWhiteSpaces Gibt an, dass s führende, innere und nachfolgende Leerzeichen enthalten kann.Specifies that s may contain leading, inner, and trailing white spaces. Dies ist das Standardverhalten.This is the default behavior. Sie kann nicht überschrieben werden, indem ein restriktiver DateTimeStyles-Enumerationswert wie None bereitgestellt wird.It cannot be overridden by supplying a more restrictive DateTimeStyles enumeration value such as None.
AssumeLocal Gibt an, dass bei s keine Zeitzoneninformationen vorhanden sind, die Ortszeit angenommen wird.Specifies that if s lacks any time zone information, local time is assumed. Wenn das AdjustToUniversal-Flag nicht vorhanden ist, wird die Kind-Eigenschaft des zurückgegebenen DateTime-Werts auf DateTimeKind.Local festgelegt.Unless the AdjustToUniversal flag is present, the Kind property of the returned DateTime value is set to DateTimeKind.Local.
AssumeUniversal Gibt an, dass die UTC-Zeit angenommen wird, wenn s keine Zeitzoneninformationen enthält.Specifies that if s lacks any time zone information, UTC is assumed. Wenn das AdjustToUniversal-Flag nicht vorhanden ist, konvertiert die-Methode den zurückgegebenen DateTime-Wert von UTC in Ortszeit und legt seine Kind-Eigenschaft auf DateTimeKind.Local fest.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 der Wert gültig ist, wird dieser Wert ignoriert.Although valid, this value is ignored.
RoundtripKind Bei Zeichen folgen, die Zeitzoneninformationen enthalten, versucht, die Konvertierung von Datums-und Uhrzeit Zeichenfolgen in einen DateTime-Wert zu verhindern, der eine Ortszeit darstellt, deren Kind-Eigenschaft auf DateTimeKind.Local festgelegt ist.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 eine solche Zeichenfolge erstellt, indem die DateTime.ToString(String)-Methode und der Standardformat Bezeichner "o", "r" und "u" verwendet wird.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-über Ladungen geben einen DateTime-Wert zurück, dessen Kind-Eigenschaft Zeitzoneninformationen enthält.The DateTime.Parse overloads return a DateTime value whose Kind property includes time zone information. Dies kann darauf hinweisen, dass die Uhrzeit:It can indicate that the time is:

Im Allgemeinen gibt die Parse-Methode ein DateTime-Objekt zurück, dessen Kind-Eigenschaft DateTimeKind.Unspecified ist.Generally, the Parse method returns a DateTime object whose Kind property is DateTimeKind.Unspecified. Die Parse-Methode kann jedoch auch eine Zeit Zonen Konvertierung durchführen und den Wert der Eigenschaft Kind unterschiedlich festlegen, abhängig von den Werten der Parameter s und styles: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 Zeit Zonen KonvertierungTime zone conversion Kind-EigenschaftKind property
s enthält Zeitzoneninformationen.s contains time zone information. Datum und Uhrzeit werden in die Uhrzeit in der lokalen Zeitzone konvertiert.The date and time is converted to the time in the local time zone. DateTimeKind.Local
s enthält Zeitzoneninformationen, und styles enthält das Flag AdjustToUniversal.s contains time zone information, and styles includes the AdjustToUniversal flag. Das Datum und die Uhrzeit werden in die koordinierte Weltzeit (UTC) konvertiert.The date and time is converted to Coordinated Universal Time (UTC). DateTimeKind.Utc
s enthält den Z-oder GMT-Zeit Zonen Kenn Zeichner, und styles enthält das RoundtripKind-Flag.s contains the Z or GMT time zone designator, and styles includes the RoundtripKind flag. Das Datum und die Uhrzeit werden als UTC interpretiert.The date and time are interpreted as UTC. DateTimeKind.Utc

Im folgenden Beispiel werden Datums Zeichenfolgen, die Zeitzoneninformationen enthalten, in die Uhrzeit in der lokalen Zeitzone 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 den Wert einer Kind-Eigenschaft der Datums-und Uhrzeit während eines Formatierungs-und Prozess Vorgangs auch beibehalten, indem Sie das DateTimeStyles.RoundtripKind-Flag verwenden.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 folgenden Beispiel wird veranschaulicht, wie sich das RoundtripKind-Flag auf den-Verarbeitungsvorgang bei DateTime-Werten auswirkt, die mit dem Format Bezeichner "o", "r" und "u" in Zeichen folgen konvertiert werden.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)

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

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 ist null.s is null.

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, gibt diese Methode einen DateTime-Wert zurück, dessen Kind-Eigenschaft DateTimeKind.Local ist, und konvertiert das Datum und die Uhrzeit in 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 er keine Zeit Zonen Konvertierung aus und gibt einen DateTime-Wert zurück, dessen Eigenschaft Kind DateTimeKind.Unspecified ist.Otherwise, it performs no time zone conversion and returns a DateTime value whose Kind property is DateTimeKind.Unspecified.

Diese Überladung versucht, s mithilfe der Formatierungs Konventionen der aktuellen Kultur zu analysieren.This overload attempts to parse s by using the formatting conventions of the current culture. Die aktuelle Kultur wird durch die CurrentCulture-Eigenschaft angegeben.The current culture is indicated by the CurrentCulture property. Um eine Zeichenfolge mithilfe der Formatierungs Konventionen einer bestimmten Kultur zu analysieren, nennen Sie die über Ladungen Parse(String, IFormatProvider) oder Parse(String, IFormatProvider, DateTimeStyles).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, s mithilfe DateTimeStyles.AllowWhiteSpaces-Stils zu analysieren.This overload attempts to parse s by using DateTimeStyles.AllowWhiteSpaces style.

BeispielExample

Im folgenden Beispiel wird die Zeichen folgen Darstellung mehrerer Datums-und Uhrzeitwerte mithilfe von analysiert:The following example parses the string representation of several date and time values by:

  • Mit dem Standardformat Anbieter, der die Formatierungs Konventionen der aktuellen Thread Kultur des Computers bereitstellt, der zum Entwickeln der Beispielausgabe verwendet wird.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 dieses Beispiels reflektiert die Formatierungs Konventionen der Kultur "en-US".The output from this example reflects the formatting conventions of the en-US culture.

  • Verwenden des standardmäßigen Stil Werts, der AllowWhiteSpaces ist.Using the default style value, which is AllowWhiteSpaces.

Es behandelt die Ausnahme "FormatException", die ausgelöst wird, wenn die Methode versucht, die Zeichen folgen Darstellung eines Datums und einer Uhrzeit mithilfe der Formatierungs Konventionen einer anderen Kultur zu analysieren.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. Außerdem wird gezeigt, wie ein Datums-und Uhrzeitwert, der nicht die Formatierungs Konventionen der aktuellen Thread Kultur verwendet, erfolgreich analysiert wird.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)

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

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

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 ist null.s is null.

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, gibt diese Methode einen DateTime-Wert zurück, dessen Kind-Eigenschaft DateTimeKind.Local ist, und konvertiert das Datum und die Uhrzeit in 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 er keine Zeit Zonen Konvertierung aus und gibt einen DateTime-Wert zurück, dessen Eigenschaft Kind DateTimeKind.Unspecified ist.Otherwise, it performs no time zone conversion and returns a DateTime value whose Kind property is DateTimeKind.Unspecified.

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

BeispielExample

Im folgenden Beispiel wird ein Array von Datums Zeichenfolgen mithilfe der Konventionen der Kulturen en-US, fr-FR und de-de 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 Zeichen folgen Darstellungen eines einzelnen Datums 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)

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

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

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)

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

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

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

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 ist null.s is null.

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 die Uhrzeit in s und legt die Kind-Eigenschaft des zurückgegebenen DateTime-Werts wie folgt fest:This method overload converts the date and time in s and sets the Kind property of the returned DateTime value as follows:

IfIf Zeit Zonen KonvertierungTime zone conversion Kind-EigenschaftKind property
s enthält keine Zeitzoneninformationen.s contains no time zone information. KeineNone. DateTimeKind.Unspecified
s enthält Zeitzoneninformationen.s contains time zone information. Bis zu dem Zeitpunkt in der lokalen ZeitzoneTo the time in the local time zone DateTimeKind.Local
s enthält Zeitzoneninformationen, und styles enthält das Flag DateTimeStyles.AdjustToUniversal.s contains time zone information, and styles includes the DateTimeStyles.AdjustToUniversal flag. In koordinierter Weltzeit (UTC)To Coordinated Universal Time (UTC) DateTimeKind.Utc
s enthält den Z-oder GMT-Zeit Zonen Kenn Zeichner, und styles enthält die DateTimeStyles.RoundtripKind.s contains the Z or GMT time zone designator, and styles includes the DateTimeStyles.RoundtripKind. KeineNone. DateTimeKind.Utc

BeispielExample

Im folgenden Beispiel wird die Parse(String, IFormatProvider, DateTimeStyles)-Methode veranschaulicht, und es wird der Wert der Eigenschaft Kind der resultierenden DateTime-Werte angezeigt.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: