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 DateTime.Parse die-Methode aufzurufen, werden im Abschnitt " Hinweise " in diesem Artikel und in der Dokumentation DateTime.Parse für die einzelnen über Ladungen zusammengesetzt.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 DateTime.Parse kompletten Satz von Beispielen, die in einem .net Core 2,0-Projekt für C# enthalten sind, und ein .net Core 2,0-Projekt für Visual Basicaus dem GitHub-Repository dotnet/Samplesherunterladen.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 ToString(String) " an die-Methode Parse(String, IFormatProvider, DateTimeStyles) , und aufrufen Sie die-Überladung mitDateTimeStyles.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.ParseExactoder 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 DateTime in die-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 FormatException analysieren, ohne eine-Ausnahme auszulösen.It tries to parse the input string completely without throwing a FormatException exception.

Wichtig

Wenn der-Vorgang aufgrund eines nicht erkannten Zeichen folgen Formats fehlschlägt, Parse löst die Methode FormatExceptioneine aus, TryParse während die false-Methode 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. TryParseist 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 aktuellen Kalender der aktuellen Kultur oder dem aktuellen Kalender der angegebenen Kultur in ein Jahr konvertiert (wenn Sie eine Überladung mit einem Argument verwenden, das nicht NULL provider 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 Parse(String, IFormatProvider, DateTimeStyles) sei denn, DateTimeStyles.NoCurrentDateDefault Sie geben styles die-Überladung an und enthalten in das-Argument. in diesem Fall geht die Methode von einem Datum vom 1. Januar 0001The 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 Parse(String, IFormatProvider, DateTimeStyles) die-über DateTimeStyles.NoCurrentDateDefault Ladung aufrufen styles und in das-Argument 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 FormatExceptiondie Methode eine 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. Verwenden Sie eine der über Ladungen DateTime.ParseExact der-Methode, und geben Sie einen Format Bezeichner an, um ein bestimmtes Datums-und Uhrzeit Format über verschiedene Gebiets Schemas zu analysieren.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 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 Formatierungs DateTimeFormatInfo Informationen in einem-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) Benutzer IFormatProvider definierte ImplementierungCustom IFormatProvider implementation Die IFormatProvider.GetFormat -MethodeThe IFormatProvider.GetFormat method

Wenn Formatierungsinformationen von einem DateTimeFormatInfo -Objekt abgeleitet werden, definiert die DateTimeFormatInfo.Calendar -Eigenschaft 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 ParseExact , verwenden Sie die Parse -Methode anstelle der-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 ParseExact die-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 DateTimeFormatInfo Thema.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 Verarbeitung von Vorgängen, die von den Formatierungs Konventionen der Standard Kultur abhängig sind oder IFormatProvider ein 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 ParseExact Sie TryParseExact können die-Methode oder die-Methode oder das genaue Format angeben. der Zeichenfolge, die analysiert werden soll.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 Uhrzeit Daten 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 CultureInfo Thema und im Abschnitt "persistente DateTime-Werte" DateTime im Thema.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 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 styles einen Parameter, der aus einem DateTimeStyles oder mehreren Membern der-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, s wie interpretiert werden soll und wie der Analyse Vorgang in ein s Datum und eine Uhrzeit konvertiert werden 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 DateTimeStyles einzelnen 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 s Analysiert und, falls erforderlich, in UTC, wie folgt: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, styles sondern das AssumeLocal -Flag enthält, analysiert die-Methode die Zeichen ToUniversalTime Folge, und ruft DateTime auf, um den zurückgegebenen Wert in zu konvertieren. UTC, und legt die Kind -Eigenschaft DateTimeKind.Utcauf 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 s , oder wenn keine Zeitzoneninformationen styles enthält, AssumeUniversal sondern das-Flag enthält, analysiert die Methode die Zeichenfolge, führt keine Zeit Zonen DateTime Konvertierung für die zurückgegebene aus. , und legt die Kind -Eigenschaft auf DateTimeKind.Utcfest.- 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 simmer 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 simmer 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 simmer zulässig.Trailing white space is always permitted in the date and time elements of s.
AllowWhiteSpaces Gibt an s , dass möglicherweise führende, innere und nachfolgende Leerzeichen enthält.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 Sie einen DateTimeStyles restriktiveren Enumerationswert Nonewie angeben.It cannot be overridden by supplying a more restrictive DateTimeStyles enumeration value such as None.
AssumeLocal Gibt an, s dass, wenn keine Zeitzoneninformationen fehlt, eine lokale Zeit angenommen wird.Specifies that if s lacks any time zone information, local time is assumed. Wenn das AdjustToUniversal -Flag nicht vorhanden ist Kind , wird die- DateTime Eigenschaft des zurückgegebenen DateTimeKind.LocalWerts auf festgelegt.Unless the AdjustToUniversal flag is present, the Kind property of the returned DateTime value is set to DateTimeKind.Local.
AssumeUniversal Gibt an, s dass, wenn keine Zeitzoneninformationen fehlt, die UTC angenommen wird.Specifies that if s lacks any time zone information, UTC is assumed. Wenn das AdjustToUniversal -Flag nicht vorhanden ist, konvertiert die- DateTime Methode den zurückgegebenen Wert von UTC in die Kind lokale Zeit DateTimeKind.Localund legt seine-Eigenschaft auf 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.Localfestgelegt 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 durch Aufrufen DateTime.ToString(String) der-Methode und mit dem Standardformat Bezeichner "o", "r" und "u" erstellt.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 DateTime einen Wert Kind zurück, dessen-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 Parse die-Methode DateTime ein- Kind Objekt zurück DateTimeKind.Unspecified, dessen-Eigenschaft 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 Kind der s -Eigenschaft in Abhängigkeit von den Werten des-para styles meters und des-Parameters unterschiedlich festlegen: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
senthä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
senthält Zeitzoneninformationen und schließt styles das AdjustToUniversal -Flag ein.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
senthält den Z-oder GMT-Zeit Zonen Kenn Zeichner und styles schließt das RoundtripKind -Flag ein.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 auch den Wert einer Datums-und Uhrzeit Eigenschaft während Kind eines Formatierungs-und Verarbeitungsvorgangs mit dem DateTimeStyles.RoundtripKind -Flag beibehalten.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, RoundtripKind wie sich das-Flag auf den DateTime Verarbeitungsvorgang bei 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) 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, gibt diese Methode einen DateTime Wert zurück Kind , dessen DateTimeKind.Local -Eigenschaft ist, und konvertiert das s Datum und die Uhrzeit in in die Ortszeit.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 wird keine Zeit Zonen Konvertierung durchführt, und es DateTime wird ein Kind Wert zurück DateTimeKind.Unspecifiedgegeben, dessen-Eigenschaft ist.Otherwise, it performs no time zone conversion and returns a DateTime value whose Kind property is DateTimeKind.Unspecified.

Diese Überladung versucht, mithilfe s 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, müssen Parse(String, IFormatProvider) Sie die Parse(String, IFormatProvider, DateTimeStyles) -Überladung oder die-Überladung aufzurufen.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, mithilfe s DateTimeStyles.AllowWhiteSpaces von Style 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.

  • Mit dem Standardstil Wert, der ist AllowWhiteSpaces.Using the default style value, which is AllowWhiteSpaces.

Sie behandelt die FormatException Ausnahme, 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) 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, gibt diese Methode einen DateTime Wert zurück Kind , dessen DateTimeKind.Local -Eigenschaft ist, und konvertiert das s Datum und die Uhrzeit in in die Ortszeit.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 wird keine Zeit Zonen Konvertierung durchführt, und es DateTime wird ein Kind Wert zurück DateTimeKind.Unspecifiedgegeben, dessen-Eigenschaft ist.Otherwise, it performs no time zone conversion and returns a DateTime value whose Kind property is DateTimeKind.Unspecified.

Diese Überladung versucht, mithilfe s des DateTimeStyles.AllowWhiteSpaces -Stils zu analysieren.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) 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 die s Uhrzeit in und Kind legt die-Eigenschaft DateTime des zurückgegebenen 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
senthält keine Zeitzoneninformationen.s contains no time zone information. KeineNone. DateTimeKind.Unspecified
senthält Zeitzoneninformationen.s contains time zone information. Bis zu dem Zeitpunkt in der lokalen ZeitzoneTo the time in the local time zone DateTimeKind.Local
senthält Zeitzoneninformationen, und ' Styles enthält das DateTimeStyles.AdjustToUniversal -Flag.s contains time zone information, and `styles includes the DateTimeStyles.AdjustToUniversal flag. In koordinierter Weltzeit (UTC)To Coordinated Universal Time (UTC) DateTimeKind.Utc
senthält den Z-oder GMT-Zeit Zonen Kenn Zeichner und styles schließt den DateTimeStyles.RoundtripKindein.s contains the Z or GMT time zone designator, and styles includes the DateTimeStyles.RoundtripKind. KeineNone. Utc

BeispielExample

Das folgende Beispiel veranschaulicht die Parse(String, IFormatProvider, DateTimeStyles) -Methode und zeigt den Wert Kind der-Eigenschaft der resultierenden DateTime Werte an.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: