Dieser Artikel wurde maschinell übersetzt. Wenn Sie die englische Version des Artikels anzeigen möchten, aktivieren Sie das Kontrollkästchen Englisch. Sie können den englischen Text auch in einem Popupfenster anzeigen, indem Sie den Mauszeiger über den Text bewegen.
Übersetzung
Englisch

TimeSpan.ParseExact-Methode: (String, String, IFormatProvider)

.NET Framework (current version)
 

Veröffentlicht: Oktober 2016

Konvertiert die Zeichenfolgendarstellung eines Zeitintervalls unter Verwendung des angegebenen Formats und der kulturspezifischen Formatierungsinformationen in die entsprechende TimeSpan. Das Format der Zeichenfolgendarstellung muss dem angegebenen Format genau entsprechen.

Namespace:   System
Assembly:  mscorlib (in mscorlib.dll)

public static TimeSpan ParseExact(
	string input,
	string format,
	IFormatProvider formatProvider
)

Parameter

input
Type: System.String

Eine Zeichenfolge, die das zu konvertierende Zeitintervall angibt.

format
Type: System.String

Eine standardmäßige oder benutzerdefinierte Formatierungszeichenfolge, die das erforderliche Format von input definiert.

formatProvider
Type: System.IFormatProvider

Ein Objekt, das kulturspezifische Formatierungsinformationen bereitstellt.

Rückgabewert

Type: System.TimeSpan

Ein Zeitintervall, das input entspricht, wie von format und formatProvider angegeben.

Exception Condition
ArgumentNullException

input ist null.

FormatException

input weist ein ungültiges Format auf.

OverflowException

input stellt eine Zahl dar, die kleiner als TimeSpan.MinValue oder größer als TimeSpan.MaxValue ist.

- oder -

Mindestens eine der Tages-, Stunden-, Minuten- oder Sekundenkomponenten in input liegt außerhalb des gültigen Bereichs.

Die ParseExact(String, String, IFormatProvider) Methode analysiert die Zeichenfolgendarstellung eines Zeitintervalls, der in dem vom definierten Format vorliegen muss die format -Parameter, mit dem Unterschied, führende und nachfolgende Leerzeichen ignoriert werden. Da input muss das Format der entsprechen format genau, Sie sollten immer Ausnahmebehandlung verwenden beim Konvertieren von Zeichenfolge als Eingabe durch den Benutzer in einem Zeitintervall. Wenn Sie nicht die Ausnahmebehandlung verwenden möchten, können Sie rufen die TryParseExact(String, String, IFormatProvider, TimeSpan) Methode stattdessen.

Die format Parameter ist eine Zeichenfolge, die entweder einen einzelnen Standardformatbezeichner oder eine oder mehrere benutzerdefinierte Formatbezeichner, der das erforderliche Format von definieren enthält input. Weitere Informationen zu gültigen-Formatzeichenfolgen finden Sie unter TimeSpan-Standardformatzeichenfolgen und Benutzerdefinierte TimeSpan-Formatzeichenfolgen.

System_CAPS_importantWichtig

Die ParseExact -Methode verwendet die Konventionen der Kultur angegeben werden, indem die formatProvider Parameter nur, wenn format ist ein Standard TimeSpan Formatzeichenfolge, deren Wert "g" oder "G ist". Verwenden die Formatierungskonventionen der invarianten Kultur, "c", "t" und "T"-Standardformatzeichenfolgen. Benutzerdefinierte Formatzeichenfolgen definieren das exakte Format der Eingabezeichenfolge und Literalzeichen verwenden, um die Komponenten eines Zeitintervalls zu trennen.

Der formatProvider -Parameter ist ein IFormatProvider Implementierung, die kulturspezifische Informationen zum Format der zurückgegebenen Zeichenfolge bereitstellt, wenn format ist eine Standardformatzeichenfolge. Die formatProvider Parameter kann einen der folgenden sein:

Wenn formatProvider ist null, die DateTimeFormatInfo -Objekt, das der aktuellen Kultur zugeordnet ist, wird verwendet.

Im folgenden Beispiel wird die ParseExact(String, String, IFormatProvider) Methode, um mehrere zeichenfolgendarstellungen mit verschiedenen Kulturen und Formatzeichenfolgen Zeitintervalle zu analysieren.

using System;
using System.Globalization;

public class Example
{
   public static void Main()
   {
      string intervalString, format;
      TimeSpan interval;
      CultureInfo culture;

      // Parse hour:minute value with "g" specifier current culture.
      intervalString = "17:14";
      format = "g";
      culture = CultureInfo.CurrentCulture;
      try {
         interval = TimeSpan.ParseExact(intervalString, format, culture);
         Console.WriteLine("'{0}' --> {1}", intervalString, interval);
      }
      catch (FormatException) {
         Console.WriteLine("'{0}': Bad Format for '{1}'", 
                           intervalString, format);
      }                     
      catch (OverflowException) {
         Console.WriteLine("'{0}': Overflow", intervalString);
      }      

      // Parse hour:minute:second value with "G" specifier.
      intervalString = "17:14:48";
      format = "G";
      culture = CultureInfo.InvariantCulture;
      try {
         interval = TimeSpan.ParseExact(intervalString, format, culture);
         Console.WriteLine("'{0}' --> {1}", intervalString, interval);
      }
      catch (FormatException) {
         Console.WriteLine("'{0}': Bad Format for '{1}'", intervalString, format);
      }   
      catch (OverflowException) {
         Console.WriteLine("'{0}': Overflow", intervalString);
      } 

      // Parse hours:minute.second value with "G" specifier 
      // and current (en-US) culture.     
      intervalString = "17:14:48.153";
      format = "G";
      culture = CultureInfo.CurrentCulture;
      try {
         interval = TimeSpan.ParseExact(intervalString, format, culture);
         Console.WriteLine("'{0}' --> {1}", intervalString, interval);
      }   
      catch (FormatException) {
         Console.WriteLine("'{0}': Bad Format for '{1}'", intervalString, format);
      }
      catch (OverflowException) {
         Console.WriteLine("'{0}': Overflow", intervalString);
      } 

      // Parse days:hours:minute.second value with "G" specifier 
      // and current (en-US) culture.     
      intervalString = "3:17:14:48.153";
      format = "G";
      culture = CultureInfo.CurrentCulture;
      try {
         interval = TimeSpan.ParseExact(intervalString, format, culture);
         Console.WriteLine("'{0}' --> {1}", intervalString, interval);
      }   
      catch (FormatException) {
         Console.WriteLine("'{0}': Bad Format for '{1}'", intervalString, format);
      }   
      catch (OverflowException) {
         Console.WriteLine("'{0}': Overflow", intervalString);
      } 

      // Parse days:hours:minute.second value with "G" specifier 
      // and fr-FR culture.     
      intervalString = "3:17:14:48.153";
      format = "G";
      culture = new CultureInfo("fr-FR");
      try {
         interval = TimeSpan.ParseExact(intervalString, format, culture);
         Console.WriteLine("'{0}' --> {1}", intervalString, interval);
      }
      catch (FormatException) {
         Console.WriteLine("'{0}': Bad Format for '{1}'", intervalString, format);
      }
      catch (OverflowException) {
         Console.WriteLine("'{0}': Overflow", intervalString);
      } 

      // Parse days:hours:minute.second value with "G" specifier 
      // and fr-FR culture.     
      intervalString = "3:17:14:48,153";
      format = "G";
      try {
         interval = TimeSpan.ParseExact(intervalString, format, culture);
         Console.WriteLine("'{0}' --> {1}", intervalString, interval);
      }   
      catch (FormatException) {
         Console.WriteLine("'{0}': Bad Format for '{1}'", intervalString, format);
      }
      catch (OverflowException) {
         Console.WriteLine("'{0}': Overflow", intervalString);
      } 

      // Parse a single number using the "c" standard format string. 
      intervalString = "12";
      format = "c";
      try {
         interval = TimeSpan.ParseExact(intervalString, format, null);
         Console.WriteLine("'{0}' --> {1}", intervalString, interval);
      }
      catch (FormatException) {
         Console.WriteLine("'{0}': Bad Format for '{1}'", intervalString, format);
      }
      catch (OverflowException) {
         Console.WriteLine("'{0}': Overflow", intervalString);
      } 

      // Parse a single number using the "%h" custom format string. 
      format = "%h";
      try {
         interval = TimeSpan.ParseExact(intervalString, format, null);
         Console.WriteLine("'{0}' --> {1}", intervalString, interval);
      }
      catch (FormatException) {
         Console.WriteLine("'{0}': Bad Format for '{1}'", intervalString, format);
      }
      catch (OverflowException) {
         Console.WriteLine("'{0}': Overflow", intervalString);
      } 

      // Parse a single number using the "%s" custom format string. 
      format = "%s";
      try {
         interval = TimeSpan.ParseExact(intervalString, format, null);
         Console.WriteLine("'{0}' --> {1}", intervalString, interval);
      }
      catch (FormatException) {
         Console.WriteLine("'{0}': Bad Format for '{1}'", intervalString, format);
      }
      catch (OverflowException) {
         Console.WriteLine("'{0}': Overflow", intervalString);
      }
   }
}
// The example displays the following output:
//       '17:14' --> 17:14:00
//       '17:14:48': Bad Format for 'G'
//       '17:14:48.153': Bad Format for 'G'
//       '3:17:14:48.153' --> 3.17:14:48.1530000
//       '3:17:14:48.153': Bad Format for 'G'
//       '3:17:14:48,153' --> 3.17:14:48.1530000
//       '12' --> 12.00:00:00
//       '12' --> 12:00:00
//       '12' --> 00:00:12

Universelle Windows-Plattform
Verfügbar seit 8
.NET Framework
Verfügbar seit 4.0
Portierbare Klassenbibliothek
Unterstützt in: portierbare .NET-Plattformen
Silverlight
Verfügbar seit 4.0
Windows Phone Silverlight
Verfügbar seit 7.1
Windows Phone
Verfügbar seit 8.1
Zurück zum Anfang
Anzeigen: