ParseExact Metoda (String, String, IFormatProvider)
Ten artykuł został przetłumaczony przez maszynę. Aby wyświetlić jego treść w języku angielskim, zaznacz pole wyboru Angielski. Możesz też wyświetlić angielski tekst w okienku wyskakującym, przesuwając wskaźnik myszy nad konkretny tekst”.
Tłumaczenie
Angielski

Metoda TimeSpan.ParseExact — (String, String, IFormatProvider)

.NET Framework (current version)
 

Konwertuje reprezentację ciągu przedział czasu do jego TimeSpan równoważne przy użyciu określonego formatu i informacji o formacie określonej kultury.  Format ciągu reprezentującego musi dokładnie pasować do wskazanego formatu.  

Przestrzeń nazw:   System
Zestaw:  mscorlib (w mscorlib.dll)

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

Parametry

input

Ciąg określający przedział czasu, którą należy przekształcić.

format

Format standardowy lub niestandardowy ciąg, który definiuje formatem wymaganym input.

formatProvider

Obiekt, który dostarcza informacje o formatowaniu specyficzne dla kultury.

Wartość zwracana

Type: System.TimeSpan

Przedział czasu, który odpowiada input, zgodnie z określonym format i formatProvider.

Exception Condition
ArgumentNullException

input jest null.

FormatException

input ma nieprawidłowy format.

OverflowException

input reprezentuje liczbę, która jest mniejsza niż TimeSpan.MinValue większą lub równą TimeSpan.MaxValue.

—lub—

Co najmniej jeden z dni, godziny, minuty lub składników sekund w input znajduje się poza prawidłowym zakresem.

 ParseExact(String, String, IFormatProvider) Metody analizuje reprezentację ciągu interwał czasu musi mieć format zdefiniowane przez format parametru, z wyjątkiem tego znaku i końcowe białe znaki są ignorowane.  Ponieważ input musi być zgodna z format format dokładnie, należy zawsze używać obsługi wyjątków podczas konwertowania ciąg na wejściu przez użytkownika na przedział czasu.  Jeśli wolisz nie używać obsługi wyjątków, można wywołać metodę TryParseExact(String, String, IFormatProvider, TimeSpan) metody zamiast niego.  

 format Ciąg znaków zawierający pojedynczy standardowy specyfikator formatu lub co najmniej jeden specyfikatory niestandardowego formatu określające format wymagany jest parametr input.  Aby uzyskać więcej informacji o prawidłowym formacie ciągów, zobacz Standardowe ciągi formatujące TimeSpan i Stringhe di formato TimeSpan personalizzate.  

System_CAPS_importantWażne

 ParseExact Metoda korzysta z konwencjami kultury, określony przez formatProvider tylko wtedy, gdy parametr format jest standardem TimeSpan format ciągu, której wartość jest "g" lub "G".  Standardowe ciągi formatujące „c”, „t” i „T” wykorzystują konwencje formatowania niezmiennej kultury.  Niestandardowe ciągi formatujące definiują dokładny format ciągu wejściowego oraz za pomocą znaków literałowych oddzielają składniki przedziału czasu.  

 formatProvider Jest parametr IFormatProvider Implementacja udostępniająca określonej kultury informacji na temat formatu ciągu zwrócony, jeśli format jest ciągiem standardowym formacie.   formatProvider Parametr może mieć jedną z następujących przyczyn:  

Jeśli formatProvider jest null, DateTimeFormatInfo służy obiekt, który jest skojarzony z bieżącej kultury.

W poniższym przykładzie użyto ParseExact(String, String, IFormatProvider) metody do przeanalizowania kilka reprezentacji ciągu interwały czasu przy użyciu różnych ciągi formatów i kultury.

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

Universal Windows Platform
Dostêpne od 4.5
.NET Framework
Dostêpne od 4.0
Portable Class Library
Obsługiwane w: portable .NET platforms
Silverlight
Dostêpne od 4.0
Windows Phone Silverlight
Dostêpne od 7.1
Windows Phone
Dostêpne od 8.1
Powrót do początku
Pokaż:
© 2016 Microsoft