DateTime.ParseExact Methode

Referenz

Definition

Namespace:: System

Assembly:: System.Runtime.dll

Assembly:: mscorlib.dll

Assembly:: netstandard.dll

Wichtig

Einige Informationen beziehen sich auf Vorabversionen, die vor dem Release ggf. grundlegend überarbeitet werden. Microsoft übernimmt hinsichtlich der hier bereitgestellten Informationen keine Gewährleistungen, seien sie ausdrücklich oder konkludent.

Konvertiert die angegebene Zeichenfolgendarstellung einer Datums- und Uhrzeitangabe in die DateTime-Entsprechung. Das Format der Zeichenfolgendarstellung muss einem bestimmten Format genau entsprechen. Andernfalls wird eine Ausnahme ausgelöst.

Überlädt

ParseExact(String, String, IFormatProvider)	Konvertiert die angegebene Zeichenfolgenentsprechung einer Datums- und Uhrzeitangabe unter Verwendung des angegebenen Formats und der angegebenen kulturabhängigen Formatierungsinformationen in die entsprechende DateTime. Das Format der Zeichenfolgendarstellung muss dem angegebenen Format genau entsprechen.
ParseExact(ReadOnlySpan<Char>, ReadOnlySpan<Char>, IFormatProvider, DateTimeStyles)	Konvertiert die angegebene Spannendarstellung einer Datums- und Uhrzeitangabe unter Verwendung der Angaben über Format, kulturabhängige Formatierungsinformationen und Stil in das DateTime-Äquivalent. Das Format der Zeichenfolgendarstellung muss dem angegebenen Format genau entsprechen. Andernfalls wird eine Ausnahme ausgelöst.
ParseExact(ReadOnlySpan<Char>, String[], IFormatProvider, DateTimeStyles)	Konvertiert die angegebene Spannendarstellung einer Datums- und Uhrzeitangabe unter Verwendung der Arrayangaben über Format, kulturabhängige Formatierungsinformationen und Stil in das DateTime-Äquivalent. Das Format der Zeichenfolgendarstellung muss mindestens einem der angegebenen Formate genau entsprechen. Andernfalls wird eine Ausnahme ausgelöst.
ParseExact(String, String, IFormatProvider, DateTimeStyles)	Konvertiert die angegebene Zeichenfolgenentsprechung einer Datums- und Uhrzeitangabe unter Verwendung der Angaben über Format, kulturabhängige Formatierungsinformationen und Stil in die entsprechende DateTime. Das Format der Zeichenfolgendarstellung muss dem angegebenen Format genau entsprechen. Andernfalls wird eine Ausnahme ausgelöst.
ParseExact(String, String[], IFormatProvider, DateTimeStyles)	Konvertiert die angegebene Zeichenfolgenentsprechung einer Datums- und Uhrzeitangabe unter Verwendung des angegebenen Formatarrays, der kulturspezifischen Formatierungsinformationen und des Stils in die DateTime-Entsprechung. Das Format der Zeichenfolgendarstellung muss mindestens einem der angegebenen Formate genau entsprechen. Andernfalls wird eine Ausnahme ausgelöst.

Hinweise

Wichtig

Die Zeitrechnung in japanischen Kalendern basiert auf den Regierungsperioden der Kaiser und wird sich daher erwartungsgemäß ändern. Beispiel: Der 1. Mai 2019 markiert den Beginn des Reiwa-Zeitabschnitts in den Kalendern des Typs JapaneseCalendar und JapaneseLunisolarCalendar. Eine derartige Änderung der Zeitabschnitte betrifft alle Anwendungen, die diese Kalender verwenden. Weitere Informationen und informationen zum Ermitteln, ob Ihre Anwendungen betroffen sind, finden Sie unter Behandeln einer neuen Ära im japanischen Kalender in .NET. Informationen zum Testen Ihrer Anwendungen auf Windows-Systemen, um ihre Bereitschaft für den Zeitwechsel sicherzustellen, finden Sie unter Vorbereiten ihrer Anwendung auf die Änderung der japanischen Ära. Features in .NET, die Kalender mit mehreren Epochen unterstützen, und bewährte Methoden für die Arbeit mit Kalendern, die mehrere Epochen unterstützen, finden Sie unter Arbeiten mit Epochen.

ParseExact(String, String, IFormatProvider)

Quelle:: DateTime.cs

Quelle:: DateTime.cs

Quelle:: DateTime.cs

Konvertiert die angegebene Zeichenfolgenentsprechung einer Datums- und Uhrzeitangabe unter Verwendung des angegebenen Formats und der angegebenen kulturabhängigen Formatierungsinformationen in die entsprechende DateTime. Das Format der Zeichenfolgendarstellung muss dem angegebenen Format genau entsprechen.

public:
 static DateTime ParseExact(System::String ^ s, System::String ^ format, IFormatProvider ^ provider);

public static DateTime ParseExact (string s, string format, IFormatProvider provider);

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

static member ParseExact : string * string * IFormatProvider -> DateTime

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

Parameter

s: String

Eine Zeichenfolge, die eine zu konvertierende Datums- und Zeitangabe enthält.

format: String

Ein Formatbezeichner, der das erforderliche Format von s definiert. Weitere Informationen finden Sie im Abschnitt "Hinweise".

provider: IFormatProvider

Ein Objekt, das kulturspezifische Formatierungsinformationen zu s bereitstellt.

Gibt zurück

DateTime

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

Ausnahmen

ArgumentNullException

s oder format ist null.

FormatException

s oder format ist eine leere Zeichenfolge.

- oder -

s enthält keine Datum/Uhrzeit-Angabe, die dem im format angegebenen Muster entspricht.

- oder -

Die Komponente für Stunden und der AM/PM-Kennzeichner in s stimmen nicht überein.

Beispiele

Das folgende Beispiel veranschaulicht die ParseExact Methode.

using System;
using System.Globalization;

public class Example
{
   public static void Main()
   {
      string dateString, format;
      DateTime result;
      CultureInfo provider = CultureInfo.InvariantCulture;

      // Parse date-only value with invariant culture.
      dateString = "06/15/2008";
      format = "d";
      try {
         result = DateTime.ParseExact(dateString, format, provider);
         Console.WriteLine("{0} converts to {1}.", dateString, result.ToString());
      }
      catch (FormatException) {
         Console.WriteLine("{0} is not in the correct format.", dateString);
      }

      // Parse date-only value without leading zero in month using "d" format.
      // Should throw a FormatException because standard short date pattern of
      // invariant culture requires two-digit month.
      dateString = "6/15/2008";
      try {
         result = DateTime.ParseExact(dateString, format, provider);
         Console.WriteLine("{0} converts to {1}.", dateString, result.ToString());
      }
      catch (FormatException) {
         Console.WriteLine("{0} is not in the correct format.", dateString);
      }

      // Parse date and time with custom specifier.
      dateString = "Sun 15 Jun 2008 8:30 AM -06:00";
      format = "ddd dd MMM yyyy h:mm tt zzz";
      try {
         result = DateTime.ParseExact(dateString, format, provider);
         Console.WriteLine("{0} converts to {1}.", dateString, result.ToString());
      }
      catch (FormatException) {
         Console.WriteLine("{0} is not in the correct format.", dateString);
      }

      // Parse date and time with offset but without offset's minutes.
      // Should throw a FormatException because "zzz" specifier requires leading
      // zero in hours.
      dateString = "Sun 15 Jun 2008 8:30 AM -06";
      try {
         result = DateTime.ParseExact(dateString, format, provider);
         Console.WriteLine("{0} converts to {1}.", dateString, result.ToString());
      }
      catch (FormatException) {
         Console.WriteLine("{0} is not in the correct format.", dateString);
      }

      dateString = "15/06/2008 08:30";
      format = "g";
      provider = new CultureInfo("fr-FR");
      try {
         result = DateTime.ParseExact(dateString, format, provider);
         Console.WriteLine("{0} converts to {1}.", dateString, result.ToString());
      }
      catch (FormatException) {
         Console.WriteLine("{0} is not in the correct format.", dateString);
      }

      // Parse a date that includes seconds and milliseconds
      // by using the French (France) and invariant cultures.
      dateString = "18/08/2015 06:30:15.006542";
      format = "dd/MM/yyyy HH:mm:ss.ffffff";
      try {
         result = DateTime.ParseExact(dateString, format, provider);
         Console.WriteLine("{0} converts to {1}.", dateString, result.ToString());
      }
      catch (FormatException) {
         Console.WriteLine("{0} is not in the correct format.", dateString);
      }
   }
}
// The example displays the following output:
//       06/15/2008 converts to 6/15/2008 12:00:00 AM.
//       6/15/2008 is not in the correct format.
//       Sun 15 Jun 2008 8:30 AM -06:00 converts to 6/15/2008 7:30:00 AM.
//       Sun 15 Jun 2008 8:30 AM -06 is not in the correct format.
//       15/06/2008 08:30 converts to 6/15/2008 8:30:00 AM.
//       18/08/2015 06:30:15.006542 converts to 8/18/2015 6:30:15 AM.

open System
open System.Globalization

[<EntryPoint>]
let main _ =
    let provider = CultureInfo.InvariantCulture

    // Parse date-only value with invariant culture.
    let dateString = "06/15/2008"
    let format = "d"
    try
        let result = DateTime.ParseExact(dateString, format, provider)
        printfn $"{dateString} converts to {result}."
    with :? FormatException ->
        printfn $"{dateString} is not in the correct format."

    // Parse date-only value without leading zero in month using "d" format.
    // Should throw a FormatException because standard short date pattern of
    // invariant culture requires two-digit month.
    let dateString = "6/15/2008"
    try
        let result = DateTime.ParseExact(dateString, format, provider)
        printfn $"{dateString} converts to {result}."
    with :? FormatException ->
        printfn $"{dateString} is not in the correct format."

    // Parse date and time with custom specifier.
    let dateString = "Sun 15 Jun 2008 8:30 AM -06:00"
    let format = "ddd dd MMM yyyy h:mm tt zzz"
    try
        let result = DateTime.ParseExact(dateString, format, provider)
        printfn $"{dateString} converts to {result}."
    with :? FormatException ->
        printfn $"{dateString} is not in the correct format."

    // Parse date and time with offset but without offset's minutes.
    // Should throw a FormatException because "zzz" specifier requires leading
    // zero in hours.
    let dateString = "Sun 15 Jun 2008 8:30 AM -06"
    try
        let result = DateTime.ParseExact(dateString, format, provider)
        printfn $"{dateString} converts to {result}."
    with :? FormatException ->
        printfn $"{dateString} is not in the correct format."

    let dateString = "15/06/2008 08:30"
    let format = "g"
    let provider = CultureInfo "fr-FR"
    try
        let result = DateTime.ParseExact(dateString, format, provider)
        printfn $"{dateString} converts to {result}."
    with :? FormatException ->
        printfn $"{dateString} is not in the correct format."

    // Parse a date that includes seconds and milliseconds
    // by using the French (France) and invariant cultures.
    let dateString = "18/08/2015 06:30:15.006542"
    let format = "dd/MM/yyyy HH:mm:ss.ffffff"
    try
        let result = DateTime.ParseExact(dateString, format, provider)
        printfn $"{dateString} converts to {result}."
    with :? FormatException ->
        printfn $"{dateString} is not in the correct format."

    0

// The example displays the following output:
//       06/15/2008 converts to 6/15/2008 12:00:00 AM.
//       6/15/2008 is not in the correct format.
//       Sun 15 Jun 2008 8:30 AM -06:00 converts to 6/15/2008 7:30:00 AM.
//       Sun 15 Jun 2008 8:30 AM -06 is not in the correct format.
//       15/06/2008 08:30 converts to 6/15/2008 8:30:00 AM.
//       18/08/2015 06:30:15.006542 converts to 8/18/2015 6:30:15 AM.

Imports System.Globalization

Module Example
   Public Sub Main()
      Dim dateString, format As String  
      Dim result As Date
      Dim provider As CultureInfo = CultureInfo.InvariantCulture

      ' Parse date-only value with invariant culture.
      dateString = "06/15/2008"
      format = "d"
      Try
         result = Date.ParseExact(dateString, format, provider)
         Console.WriteLine("{0} converts to {1}.", dateString, result.ToString())
      Catch e As FormatException
         Console.WriteLine("{0} is not in the correct format.", dateString)
      End Try 

      ' Parse date-only value without leading zero in month using "d" format.
      ' Should throw a FormatException because standard short date pattern of 
      ' invariant culture requires two-digit month.
      dateString = "6/15/2008"
      Try
         result = Date.ParseExact(dateString, format, provider)
         Console.WriteLine("{0} converts to {1}.", dateString, result.ToString())
      Catch e As FormatException
         Console.WriteLine("{0} is not in the correct format.", dateString)
      End Try 
      
      ' Parse date and time with custom specifier.
      dateString = "Sun 15 Jun 2008 8:30 AM -06:00"
      format = "ddd dd MMM yyyy h:mm tt zzz"        
      Try
         result = Date.ParseExact(dateString, format, provider)
         Console.WriteLine("{0} converts to {1}.", dateString, result.ToString())
      Catch e As FormatException
         Console.WriteLine("{0} is not in the correct format.", dateString)
      End Try 
      
      ' Parse date and time with offset but without offset's minutes.
      ' Should throw a FormatException because "zzz" specifier requires leading  
      ' zero in hours.
      dateString = "Sun 15 Jun 2008 8:30 AM -06"
      Try
         result = Date.ParseExact(dateString, format, provider)
         Console.WriteLine("{0} converts to {1}.", dateString, result.ToString())
      Catch e As FormatException
         Console.WriteLine("{0} is not in the correct format.", dateString)
      End Try 
      
      ' Parse a date string using the French (France) culture.
      dateString = "15/06/2008 08:30"
      format = "g"
      provider = New CultureInfo("fr-FR")
      Try
         result = Date.ParseExact(dateString, format, provider)
         Console.WriteLine("{0} converts to {1}.", dateString, result.ToString())
      Catch e As FormatException
         Console.WriteLine("{0} is not in the correct format.", dateString)
      End Try

      ' Parse a date that includes seconds and milliseconds
      ' by using the French (France) and invariant cultures.
      dateString = "18/08/2015 06:30:15.006542"
      format = "dd/MM/yyyy HH:mm:ss.ffffff"
      Try
         result = Date.ParseExact(dateString, format, provider)
         Console.WriteLine("{0} converts to {1}.", dateString, result.ToString())
      Catch e As FormatException
         Console.WriteLine("{0} is not in the correct format.", dateString)
      End Try
   End Sub
End Module
' The example displays the following output:
'       06/15/2008 converts to 6/15/2008 12:00:00 AM.
'       6/15/2008 is not in the correct format.
'       Sun 15 Jun 2008 8:30 AM -06:00 converts to 6/15/2008 7:30:00 AM.
'       Sun 15 Jun 2008 8:30 AM -06 is not in the correct format.
'       15/06/2008 08:30 converts to 6/15/2008 8:30:00 AM.
'       18/08/2015 06:30:15.006542 converts to 8/18/2015 6:30:15 AM.

Hinweise

Die DateTime.ParseExact(String, String, IFormatProvider) -Methode analysiert die Zeichenfolgendarstellung eines Datums, das im durch den format Parameter definierten Format vorliegen muss. Außerdem ist es erforderlich, dass die <Elemente Date> und <Time> der Zeichenfolgendarstellung eines Datums und einer Uhrzeit in der durch formatangegebenen Reihenfolge angezeigt werden und keine s andere Leerzeichen als die von formatzulässige aufweisen. Wenn format ein Datum ohne time-Element definiert und der Analysevorgang erfolgreich ist, weist der resultierende DateTime Wert eine Uhrzeit von Mitternacht (00:00:00) auf. Wenn format eine Uhrzeit ohne datumselement definiert und der Analysevorgang erfolgreich ist, weist der resultierende DateTime Wert das Datum auf DateTime.Now.Date.

Wenn s keine Zeit in einer bestimmten Zeitzone darstellt und der Analysevorgang erfolgreich ist, ist DateTimeKind.Unspecifieddie Kind -Eigenschaft des zurückgegebenen DateTime Werts . Wenn s die Uhrzeit in einer bestimmten Zeitzone darstellt und format Zeitzoneninformationen vorhanden sind (z. B. wenn format gleich den Standardformatbezeichnern "o", "r" oder "u" ist oder wenn er die benutzerdefinierten Formatbezeichner "z", "zz" oder "zzz" enthält), ist DateTimeKind.Localdie Kind -Eigenschaft des zurückgegebenen DateTime Werts .

Der format Parameter ist eine Zeichenfolge, die entweder einen einzelnen Standardformatbezeichner oder einen oder mehrere benutzerdefinierte Formatbezeichner enthält, die das erforderliche Format von sdefinieren. Ausführliche Informationen zu gültigen Formatierungscodes finden Sie unter Standardformatzeichenfolgen für Datum und Uhrzeit oder benutzerdefinierte Formatzeichenfolgen für Datum und Uhrzeit.

Hinweis

Wenn format ein benutzerdefiniertes Formatmuster ist, das keine Datums- oder Uhrzeittrennzeichen enthält (z. B. "yyyyMMddHHmm"), verwenden Sie die invariante Kultur für den provider Parameter und die breiteste Form jedes benutzerdefinierten Formatbezeichners. Wenn Sie z. B. Stunden im Formatmuster angeben möchten, geben Sie das breitere Formular "HH" anstelle der schmaleren Form "H" an.

Die bestimmten Datums- und Uhrzeitsymbole und Zeichenfolgen (z. B. Namen der Wochentage in einer bestimmten Sprache), die in s verwendet werden, werden durch den provider Parameter definiert, ebenso wie das genaue Format von s if format ist eine Standardformatbezeichnerzeichenfolge. Der provider Parameter kann einer der folgenden Sein:

Ein CultureInfo -Objekt, das die Kultur darstellt, die zum Interpretieren svon verwendet wird. Das DateTimeFormatInfo von seiner DateTimeFormat -Eigenschaft zurückgegebene Objekt definiert die Symbole und Formatierungen in s.
Ein DateTimeFormatInfo -Objekt, das das Format von Datums- und Uhrzeitdaten definiert.
Eine benutzerdefinierte IFormatProvider Implementierung, deren GetFormat Methode entweder das CultureInfo -Objekt oder das -Objekt zurückgibt, das DateTimeFormatInfo Formatierungsinformationen bereitstellt.

Wenn provider ist null, wird das CultureInfo Objekt verwendet, das der aktuellen Kultur entspricht.

Hinweise für Aufrufer

Im .NET Framework 4 löst die ParseExact Methode ein ausFormatException, wenn die zu analysierende Zeichenfolge eine Stundenkomponente und einen AM/PM-Bezeichner enthält, die nicht übereinstimmen. In der .NET Framework 3.5 und früheren Versionen wird der AM/PM-Bezeichner ignoriert.

Weitere Informationen

Gilt für:

ParseExact(ReadOnlySpan<Char>, ReadOnlySpan<Char>, IFormatProvider, DateTimeStyles)

Quelle:: DateTime.cs

Quelle:: DateTime.cs

Quelle:: DateTime.cs

Konvertiert die angegebene Spannendarstellung einer Datums- und Uhrzeitangabe unter Verwendung der Angaben über Format, kulturabhängige Formatierungsinformationen und Stil in das DateTime-Äquivalent. Das Format der Zeichenfolgendarstellung muss dem angegebenen Format genau entsprechen. Andernfalls wird eine Ausnahme ausgelöst.

public static DateTime ParseExact (ReadOnlySpan<char> s, ReadOnlySpan<char> format, IFormatProvider? provider, System.Globalization.DateTimeStyles style = System.Globalization.DateTimeStyles.None);

public static DateTime ParseExact (ReadOnlySpan<char> s, ReadOnlySpan<char> format, IFormatProvider provider, System.Globalization.DateTimeStyles style = System.Globalization.DateTimeStyles.None);

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

Public Shared Function ParseExact (s As ReadOnlySpan(Of Char), format As ReadOnlySpan(Of Char), provider As IFormatProvider, Optional style As DateTimeStyles = System.Globalization.DateTimeStyles.None) As DateTime

Parameter

s: ReadOnlySpan<Char>

Eine Zeichenspanne, die zu konvertierende Datums- und Uhrzeitwerte darstellt.

format: ReadOnlySpan<Char>

Eine Zeichenspanne, die einen Formatspezifizierer darstellt, der das erforderliche Format s definiert.

provider: IFormatProvider

Ein Objekt, das kulturspezifische Formatierungsinformationen zu s bereitstellt.

style: DateTimeStyles

Eine bitweise Kombination der Enumerationswerte, die zusätzliche Informationen über s, über in s möglicherweise vorhandene Stilelementen oder über die Konvertierung von s in einen DateTime-Wert bereitstellt. Ein häufig angegebener Wert ist None.

Gibt zurück

DateTime

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

Gilt für:

ParseExact(ReadOnlySpan<Char>, String[], IFormatProvider, DateTimeStyles)

Quelle:: DateTime.cs

Quelle:: DateTime.cs

Quelle:: DateTime.cs

Konvertiert die angegebene Spannendarstellung einer Datums- und Uhrzeitangabe unter Verwendung der Arrayangaben über Format, kulturabhängige Formatierungsinformationen und Stil in das DateTime-Äquivalent. Das Format der Zeichenfolgendarstellung muss mindestens einem der angegebenen Formate genau entsprechen. Andernfalls wird eine Ausnahme ausgelöst.

public static DateTime ParseExact (ReadOnlySpan<char> s, string[] formats, IFormatProvider? provider, System.Globalization.DateTimeStyles style = System.Globalization.DateTimeStyles.None);

public static DateTime ParseExact (ReadOnlySpan<char> s, string[] formats, IFormatProvider provider, System.Globalization.DateTimeStyles style = System.Globalization.DateTimeStyles.None);

static member ParseExact : ReadOnlySpan<char> * string[] * IFormatProvider * System.Globalization.DateTimeStyles -> DateTime

Public Shared Function ParseExact (s As ReadOnlySpan(Of Char), formats As String(), provider As IFormatProvider, Optional style As DateTimeStyles = System.Globalization.DateTimeStyles.None) As DateTime

Parameter

s: ReadOnlySpan<Char>

Eine Zeichenspanne, die zu konvertierende Datums- und Uhrzeitwerte darstellt.

formats: String[]

Ein Array mit den zulässigen Formaten von s.

provider: IFormatProvider

Ein Objekt, das kulturspezifische Formatierungsinformationen zu s bereitstellt.

style: DateTimeStyles

Eine bitweise Kombination von Enumerationswerten, die das zulässige Format von s angibt. Ein häufig angegebener Wert ist None.

Gibt zurück

DateTime

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

Gilt für:

ParseExact(String, String, IFormatProvider, DateTimeStyles)

Quelle:: DateTime.cs

Quelle:: DateTime.cs

Quelle:: DateTime.cs

Konvertiert die angegebene Zeichenfolgenentsprechung einer Datums- und Uhrzeitangabe unter Verwendung der Angaben über Format, kulturabhängige Formatierungsinformationen und Stil in die entsprechende DateTime. Das Format der Zeichenfolgendarstellung muss dem angegebenen Format genau entsprechen. Andernfalls wird eine Ausnahme ausgelöst.

public:
 static DateTime ParseExact(System::String ^ s, System::String ^ format, IFormatProvider ^ provider, System::Globalization::DateTimeStyles style);

public static DateTime ParseExact (string s, string format, IFormatProvider provider, System.Globalization.DateTimeStyles style);

public static DateTime ParseExact (string s, string format, IFormatProvider? provider, System.Globalization.DateTimeStyles style);

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

Public Shared Function ParseExact (s As String, format As String, provider As IFormatProvider, style As DateTimeStyles) As DateTime

Parameter

s: String

Eine Zeichenfolge, die eine zu konvertierende Datums- und Zeitangabe enthält.

format: String

Ein Formatbezeichner, der das erforderliche Format von s definiert. Weitere Informationen finden Sie im Abschnitt "Hinweise".

provider: IFormatProvider

Ein Objekt, das kulturspezifische Formatierungsinformationen zu s bereitstellt.

style: DateTimeStyles

Gibt zurück

DateTime

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

Ausnahmen

ArgumentNullException

s oder format ist null.

FormatException

s oder format ist eine leere Zeichenfolge.

- oder -

s enthält keine Datum/Uhrzeit-Angabe, die dem im format angegebenen Muster entspricht.

- oder -

Die Komponente für Stunden und der AM/PM-Kennzeichner in s stimmen nicht überein.

ArgumentException

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

Beispiele

Das folgende Beispiel veranschaulicht die ParseExact(String, String, IFormatProvider) Methode. Beachten Sie, dass die Zeichenfolge " 01.05.2009 8:30 Uhr" nicht erfolgreich analysiert werden kann, wenn der styles Parameter gleich ist DateTimeStyles.None , weil führende Leerzeichen von formatnicht zulässig sind. Darüber hinaus kann die Zeichenfolge "01.05.2009 09:00" nicht erfolgreich mit dem format Wert "MM/tt/jjjjhh:mm" analysiert werden, da die Datumszeichenfolge der Monatszahl nicht wie format erforderlich eine führende Null vorangestellt hat.

using System;
using System.Globalization;

public class Example
{
   public static void Main()
   {
      CultureInfo enUS = new CultureInfo("en-US");
      string dateString;
      DateTime dateValue;

      // Parse date with no style flags.
      dateString = " 5/01/2009 8:30 AM";
      try {
         dateValue = DateTime.ParseExact(dateString, "g", enUS, DateTimeStyles.None);
         Console.WriteLine("Converted '{0}' to {1} ({2}).", dateString, dateValue,
                           dateValue.Kind);
      }
      catch (FormatException) {
         Console.WriteLine("'{0}' is not in an acceptable format.", dateString);
      }
      // Allow a leading space in the date string.
      try {
         dateValue = DateTime.ParseExact(dateString, "g", enUS, DateTimeStyles.AllowLeadingWhite);
         Console.WriteLine("Converted '{0}' to {1} ({2}).", dateString, dateValue,
                           dateValue.Kind);
      }
      catch (FormatException) {
         Console.WriteLine("'{0}' is not in an acceptable format.", dateString);
      }

      // Use custom formats with M and MM.
      dateString = "5/01/2009 09:00";
      try {
         dateValue = DateTime.ParseExact(dateString, "M/dd/yyyy hh:mm", enUS, DateTimeStyles.None);
         Console.WriteLine("Converted '{0}' to {1} ({2}).", dateString, dateValue,
                           dateValue.Kind);
      }
      catch (FormatException) {
         Console.WriteLine("'{0}' is not in an acceptable format.", dateString);
      }
      // Allow a leading space in the date string.
      try {
         dateValue = DateTime.ParseExact(dateString, "MM/dd/yyyy hh:mm", enUS, DateTimeStyles.None);
         Console.WriteLine("Converted '{0}' to {1} ({2}).", dateString, dateValue,
                           dateValue.Kind);
      }
      catch (FormatException) {
         Console.WriteLine("'{0}' is not in an acceptable format.", dateString);
      }

      // Parse a string with time zone information.
      dateString = "05/01/2009 01:30:42 PM -05:00";
      try {
         dateValue = DateTime.ParseExact(dateString, "MM/dd/yyyy hh:mm:ss tt zzz", enUS, DateTimeStyles.None);
         Console.WriteLine("Converted '{0}' to {1} ({2}).", dateString, dateValue,
                           dateValue.Kind);
      }
      catch (FormatException) {
         Console.WriteLine("'{0}' is not in an acceptable format.", dateString);
      }
      // Allow a leading space in the date string.
      try {
         dateValue = DateTime.ParseExact(dateString, "MM/dd/yyyy hh:mm:ss tt zzz", enUS,
                                     DateTimeStyles.AdjustToUniversal);
         Console.WriteLine("Converted '{0}' to {1} ({2}).", dateString, dateValue,
                           dateValue.Kind);
      }
      catch (FormatException) {
         Console.WriteLine("'{0}' is not in an acceptable format.", dateString);
      }

      // Parse a string representing UTC.
      dateString = "2008-06-11T16:11:20.0904778Z";
      try {
         dateValue = DateTime.ParseExact(dateString, "o", CultureInfo.InvariantCulture,
                                     DateTimeStyles.None);
         Console.WriteLine("Converted '{0}' to {1} ({2}).", dateString, dateValue,
                           dateValue.Kind);
      }
      catch (FormatException) {
         Console.WriteLine("'{0}' is not in an acceptable format.", dateString);
      }
      try {
         dateValue = DateTime.ParseExact(dateString, "o", CultureInfo.InvariantCulture,
                                     DateTimeStyles.RoundtripKind);
         Console.WriteLine("Converted '{0}' to {1} ({2}).", dateString, dateValue,
                           dateValue.Kind);
      }
      catch (FormatException) {
         Console.WriteLine("'{0}' is not in an acceptable format.", dateString);
      }
   }
}
// The example displays the following output:
//    ' 5/01/2009 8:30 AM' is not in an acceptable format.
//    Converted ' 5/01/2009 8:30 AM' to 5/1/2009 8:30:00 AM (Unspecified).
//    Converted '5/01/2009 09:00' to 5/1/2009 9:00:00 AM (Unspecified).
//    '5/01/2009 09:00' is not in an acceptable format.
//    Converted '05/01/2009 01:30:42 PM -05:00' to 5/1/2009 11:30:42 AM (Local).
//    Converted '05/01/2009 01:30:42 PM -05:00' to 5/1/2009 6:30:42 PM (Utc).
//    Converted '2008-06-11T16:11:20.0904778Z' to 6/11/2008 9:11:20 AM (Local).
//    Converted '2008-06-11T16:11:20.0904778Z' to 6/11/2008 4:11:20 PM (Utc).

open System
open System.Globalization

[<EntryPoint>]
let main _ =
    let enUS = CultureInfo "en-US"

    // Parse date with no style flags.
    let dateString = " 5/01/2009 8:30 AM"
    try
        let dateValue = DateTime.ParseExact(dateString, "g", enUS, DateTimeStyles.None)
        printfn $"Converted '{dateString}' to {dateValue} ({dateValue.Kind})."
    with :? FormatException ->
        printfn $"'{dateString}' is not in an acceptable format."
    
    // Allow a leading space in the date string.
    try
        let dateValue = DateTime.ParseExact(dateString, "g", enUS, DateTimeStyles.AllowLeadingWhite)
        printfn $"Converted '{dateString}' to {dateValue} ({dateValue.Kind})."
    with :? FormatException ->
        printfn $"'{dateString}' is not in an acceptable format."

    // Use custom formats with M and MM.
    let dateString = "5/01/2009 09:00"
    try
        let dateValue = DateTime.ParseExact(dateString, "M/dd/yyyy hh:mm", enUS, DateTimeStyles.None)
        printfn $"Converted '{dateString}' to {dateValue} ({dateValue.Kind})."
    with :? FormatException ->
        printfn $"'{dateString}' is not in an acceptable format."

    // Allow a leading space in the date string.
    try
        let dateValue = DateTime.ParseExact(dateString, "MM/dd/yyyy hh:mm", enUS, DateTimeStyles.None)
        printfn $"Converted '{dateString}' to {dateValue} ({dateValue.Kind})."
    with :? FormatException ->
        printfn $"'{dateString}' is not in an acceptable format."

    // Parse a string with time zone information.
    let dateString = "05/01/2009 01:30:42 PM -05:00"
    try
        let dateValue = DateTime.ParseExact(dateString, "MM/dd/yyyy hh:mm:ss tt zzz", enUS, DateTimeStyles.None)
        printfn $"Converted '{dateString}' to {dateValue} ({dateValue.Kind})."
    with :? FormatException ->
        printfn $"'{dateString}' is not in an acceptable format."

    // Allow a leading space in the date string.
    try
        let dateValue = DateTime.ParseExact(dateString, "MM/dd/yyyy hh:mm:ss tt zzz", enUS, DateTimeStyles.AdjustToUniversal)
        printfn $"Converted '{dateString}' to {dateValue} ({dateValue.Kind})."
    with :? FormatException ->
        printfn $"'{dateString}' is not in an acceptable format."

    // Parse a string representing UTC.
    let dateString = "2008-06-11T16:11:20.0904778Z"
    try
        let dateValue = DateTime.ParseExact(dateString, "o", CultureInfo.InvariantCulture, DateTimeStyles.None)
        printfn $"Converted '{dateString}' to {dateValue} ({dateValue.Kind})."
    with :? FormatException ->
        printfn $"'{dateString}' is not in an acceptable format."

    try
        let dateValue = DateTime.ParseExact(dateString, "o", CultureInfo.InvariantCulture, DateTimeStyles.RoundtripKind)
        printfn $"Converted '{dateString}' to {dateValue} ({dateValue.Kind})."
    with :? FormatException ->
        printfn $"'{dateString}' is not in an acceptable format."


// The example displays the following output:
//    ' 5/01/2009 8:30 AM' is not in an acceptable format.
//    Converted ' 5/01/2009 8:30 AM' to 5/1/2009 8:30:00 AM (Unspecified).
//    Converted '5/01/2009 09:00' to 5/1/2009 9:00:00 AM (Unspecified).
//    '5/01/2009 09:00' is not in an acceptable format.
//    Converted '05/01/2009 01:30:42 PM -05:00' to 5/1/2009 11:30:42 AM (Local).
//    Converted '05/01/2009 01:30:42 PM -05:00' to 5/1/2009 6:30:42 PM (Utc).
//    Converted '2008-06-11T16:11:20.0904778Z' to 6/11/2008 9:11:20 AM (Local).
//    Converted '2008-06-11T16:11:20.0904778Z' to 6/11/2008 4:11:20 PM (Utc).

Imports System.Globalization

Module Example
   Public Sub Main()
      Dim enUS As New CultureInfo("en-US") 
      Dim dateString As String
      Dim dateValue As Date
      
      ' Parse date with no style flags.
      dateString = " 5/01/2009 8:30 AM"
      Try
         dateValue = Date.ParseExact(dateString, "g", enUS, DateTimeStyles.None)
         Console.WriteLine("Converted '{0}' to {1} ({2}).", dateString, dateValue, _
                           dateValue.Kind)
      Catch e As FormatException
         Console.WriteLine("'{0}' is not in an acceptable format.", dateString)
      End Try
      ' Allow a leading space in the date string.
      Try
         dateValue = Date.ParseExact(dateString, "g", enUS, DateTimeStyles.AllowLeadingWhite)
         Console.WriteLine("Converted '{0}' to {1} ({2}).", dateString, dateValue, _
                           dateValue.Kind)
      Catch e As FormatException
         Console.WriteLine("'{0}' is not in an acceptable format.", dateString)
      End Try
      
      ' Use custom formats with M and MM.
      dateString = "5/01/2009 09:00"
      Try
         dateValue = Date.ParseExact(dateString, "M/dd/yyyy hh:mm", enUS, DateTimeStyles.None)
         Console.WriteLine("Converted '{0}' to {1} ({2}).", dateString, dateValue, _
                           dateValue.Kind)
      Catch e As FormatException
         Console.WriteLine("'{0}' is not in an acceptable format.", dateString)
      End Try
      ' Allow a leading space in the date string.
      Try
         dateValue = Date.ParseExact(dateString, "MM/dd/yyyy hh:mm", enUS, DateTimeStyles.None)
         Console.WriteLine("Converted '{0}' to {1} ({2}).", dateString, dateValue, _
                           dateValue.Kind)
      Catch e As FormatException
         Console.WriteLine("'{0}' is not in an acceptable format.", dateString)
      End Try

      ' Parse a string with time zone information.
      dateString = "05/01/2009 01:30:42 PM -05:00" 
      Try
         dateValue = Date.ParseExact(dateString, "MM/dd/yyyy hh:mm:ss tt zzz", enUS, DateTimeStyles.None)
         Console.WriteLine("Converted '{0}' to {1} ({2}).", dateString, dateValue, _
                           dateValue.Kind)
      Catch e As FormatException
         Console.WriteLine("'{0}' is not in an acceptable format.", dateString)
      End Try
      ' Allow a leading space in the date string.
      Try
         dateValue = Date.ParseExact(dateString, "MM/dd/yyyy hh:mm:ss tt zzz", enUS, _
                                     DateTimeStyles.AdjustToUniversal)
         Console.WriteLine("Converted '{0}' to {1} ({2}).", dateString, dateValue, _
                           dateValue.Kind)
      Catch e As FormatException
         Console.WriteLine("'{0}' is not in an acceptable format.", dateString)
      End Try
           
      ' Parse a string representing UTC.
      dateString = "2008-06-11T16:11:20.0904778Z"
      Try
         dateValue = Date.ParseExact(dateString, "o", CultureInfo.InvariantCulture, _
                                     DateTimeStyles.None)
         Console.WriteLine("Converted '{0}' to {1} ({2}).", dateString, dateValue, _
                           dateValue.Kind)
      Catch e As FormatException
         Console.WriteLine("'{0}' is not in an acceptable format.", dateString)
      End Try
      Try
         dateValue = Date.ParseExact(dateString, "o", CultureInfo.InvariantCulture, _
                                     DateTimeStyles.RoundtripKind)
         Console.WriteLine("Converted '{0}' to {1} ({2}).", dateString, dateValue, _
                           dateValue.Kind)
      Catch e As FormatException
         Console.WriteLine("'{0}' is not in an acceptable format.", dateString)
      End Try
   End Sub
End Module
' The example displays the following output:
'    ' 5/01/2009 8:30 AM' is not in an acceptable format.
'    Converted ' 5/01/2009 8:30 AM' to 5/1/2009 8:30:00 AM (Unspecified).
'    Converted '5/01/2009 09:00' to 5/1/2009 9:00:00 AM (Unspecified).
'    '5/01/2009 09:00' is not in an acceptable format.
'    Converted '05/01/2009 01:30:42 PM -05:00' to 5/1/2009 11:30:42 AM (Local).
'    Converted '05/01/2009 01:30:42 PM -05:00' to 5/1/2009 6:30:42 PM (Utc).
'    Converted '2008-06-11T16:11:20.0904778Z' to 6/11/2008 9:11:20 AM (Local).
'    Converted '2008-06-11T16:11:20.0904778Z' to 6/11/2008 4:11:20 PM (Utc).

Hinweise

Die DateTime.ParseExact(String, String, IFormatProvider, DateTimeStyles) -Methode analysiert die Zeichenfolgendarstellung eines Datums, das in einem durch den format -Parameter definierten Format vorliegen muss. Außerdem müssen die Datums- und Uhrzeitelemente in s in der durch angegebenen Reihenfolge angezeigt werden format. Wenn s nicht mit dem Muster des format Parameters übereinstimmt, löst die -Methode mit allen durch den style -Parameter definierten Variationen eine aus FormatException. Im Gegensatz dazu analysiert die DateTime.Parse(String, IFormatProvider, DateTimeStyles) -Methode die Zeichenfolgendarstellung eines Datums in einem der vom Objekt des Formatanbieters DateTimeFormatInfo erkannten Formate. Die DateTime.Parse(String, IFormatProvider, DateTimeStyles) -Methode ermöglicht es auch, dass die Datums- und Uhrzeitelemente in s beliebiger Reihenfolge angezeigt werden.

Wenn der s Parameter nur eine Uhrzeit und kein Datum enthält, wird das aktuelle Datum verwendet, es sei denn, der style Parameter enthält das DateTimeStyles.NoCurrentDateDefault Flag. In diesem Fall wird das Standarddatum (DateTime.Date.MinValue) verwendet. Wenn der s Parameter nur ein Datum und keine Uhrzeit enthält, wird Mitternacht (00:00:00:00) verwendet. Der style Parameter bestimmt auch, ob der s Parameter führende, innere oder nachfolgende Leerzeichen enthalten kann.

Wenn s keine Zeitzoneninformationen enthalten sind, ist DateTimeKind.Unspecifieddie Kind Eigenschaft des zurückgegebenen DateTime Objekts . Dieses Verhalten kann mithilfe des DateTimeStyles.AssumeLocal Flags geändert werden, das einen DateTime Wert zurückgibt, dessen Kind Eigenschaft ist DateTimeKind.Local, oder mithilfe der DateTimeStyles.AssumeUniversal Flags und DateTimeStyles.AdjustToUniversal , die einen DateTime Wert zurückgibt, dessen Kind Eigenschaft ist DateTimeKind.Utc. Wenn s Zeitzoneninformationen enthalten, wird die Zeit bei Bedarf in die Ortszeit konvertiert, und die Kind Eigenschaft des zurückgegebenen DateTime Objekts ist auf DateTimeKind.Localfestgelegt. Dieses Verhalten kann mithilfe des Flags geändert werden, um koordinierte DateTimeStyles.RoundtripKind Weltzeit (UTC) nicht in eine lokale Zeit zu konvertieren und die Kind -Eigenschaft auf DateTimeKind.Utcfestzulegen.

Der format Parameter definiert das erforderliche Muster des s Parameters. Sie kann entweder aus einem oder mehreren benutzerdefinierten Formatbezeichnern aus der Tabelle Benutzerdefinierte Datums- und Uhrzeitformatzeichenfolgen oder einem einzelnen Standardformatbezeichner bestehen, der ein vordefiniertes Muster aus der Tabelle Standarddatums- und Uhrzeitformatzeichenfolgen identifiziert.

Wenn Sie keine Datums- oder Uhrzeittrennzeichen in einem benutzerdefinierten Formatmuster verwenden, verwenden Sie die invariante Kultur für den provider Parameter und die breiteste Form jedes benutzerdefinierten Formatbezeichners. Wenn Sie beispielsweise Stunden im Muster angeben möchten, geben Sie das breitere Formular "HH" anstelle des schmaleren Formulars "H" an.

Hinweis

Anstatt zu verlangen, dass diese s einem einzelnen Format entsprechen, damit der Analysevorgang erfolgreich ist, können Sie die DateTime.ParseExact(String, String[], IFormatProvider, DateTimeStyles) -Methode aufrufen und mehrere zulässige Formate angeben. Dies macht den Analysevorgang wahrscheinlicher, dass er erfolgreich ist.

Der styles Parameter enthält ein oder mehrere Member der Enumeration, die DateTimeStyles bestimmen, ob und wo Leerraum, von nicht definiert, format in s angezeigt werden kann, und die das genaue Verhalten des Analysevorgangs steuern. In der folgenden Tabelle wird beschrieben, wie sich jedes Element der DateTimeStyles Enumeration auf den Vorgang der ParseExact(String, String, IFormatProvider, DateTimeStyles) -Methode auswirkt.

DateTimeStyles-Member	Beschreibung
AdjustToUniversal	`s` Analysiert und konvertiert sie bei Bedarf in UTC. Wenn `s` ein Zeitzonenoffset enthalten ist oder keine `s` Zeitzoneninformationen, aber `styles` das DateTimeStyles.AssumeLocal Flag enthält, analysiert die -Methode die Zeichenfolge, ruft ToUniversalTime auf, um den zurückgegebenen DateTime Wert in UTC zu konvertieren, und legt die Kind -Eigenschaft auf DateTimeKind.Utcfest. Wenn `s` angegeben ist, dass sie UTC darstellt oder keine `s` Zeitzoneninformationen enthält, sondern `styles` das DateTimeStyles.AssumeUniversal Flag enthält, analysiert die -Methode die Zeichenfolge, führt keine Zeitzonenkonvertierung für den zurückgegebenen DateTime Wert aus und legt die Kind -Eigenschaft auf fest DateTimeKind.Utc. In allen anderen Fällen hat das Flag keine Auswirkung.
AllowInnerWhite	Gibt an, dass leerer Leerraum, der nicht durch definiert ist `format` , zwischen jedem einzelnen Datums- oder Uhrzeitelement angezeigt werden kann.
AllowLeadingWhite	Gibt an, dass leerer Leerraum, der nicht durch `format` definiert wird, am Anfang von `s`angezeigt werden kann.
AllowTrailingWhite	Gibt an, dass leerer Leerraum, der nicht definiert ist, `format` am Ende von `s`angezeigt werden kann.
AllowWhiteSpaces	Gibt an, dass `s` führende, innere und nachfolgende Leerzeichen enthalten können, die nicht durch definiert werden `format`.
AssumeLocal	Gibt an, dass bei fehlenden Zeitzoneninformationen davon ausgegangen wird, dass `s` sie eine Ortszeit darstellt. Sofern das DateTimeStyles.AdjustToUniversal Flag nicht vorhanden ist, wird die Kind Eigenschaft des zurückgegebenen DateTime Werts auf DateTimeKind.Localfestgelegt.
AssumeUniversal	Gibt an, dass bei fehlenden Zeitzoneninformationen davon ausgegangen wird, dass `s` sie UTC darstellt. Sofern das DateTimeStyles.AdjustToUniversal Flag nicht vorhanden ist, konvertiert die Methode den zurückgegebenen DateTime Wert von UTC in die Ortszeit und legt ihre Kind Eigenschaft auf fest DateTimeKind.Local.
NoCurrentDateDefault	Wenn `s` Zeit ohne Datumsinformationen enthält, wird das Datum des Rückgabewerts auf `DateTime.MinValue.Date`festgelegt.
None	Der `s` Parameter wird mithilfe von Standardwerten analysiert. Es ist kein anderer Leerraum als der in `format` zulässige Leerraum zulässig. Wenn `s` keine Datumskomponente vorhanden ist, wird das Datum des zurückgegebenen DateTime Werts auf den 1.1.0001 festgelegt. Wenn `s` keine Zeitzoneninformationen enthalten sind, wird die Kind Eigenschaft des zurückgegebenen DateTime Objekts auf DateTimeKind.Unspecifiedfestgelegt. Wenn Zeitzoneninformationen in vorhanden sind, wird die Zeit in `s`die Ortszeit konvertiert, und die Kind Eigenschaft des zurückgegebenen DateTime Objekts ist auf DateTimeKind.Localfestgelegt.
RoundtripKind	Bei Zeichenfolgen, die Zeitzoneninformationen enthalten, versucht, die Konvertierung in ein Wertdatum und eine DateTime -Uhrzeit zu verhindern, wobei die Kind -Eigenschaft auf festgelegt ist DateTimeKind.Local. Dieses Flag verhindert in erster Linie die Konvertierung von UTC-Zeiten in Lokale Zeiten.

Die jeweiligen Datums- und Uhrzeitsymbole und Zeichenfolgen (z. B. die Namen der Wochentage in einer bestimmten Sprache), die in s verwendet werden, werden durch den provider Parameter definiert, ebenso wie das genaue Format von s if format eine Standardformatbezeichnerzeichenfolge ist. Der provider Parameter kann einer der folgenden Sein:

Ein CultureInfo -Objekt, das die Kultur darstellt, die verwendet wird, um zu interpretieren s. Das DateTimeFormatInfo von seiner DateTimeFormat -Eigenschaft zurückgegebene Objekt definiert die Symbole und Formatierungen in s.
Ein DateTimeFormatInfo -Objekt, das das Format von Datums- und Uhrzeitdaten definiert.
Eine benutzerdefinierte IFormatProvider Implementierung, deren GetFormat Methode entweder das CultureInfo -Objekt oder das -Objekt zurückgibt, das DateTimeFormatInfo Formatierungsinformationen bereitstellt.

Wenn provider ist null, wird das CultureInfo Objekt verwendet, das der aktuellen Kultur entspricht.

Hinweise für Aufrufer

Weitere Informationen

Gilt für:

ParseExact(String, String[], IFormatProvider, DateTimeStyles)

Quelle:: DateTime.cs

Quelle:: DateTime.cs

Quelle:: DateTime.cs

Konvertiert die angegebene Zeichenfolgenentsprechung einer Datums- und Uhrzeitangabe unter Verwendung des angegebenen Formatarrays, der kulturspezifischen Formatierungsinformationen und des Stils in die DateTime-Entsprechung. Das Format der Zeichenfolgendarstellung muss mindestens einem der angegebenen Formate genau entsprechen. Andernfalls wird eine Ausnahme ausgelöst.

public:
 static DateTime ParseExact(System::String ^ s, cli::array <System::String ^> ^ formats, IFormatProvider ^ provider, System::Globalization::DateTimeStyles style);

public static DateTime ParseExact (string s, string[] formats, IFormatProvider provider, System.Globalization.DateTimeStyles style);

public static DateTime ParseExact (string s, string[] formats, IFormatProvider? provider, System.Globalization.DateTimeStyles style);

static member ParseExact : string * string[] * IFormatProvider * System.Globalization.DateTimeStyles -> DateTime

Public Shared Function ParseExact (s As String, formats As String(), provider As IFormatProvider, style As DateTimeStyles) As DateTime

Parameter

s: String

Eine Zeichenfolge, die eine zu konvertierende Datums- und Zeitangabe enthält.

formats: String[]

Ein Array mit den zulässigen Formaten von s. Weitere Informationen finden Sie im Abschnitt "Hinweise".

provider: IFormatProvider

Ein Objekt, das kulturspezifische Formatierungsinformationen zu s bereitstellt.

style: DateTimeStyles

Eine bitweise Kombination von Enumerationswerten, die das zulässige Format von s angibt. Ein häufig angegebener Wert ist None.

Gibt zurück

DateTime

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

Ausnahmen

ArgumentNullException

s oder formats ist null.

FormatException

s ist eine leere Zeichenfolge.

- oder -

Ein Element von formats ist eine leere Zeichenfolge.

- oder -

s enthält keine Datum/Uhrzeit-Angabe, die einem Element von formats entspricht.

- oder -

Die Komponente für Stunden und der AM/PM-Kennzeichner in s stimmen nicht überein.

ArgumentException

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

Beispiele

Im folgenden Beispiel wird die DateTime.ParseExact(String, String[], IFormatProvider, DateTimeStyles) -Methode verwendet, um sicherzustellen, dass eine Zeichenfolge in einer Reihe möglicher Formate erfolgreich analysiert werden kann.

using System;
using System.Globalization;

public class Example
{
   public static void Main()
   {
      string[] formats= {"M/d/yyyy h:mm:ss tt", "M/d/yyyy h:mm tt",
                         "MM/dd/yyyy hh:mm:ss", "M/d/yyyy h:mm:ss",
                         "M/d/yyyy hh:mm tt", "M/d/yyyy hh tt",
                         "M/d/yyyy h:mm", "M/d/yyyy h:mm",
                         "MM/dd/yyyy hh:mm", "M/dd/yyyy hh:mm",
                         "MM/d/yyyy HH:mm:ss.ffffff" };
      string[] dateStrings = {"5/1/2009 6:32 PM", "05/01/2009 6:32:05 PM",
                              "5/1/2009 6:32:00", "05/01/2009 06:32",
                              "05/01/2009 06:32:00 PM", "05/01/2009 06:32:00",
                              "08/28/2015 16:17:39.125", "08/28/2015 16:17:39.125000" };
      DateTime dateValue;

      foreach (string dateString in dateStrings)
      {
         try {
            dateValue = DateTime.ParseExact(dateString, formats,
                                            new CultureInfo("en-US"),
                                            DateTimeStyles.None);
            Console.WriteLine("Converted '{0}' to {1}.", dateString, dateValue);
         }
         catch (FormatException) {
            Console.WriteLine("Unable to convert '{0}' to a date.", dateString);
         }
      }
   }
}
// The example displays the following output:
//       Converted '5/1/2009 6:32 PM' to 5/1/2009 6:32:00 PM.
//       Converted '05/01/2009 6:32:05 PM' to 5/1/2009 6:32:05 PM.
//       Converted '5/1/2009 6:32:00' to 5/1/2009 6:32:00 AM.
//       Converted '05/01/2009 06:32' to 5/1/2009 6:32:00 AM.
//       Converted '05/01/2009 06:32:00 PM' to 5/1/2009 6:32:00 PM.
//       Converted '05/01/2009 06:32:00' to 5/1/2009 6:32:00 AM.
//       Unable to convert '08/28/2015 16:17:39.125' to a date.
//       Converted '08/28/2015 16:17:39.125000' to 8/28/2015 4:17:39 PM.

open System
open System.Globalization

let formats = 
    [| "M/d/yyyy h:mm:ss tt"; "M/d/yyyy h:mm tt"
       "MM/dd/yyyy hh:mm:ss"; "M/d/yyyy h:mm:ss"
       "M/d/yyyy hh:mm tt"; "M/d/yyyy hh tt"
       "M/d/yyyy h:mm"; "M/d/yyyy h:mm"
       "MM/dd/yyyy hh:mm"; "M/dd/yyyy hh:mm"
       "MM/d/yyyy HH:mm:ss.ffffff" |]

let dateStrings = 
    [ "5/1/2009 6:32 PM"; "05/01/2009 6:32:05 PM"
      "5/1/2009 6:32:00"; "05/01/2009 06:32"
      "05/01/2009 06:32:00 PM"; "05/01/2009 06:32:00"
      "08/28/2015 16:17:39.125"; "08/28/2015 16:17:39.125000" ]

for dateString in dateStrings do
    try
        let dateValue = DateTime.ParseExact(dateString, formats, CultureInfo "en-US", DateTimeStyles.None)
        printfn $"Converted '{dateString}' to {dateValue}."
    with :? FormatException ->
        printfn $"Unable to convert '{dateString}' to a date."

// The example displays the following output:
//       Converted '5/1/2009 6:32 PM' to 5/1/2009 6:32:00 PM.
//       Converted '05/01/2009 6:32:05 PM' to 5/1/2009 6:32:05 PM.
//       Converted '5/1/2009 6:32:00' to 5/1/2009 6:32:00 AM.
//       Converted '05/01/2009 06:32' to 5/1/2009 6:32:00 AM.
//       Converted '05/01/2009 06:32:00 PM' to 5/1/2009 6:32:00 PM.
//       Converted '05/01/2009 06:32:00' to 5/1/2009 6:32:00 AM.
//       Unable to convert '08/28/2015 16:17:39.125' to a date.
//       Converted '08/28/2015 16:17:39.125000' to 8/28/2015 4:17:39 PM.

Imports System.Globalization

Module Example
   Public Sub Main()
      Dim formats() As String = {"M/d/yyyy h:mm:ss tt", "M/d/yyyy h:mm tt", _
                                 "MM/dd/yyyy hh:mm:ss", "M/d/yyyy h:mm:ss", _
                                 "M/d/yyyy hh:mm tt", "M/d/yyyy hh tt", _
                                 "M/d/yyyy h:mm", "M/d/yyyy h:mm", _
                                 "MM/dd/yyyy hh:mm", "M/dd/yyyy hh:mm",
                                 "MM/d/yyyy HH:mm:ss.ffffff" }
      Dim dateStrings() As String = {"5/1/2009 6:32 PM", "05/01/2009 6:32:05 PM", _
                                     "5/1/2009 6:32:00", "05/01/2009 06:32", _
                                     "05/01/2009 06:32:00 PM", "05/01/2009 06:32:00",
                                     "08/28/2015 16:17:39.125", "08/28/2015 16:17:39.125000" }

      Dim dateValue As DateTime
      
      For Each dateString As String In dateStrings
         Try
            dateValue = DateTime.ParseExact(dateString, formats, _
                                            New CultureInfo("en-US"), _
                                            DateTimeStyles.None)
            Console.WriteLine("Converted '{0}' to {1}.", dateString, dateValue)
         Catch e As FormatException
            Console.WriteLine("Unable to convert '{0}' to a date.", dateString)
         End Try                                               
      Next
   End Sub
End Module
' The example displays the following output:
'       Converted '5/1/2009 6:32 PM' to 5/1/2009 6:32:00 PM.
'       Converted '05/01/2009 6:32:05 PM' to 5/1/2009 6:32:05 PM.
'       Converted '5/1/2009 6:32:00' to 5/1/2009 6:32:00 AM.
'       Converted '05/01/2009 06:32' to 5/1/2009 6:32:00 AM.
'       Converted '05/01/2009 06:32:00 PM' to 5/1/2009 6:32:00 PM.
'       Converted '05/01/2009 06:32:00' to 5/1/2009 6:32:00 AM.
'       Unable to convert '08/28/2015 16:17:39.125' to a date.
'       Converted '08/28/2015 16:17:39.125000' to 8/28/2015 4:17:39 PM.

Hinweise

Die DateTime.ParseExact(String, String[], IFormatProvider, DateTimeStyles) -Methode analysiert die Zeichenfolgendarstellung eines Datums, das mit einem der dem formats Parameter zugewiesenen Muster übereinstimmt. Wenn die Zeichenfolge s keines dieser Muster mit einer der durch den styles -Parameter definierten Variationen übereinstimmt, löst die -Methode einen aus FormatException. Abgesehen vom Vergleich s mit mehreren Formatierungsmustern und nicht mit einem einzelnen Formatierungsmuster verhält sich diese Überladung identisch mit der DateTime.ParseExact(String, String, IFormatProvider, DateTimeStyles) -Methode.

Der s Parameter enthält das Zu analysierende Datum und die Uhrzeit. Wenn der s Parameter nur eine Uhrzeit und kein Datum enthält, wird das aktuelle Datum verwendet, es sei denn, der style Parameter enthält das DateTimeStyles.NoCurrentDateDefault Flag. In diesem Fall wird das Standarddatum (DateTime.Date.MinValue) verwendet. Wenn der s Parameter nur ein Datum und keine Uhrzeit enthält, wird Mitternacht (00:00:00:00) verwendet. Der style Parameter bestimmt auch, ob der s Parameter führende, innere oder nachfolgende Leerzeichen enthalten kann, die nicht von einer der Formatzeichenfolgen in formatszulässig sind.

Der formats Parameter enthält ein Array von Mustern, von denen s eines genau übereinstimmen muss, wenn der Analysevorgang erfolgreich sein soll. Die Muster im formats Parameter bestehen aus einem oder mehreren benutzerdefinierten Formatbezeichnern aus der Tabelle Benutzerdefinierte Datums- und Uhrzeitformatzeichenfolgen oder einem einzelnen Standardformatbezeichner, der ein vordefiniertes Muster aus der Tabelle Standarddatums- und Uhrzeitformatzeichenfolgen identifiziert.

DateTimeStyles-Member	Beschreibung
AdjustToUniversal	`s` Analysiert und konvertiert sie bei Bedarf in UTC. Wenn `s` ein Zeitzonenoffset enthalten ist oder keine `s` Zeitzoneninformationen, aber `styles` das DateTimeStyles.AssumeLocal Flag enthält, analysiert die -Methode die Zeichenfolge, ruft ToUniversalTime auf, um den zurückgegebenen DateTime Wert in UTC zu konvertieren, und legt die Kind -Eigenschaft auf DateTimeKind.Utcfest. Wenn `s` angegeben ist, dass sie UTC darstellt oder keine `s` Zeitzoneninformationen enthält, sondern `styles` das DateTimeStyles.AssumeUniversal Flag enthält, analysiert die -Methode die Zeichenfolge, führt keine Zeitzonenkonvertierung für den zurückgegebenen DateTime Wert aus und legt die Kind -Eigenschaft auf fest DateTimeKind.Utc. In allen anderen Fällen hat das Flag keine Auswirkung.
AllowInnerWhite	Gibt an, dass leerer Leerraum, der nicht durch definiert ist `format` , zwischen jedem einzelnen Datums- oder Uhrzeitelement angezeigt werden kann.
AllowLeadingWhite	Gibt an, dass leerer Leerraum, der nicht durch `format` definiert wird, am Anfang von `s`angezeigt werden kann.
AllowTrailingWhite	Gibt an, dass leerer Leerraum, der nicht definiert ist, `format` am Ende von `s`angezeigt werden kann.
AllowWhiteSpaces	Gibt an, dass `s` führende, innere und nachfolgende Leerzeichen enthalten können, die nicht durch definiert werden `format`.
AssumeLocal	Gibt an, dass bei fehlenden Zeitzoneninformationen davon ausgegangen wird, dass `s` sie eine Ortszeit darstellt. Sofern das DateTimeStyles.AdjustToUniversal Flag nicht vorhanden ist, wird die Kind -Eigenschaft des zurückgegebenen Werts DateTime auf DateTimeKind.Localfestgelegt.
AssumeUniversal	Gibt an, dass, wenn `s` keine Zeitzoneninformationen vorhanden sind, davon ausgegangen wird, dass sie UTC darstellen. Sofern das DateTimeStyles.AdjustToUniversal Flag nicht vorhanden ist, konvertiert die Methode den zurückgegebenen DateTime Wert von UTC in Ortszeit und legt ihre Kind -Eigenschaft auf fest DateTimeKind.Local.
NoCurrentDateDefault	Wenn `s` Zeit ohne Datumsinformationen enthält, wird das Datum des Rückgabewerts auf `DateTime.MinValue.Date`festgelegt.
None	Der `s` Parameter wird mithilfe von Standardwerten analysiert. Außer dem in `format` vorhandenen Leerzeichen ist kein Leerzeichen zulässig. Wenn `s` keine Datumskomponente vorhanden ist, wird das Datum des zurückgegebenen DateTime Werts auf 1.1.0001 festgelegt. Wenn `s` keine Zeitzoneninformationen enthalten sind, wird die Kind -Eigenschaft des zurückgegebenen DateTime Objekts auf DateTimeKind.Unspecifiedfestgelegt. Wenn Zeitzoneninformationen in `s`vorhanden sind, wird die Zeit in die Ortszeit konvertiert, und die Kind -Eigenschaft des zurückgegebenen DateTime Objekts wird auf DateTimeKind.Localfestgelegt.
RoundtripKind	Bei Zeichenfolgen, die Zeitzoneninformationen enthalten, versucht, die Konvertierung in ein Datum und eine Uhrzeit zu verhindern, wobei die Kind -Eigenschaft auf DateTimeKind.Localfestgelegt ist. Dieses Flag verhindert in erster Linie die Konvertierung von UTC-Zeiten in Lokale Zeiten.

Die bestimmten Datums- und Uhrzeitsymbole und Zeichenfolgen (z. B. die Namen der Wochentage in einer bestimmten Sprache), die in s verwendet werden, werden durch den provider Parameter definiert, ebenso wie das genaue Format von s if format ist eine Standardformatbezeichnerzeichenfolge. Der provider Parameter kann einer der folgenden Sein:

Ein CultureInfo -Objekt, das die Kultur darstellt, die zum Interpretieren svon verwendet wird. Das DateTimeFormatInfo von seiner DateTimeFormat -Eigenschaft zurückgegebene Objekt definiert die Symbole und Formatierungen in s.
Ein DateTimeFormatInfo -Objekt, das das Format von Datums- und Uhrzeitdaten definiert.
Eine benutzerdefinierte IFormatProvider Implementierung, deren GetFormat Methode entweder das CultureInfo -Objekt oder das -Objekt zurückgibt, das DateTimeFormatInfo Formatierungsinformationen bereitstellt.

Wenn provider ist null, wird das CultureInfo Objekt verwendet, das der aktuellen Kultur entspricht.

Hinweise für Aufrufer

Im .NET Framework 4 löst die ParseExact Methode ein ausFormatException, wenn die zu analysierende Zeichenfolge eine Stundenkomponente und einen AM/PM-Entwurf enthält, die nicht übereinstimmen. In den .NET Framework 3.5 und früheren Versionen wird der AM/PM-Bezeichner ignoriert.

Weitere Informationen

Gilt für:

Teilen über

DateTime.ParseExact Methode

Definition

Überlädt

Hinweise

ParseExact(String, String, IFormatProvider)

Parameter

Gibt zurück

Ausnahmen

Beispiele

Hinweise

Hinweise für Aufrufer

Weitere Informationen

Gilt für:

ParseExact(ReadOnlySpan<Char>, ReadOnlySpan<Char>, IFormatProvider, DateTimeStyles)

Parameter

Gibt zurück

Gilt für:

ParseExact(ReadOnlySpan<Char>, String[], IFormatProvider, DateTimeStyles)

Parameter

Gibt zurück

Gilt für:

ParseExact(String, String, IFormatProvider, DateTimeStyles)

Parameter

Gibt zurück

Ausnahmen

Beispiele

Hinweise

Hinweise für Aufrufer

Weitere Informationen

Gilt für:

ParseExact(String, String[], IFormatProvider, DateTimeStyles)

Parameter

Gibt zurück

Ausnahmen

Beispiele

Hinweise

Hinweise für Aufrufer

Weitere Informationen

Gilt für:

Zusätzliche Ressourcen