TimeSpan.ParseExact Metodo

Definizione

Converte la rappresentazione di stringa di un intervallo di tempo nell'equivalente TimeSpan.Converts the string representation of a time interval to its TimeSpan equivalent. Il formato della rappresentazione di stringa deve corrispondere esattamente a un formato specificato.The format of the string representation must match a specified format exactly.

Overload

ParseExact(String, String, IFormatProvider, TimeSpanStyles)

Converte la rappresentazione di stringa di un intervallo di tempo nell'equivalente TimeSpan usando gli stili e le informazioni sul formato specifiche delle impostazioni cultura indicate.Converts the string representation of a time interval to its TimeSpan equivalent by using the specified format, culture-specific format information, and styles. Il formato della rappresentazione di stringa deve corrispondere esattamente al formato specificato.The format of the string representation must match the specified format exactly.

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

Converte la rappresentazione di stringa di un intervallo di tempo nell'equivalente TimeSpan usando i formati, gli stili e le informazioni sul formato specifiche delle impostazioni cultura indicate.Converts the string representation of a time interval to its TimeSpan equivalent by using the specified formats, culture-specific format information, and styles. Il formato della rappresentazione di stringa deve corrispondere esattamente a uno dei formati specificati.The format of the string representation must match one of the specified formats exactly.

ParseExact(String, String[], IFormatProvider)

Converte la rappresentazione di stringa di un intervallo di tempo nell'equivalente TimeSpan usando la matrice di stringhe di formato e le informazioni sul formato specifiche delle impostazioni cultura indicate.Converts the string representation of a time interval to its TimeSpan equivalent by using the specified array of format strings and culture-specific format information. Il formato della rappresentazione di stringa deve corrispondere esattamente a uno dei formati specificati.The format of the string representation must match one of the specified formats exactly.

ParseExact(String, String, IFormatProvider)

Converte la rappresentazione di stringa di un intervallo di tempo nell'equivalente TimeSpan usando le informazioni sul formato specifiche delle impostazioni cultura indicate.Converts the string representation of a time interval to its TimeSpan equivalent by using the specified format and culture-specific format information. Il formato della rappresentazione di stringa deve corrispondere esattamente al formato specificato.The format of the string representation must match the specified format exactly.

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

ParseExact(String, String, IFormatProvider, TimeSpanStyles)

Converte la rappresentazione di stringa di un intervallo di tempo nell'equivalente TimeSpan usando gli stili e le informazioni sul formato specifiche delle impostazioni cultura indicate.Converts the string representation of a time interval to its TimeSpan equivalent by using the specified format, culture-specific format information, and styles. Il formato della rappresentazione di stringa deve corrispondere esattamente al formato specificato.The format of the string representation must match the specified format exactly.

public:
 static TimeSpan ParseExact(System::String ^ input, System::String ^ format, IFormatProvider ^ formatProvider, System::Globalization::TimeSpanStyles styles);
public static TimeSpan ParseExact (string input, string format, IFormatProvider formatProvider, System.Globalization.TimeSpanStyles styles);
static member ParseExact : string * string * IFormatProvider * System.Globalization.TimeSpanStyles -> TimeSpan
Public Shared Function ParseExact (input As String, format As String, formatProvider As IFormatProvider, styles As TimeSpanStyles) As TimeSpan

Parametri

input
String

Stringa che specifica l'intervallo di tempo da convertire.A string that specifies the time interval to convert.

format
String

Stringa di formato standard o personalizzato che definisce il formato richiesto di input.A standard or custom format string that defines the required format of input.

formatProvider
IFormatProvider

Oggetto che fornisce informazioni di formattazione specifiche delle impostazioni cultura.An object that provides culture-specific formatting information.

styles
TimeSpanStyles

Combinazione bit per bit di valori di enumerazione che definisce gli elementi di stile che possono essere presenti in input.A bitwise combination of enumeration values that defines the style elements that may be present in input.

Restituisce

Intervallo di tempo che corrisponde a input, come specificato da format, formatProvider e styles.A time interval that corresponds to input, as specified by format, formatProvider, and styles.

Eccezioni

styles è un valore TimeSpanStyles non valido.styles is an invalid TimeSpanStyles value.

input è null.input is null.

Il formato di input non è valido.input has an invalid format.

L'oggetto input rappresenta un numero minore di MinValue o maggiore di MaxValue.input represents a number that is less than MinValue or greater than MaxValue.

In alternativa-or- Almeno uno dei componenti giorni, ore, minuti o secondi in input non rientra nell'intervallo valido.At least one of the days, hours, minutes, or seconds components in input is outside its valid range.

Esempi

Nell'esempio seguente viene usato ParseExact(String, String, IFormatProvider) il metodo per analizzare più rappresentazioni di stringa di intervalli temporali usando varie stringhe di formato e impostazioni cultura.The following example uses the ParseExact(String, String, IFormatProvider) method to parse several string representations of time intervals using various format strings and cultures. USA anche il TimeSpanStyles.AssumeNegative valore per interpretare ogni stringa come un intervallo di tempo negativo.It also uses the TimeSpanStyles.AssumeNegative value to interpret each string as a negative time interval. Nell'output dell'esempio viene illustrato che lo TimeSpanStyles.AssumeNegative stile influisca sul valore restituito solo quando viene utilizzato con stringhe di formato personalizzate.The output from the example illustrates that the TimeSpanStyles.AssumeNegative style affects the return value only when it is used with custom format strings.

using System;
using System.Globalization;

public class Example
{
   public static void Main()
   {
      string intervalString, format;
      TimeSpan interval;
      CultureInfo culture = null;
      
      // Parse hour:minute value with custom format specifier.
      intervalString = "17:14";
      format = "h\\:mm";
      culture = CultureInfo.CurrentCulture;
      try {
         interval = TimeSpan.ParseExact(intervalString, format, 
                                        culture, TimeSpanStyles.AssumeNegative);
         Console.WriteLine("'{0}' ({1}) --> {2}", intervalString, format, 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, TimeSpanStyles.AssumeNegative);
         Console.WriteLine("'{0}' ({1}) --> {2}", intervalString, format, 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 custom format specifier.     
      intervalString = "17:14:48.153";
      format = @"h\:mm\:ss\.fff";
      culture = null;
      try {
         interval = TimeSpan.ParseExact(intervalString, format, 
                                        culture, TimeSpanStyles.AssumeNegative);
         Console.WriteLine("'{0}' ({1}) --> {2}", intervalString, format, 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, TimeSpanStyles.AssumeNegative);
         Console.WriteLine("'{0}' ({1}) --> {2}", intervalString, format, 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 a custom format specifier.     
      intervalString = "3:17:14:48.153";
      format = @"d\:hh\:mm\:ss\.fff";
      culture = null;
      try {
         interval = TimeSpan.ParseExact(intervalString, format, 
                                        culture, TimeSpanStyles.AssumeNegative);
         Console.WriteLine("'{0}' ({1}) --> {2}", intervalString, format, 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, TimeSpanStyles.AssumeNegative);
         Console.WriteLine("'{0}' ({1}) --> {2}", intervalString, format, 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, TimeSpanStyles.AssumeNegative);
         Console.WriteLine("'{0}' ({1}) --> {2}", intervalString, format, 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, TimeSpanStyles.AssumeNegative);
         Console.WriteLine("'{0}' ({1}) --> {2}", intervalString, format, 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, TimeSpanStyles.AssumeNegative);
         Console.WriteLine("'{0}' ({1}) --> {2}", intervalString, format, 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' (h\:mm) --> -17:14:00
//    '17:14:48' (g) --> 17:14:48
//    '17:14:48.153' (h\:mm\:ss\.fff) --> -17:14:48.1530000
//    '3:17:14:48.153' (G) --> 3.17:14:48.1530000
//    '3:17:14:48.153' (d\:hh\:mm\:ss\.fff) --> -3.17:14:48.1530000
//    '3:17:14:48,153' (G) --> 3.17:14:48.1530000
//    '12' (c) --> 12.00:00:00
//    '12' (%h) --> -12:00:00
//    '12' (%s) --> -00:00:12
Imports System.Globalization

Module Example
   Public Sub Main()
      Dim intervalString, format As String
      Dim interval As TimeSpan
      Dim culture As CultureInfo = Nothing
      
      ' Parse hour:minute value with custom format specifier.
      intervalString = "17:14"
      format = "h\:mm"
      culture = CultureInfo.CurrentCulture
      Try
         interval = TimeSpan.ParseExact(intervalString, format, 
                                        culture, TimeSpanStyles.AssumeNegative)
         Console.WriteLine("'{0}' ({1}) --> {2}", intervalString, format, interval)
      Catch e As FormatException
         Console.WriteLine("'{0}': Bad Format for '{1}'", intervalString, format)
      Catch e As OverflowException
         Console.WriteLine("'{0}': Overflow", intervalString)
      End Try      
      
      ' Parse hour:minute:second value with "g" specifier.
      intervalString = "17:14:48"
      format = "g"
      culture = CultureInfo.InvariantCulture
      Try
         interval = TimeSpan.ParseExact(intervalString, format, 
                                        culture, TimeSpanStyles.AssumeNegative)
         Console.WriteLine("'{0}' ({1}) --> {2}", intervalString, format, interval)
      Catch e As FormatException
         Console.WriteLine("'{0}': Bad Format for '{1}'", intervalString, format)
      Catch e As OverflowException
         Console.WriteLine("'{0}': Overflow", intervalString)
      End Try 
      
      ' Parse hours:minute.second value with custom format specifier.     
      intervalString = "17:14:48.153"
      format = "h\:mm\:ss\.fff"
      culture = Nothing
      Try
         interval = TimeSpan.ParseExact(intervalString, format, 
                                        culture, TimeSpanStyles.AssumeNegative)
         Console.WriteLine("'{0}' ({1}) --> {2}", intervalString, format, interval)
      Catch e As FormatException
         Console.WriteLine("'{0}': Bad Format for '{1}'", intervalString, format)
      Catch e As OverflowException
         Console.WriteLine("'{0}': Overflow", intervalString)
      End Try 

      ' 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, TimeSpanStyles.AssumeNegative)
         Console.WriteLine("'{0}' ({1}) --> {2}", intervalString, format, interval)
      Catch e As FormatException
         Console.WriteLine("'{0}': Bad Format for '{1}'", intervalString, format)
      Catch e As OverflowException
         Console.WriteLine("'{0}': Overflow", intervalString)
      End Try 
            
      ' Parse days:hours:minute.second value with a custom format specifier.     
      intervalString = "3:17:14:48.153"
      format = "d\:hh\:mm\:ss\.fff"
      culture = Nothing
      Try
         interval = TimeSpan.ParseExact(intervalString, format, 
                                        culture, TimeSpanStyles.AssumeNegative)
         Console.WriteLine("'{0}' ({1}) --> {2}", intervalString, format, interval)
      Catch e As FormatException
         Console.WriteLine("'{0}': Bad Format for '{1}'", intervalString, format)
      Catch e As OverflowException
         Console.WriteLine("'{0}': Overflow", intervalString)
      End Try 
      
      ' 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, TimeSpanStyles.AssumeNegative)
         Console.WriteLine("'{0}' ({1}) --> {2}", intervalString, format, interval)
      Catch e As FormatException
         Console.WriteLine("'{0}': Bad Format for '{1}'", intervalString, format)
      Catch e As OverflowException
         Console.WriteLine("'{0}': Overflow", intervalString)
      End Try 

      ' Parse a single number using the "c" standard format string. 
      intervalString = "12"
      format = "c"
      Try
         interval = TimeSpan.ParseExact(intervalString, format, 
                                        Nothing, TimeSpanStyles.AssumeNegative)
         Console.WriteLine("'{0}' ({1}) --> {2}", intervalString, format, interval)
      Catch e As FormatException
         Console.WriteLine("'{0}': Bad Format for '{1}'", intervalString, format)
      Catch e As OverflowException
         Console.WriteLine("'{0}': Overflow", intervalString)
      End Try 
      
      ' Parse a single number using the "%h" custom format string. 
      format = "%h"
      Try
         interval = TimeSpan.ParseExact(intervalString, format, 
                                        Nothing, TimeSpanStyles.AssumeNegative)
         Console.WriteLine("'{0}' ({1}) --> {2}", intervalString, format, interval)
      Catch e As FormatException
         Console.WriteLine("'{0}': Bad Format for '{1}'", intervalString, format)
      Catch e As OverflowException
         Console.WriteLine("'{0}': Overflow", intervalString)
      End Try 
      
      ' Parse a single number using the "%s" custom format string. 
      format = "%s"
      Try
         interval = TimeSpan.ParseExact(intervalString, format, 
                                        Nothing, TimeSpanStyles.AssumeNegative)
         Console.WriteLine("'{0}' ({1}) --> {2}", intervalString, format, interval)
      Catch e As FormatException
         Console.WriteLine("'{0}': Bad Format for '{1}'", intervalString, format)
      Catch e As OverflowException
         Console.WriteLine("'{0}': Overflow", intervalString)
      End Try 
   End Sub
End Module
' The example displays the following output:
'    '17:14' (h\:mm) --> -17:14:00
'    '17:14:48' (g) --> 17:14:48
'    '17:14:48.153' (h\:mm\:ss\.fff) --> -17:14:48.1530000
'    '3:17:14:48.153' (G) --> 3.17:14:48.1530000
'    '3:17:14:48.153' (d\:hh\:mm\:ss\.fff) --> -3.17:14:48.1530000
'    '3:17:14:48,153' (G) --> 3.17:14:48.1530000
'    '12' (c) --> 12.00:00:00
'    '12' (%h) --> -12:00:00
'    '12' (%s) --> -00:00:12

Commenti

Il ParseExact metodo analizza la rappresentazione di stringa di un intervallo di tempo, che deve essere nel formato definito format dal parametro, ad eccezione del fatto che gli spazi vuoti iniziali e finali vengono ignorati.The ParseExact method parses the string representation of a time interval, which must be in the format defined by the format parameter, except that leading and trailing white-space characters are ignored. Poiché input deve essere conforme al format formato esatto, è consigliabile usare sempre la gestione delle eccezioni durante la conversione di un input di stringa da parte dell'utente in un intervallo di tempo.Because input must conform to the format of format exactly, you should always use exception handling when converting a string input by the user to a time interval. Se si preferisce non utilizzare la gestione delle eccezioni, è invece possibile TryParseExact(String, String, IFormatProvider, TimeSpanStyles, TimeSpan) chiamare il metodo.If you prefer not to use exception handling, you can call the TryParseExact(String, String, IFormatProvider, TimeSpanStyles, TimeSpan) method instead.

Il format parametro è una stringa che contiene un singolo identificatore di formato standard o uno o più identificatori di formato personalizzati che definiscono il formato necessario di input.The format parameter is a string that contains either a single standard format specifier, or one or more custom format specifiers that define the required format of input. Per altre informazioni sulle stringhe di formato valide, vedere stringhe di formato TimeSpan standard e stringhe di formato TimeSpan personalizzate.For more information about valid format strings, see Standard TimeSpan Format Strings and Custom TimeSpan Format Strings.

Importante

Il ParseExact metodo usa le convenzioni delle impostazioni cultura specificate formatProvider dal parametro solo se format è una stringa TimeSpan di formato standard il cui valore è "g" o "g".The ParseExact method uses the conventions of the culture specified by the formatProvider parameter only if format is a standard TimeSpan format string whose value is either "g" or "G". Le stringhe di formato standard "c", "t" e "T" usano le convenzioni di formattazione delle impostazioni cultura invarianti.The "c", "t", and "T" standard format strings use the formatting conventions of the invariant culture. Le stringhe di formato personalizzate definiscono il formato preciso della stringa di input e utilizzano caratteri letterali per separare i componenti di un intervallo di tempo.Custom format strings define the precise format of the input string and use literal characters to separate the components of a time interval.

Il formatProvider parametro è un' IFormatProvider implementazione di che fornisce informazioni specifiche delle impostazioni cultura relative al formato della stringa restituita se format è una stringa di formato standard.The formatProvider parameter is an IFormatProvider implementation that provides culture-specific information about the format of the returned string if format is a standard format string. Il formatProvider parametro può essere uno dei seguenti:The formatProvider parameter can be any of the following:

Se formatProvider DateTimeFormatInfo è null, viene utilizzato l'oggetto associato alle impostazioni cultura correnti.If formatProvider is null, the DateTimeFormatInfo object that is associated with the current culture is used.

Il styles parametro influiscono sull'interpretazione delle stringhe analizzate mediante stringhe di formato personalizzate.The styles parameter affects the interpretation of strings that are parsed using custom format strings. Determina se input viene interpretato come un intervallo di tempo negativo solo se è presente un segno negativo (TimeSpanStyles.None) o se viene sempre interpretato come un intervallo di tempo negativo (TimeSpanStyles.AssumeNegative).It determines whether input is interpreted as a negative time interval only if a negative sign is present (TimeSpanStyles.None), or whether it is always interpreted as a negative time interval (TimeSpanStyles.AssumeNegative). Se TimeSpanStyles.AssumeNegative non viene usato, format deve includere un simbolo di segno negativo letterale (ad\esempio "-") per analizzare correttamente un intervallo di tempo negativo.If TimeSpanStyles.AssumeNegative is not used, format must include a literal negative sign symbol (such as "\-") to successfully parse a negative time interval.

Vedi anche

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

public static TimeSpan ParseExact (ReadOnlySpan<char> input, string[] formats, IFormatProvider formatProvider, System.Globalization.TimeSpanStyles styles = System.Globalization.TimeSpanStyles.None);
static member ParseExact : ReadOnlySpan<char> * string[] * IFormatProvider * System.Globalization.TimeSpanStyles -> TimeSpan
Public Shared Function ParseExact (input As ReadOnlySpan(Of Char), formats As String(), formatProvider As IFormatProvider, Optional styles As TimeSpanStyles = System.Globalization.TimeSpanStyles.None) As TimeSpan

Parametri

formats
String[]
formatProvider
IFormatProvider

Restituisce

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

Converte la rappresentazione di stringa di un intervallo di tempo nell'equivalente TimeSpan usando i formati, gli stili e le informazioni sul formato specifiche delle impostazioni cultura indicate.Converts the string representation of a time interval to its TimeSpan equivalent by using the specified formats, culture-specific format information, and styles. Il formato della rappresentazione di stringa deve corrispondere esattamente a uno dei formati specificati.The format of the string representation must match one of the specified formats exactly.

public:
 static TimeSpan ParseExact(System::String ^ input, cli::array <System::String ^> ^ formats, IFormatProvider ^ formatProvider, System::Globalization::TimeSpanStyles styles);
public static TimeSpan ParseExact (string input, string[] formats, IFormatProvider formatProvider, System.Globalization.TimeSpanStyles styles);
static member ParseExact : string * string[] * IFormatProvider * System.Globalization.TimeSpanStyles -> TimeSpan
Public Shared Function ParseExact (input As String, formats As String(), formatProvider As IFormatProvider, styles As TimeSpanStyles) As TimeSpan

Parametri

input
String

Stringa che specifica l'intervallo di tempo da convertire.A string that specifies the time interval to convert.

formats
String[]

Matrice di stringhe di formato standard o personalizzate che definisce il formato richiesto di input.A array of standard or custom format strings that define the required format of input.

formatProvider
IFormatProvider

Oggetto che fornisce informazioni di formattazione specifiche delle impostazioni cultura.An object that provides culture-specific formatting information.

styles
TimeSpanStyles

Combinazione bit per bit di valori di enumerazione che definisce gli elementi di stile che possono essere presenti in input.A bitwise combination of enumeration values that defines the style elements that may be present in input.

Restituisce

Intervallo di tempo che corrisponde a input, come specificato da formats, formatProvider e styles.A time interval that corresponds to input, as specified by formats, formatProvider, and styles.

Eccezioni

styles è un valore TimeSpanStyles non valido.styles is an invalid TimeSpanStyles value.

input è null.input is null.

Il formato di input non è valido.input has an invalid format.

L'oggetto input rappresenta un numero minore di MinValue o maggiore di MaxValue.input represents a number that is less than MinValue or greater than MaxValue.

-oppure--or- Almeno uno dei componenti giorni, ore, minuti o secondi in input non rientra nell'intervallo valido.At least one of the days, hours, minutes, or seconds components in input is outside its valid range.

Esempi

Nell'esempio seguente viene chiamato ParseExact(String, String[], IFormatProvider, TimeSpanStyles) il metodo per convertire ogni elemento di una matrice di stringhe TimeSpan in un valore.The following example calls the ParseExact(String, String[], IFormatProvider, TimeSpanStyles) method to convert each element of a string array to a TimeSpan value. Le stringhe possono rappresentare un intervallo di tempo nel formato breve generale o nel formato esteso generale.The strings can represent a time interval in either the general short format or the general long format.

Inoltre, nell'esempio viene modificato il modo in cui i metodi di analisi dell'intervallo di tempo interpretano una singola cifra.In addition, the example changes the way in which the time interval parsing methods interpret a single digit. In genere, una singola cifra viene interpretata come il numero di giorni in un intervallo di tempo.Ordinarily, a single digit is interpreted as the number of days in a time interval. Al contrario, %h la stringa di formato personalizzata viene usata per interpretare una singola cifra come numero di ore.Instead, the %h custom format string is used to interpret a single digit as the number of hours. Affinché questa modifica sia effettiva, si noti che la %h stringa di formato personalizzata deve precedere le altre stringhe formats di formato nella matrice.For this change to be effective, note that the %h custom format string must precede the other format strings in the formats array. Si noti inoltre che dall'output viene TimeSpanStyles.AssumeNegative usato il flag specificato nella chiamata al metodo solo quando si analizza una stringa con questo identificatore di formato.Also note from the output that the TimeSpanStyles.AssumeNegative flag specified in the method call is used only when parsing a string with this format specifier.

using System;
using System.Globalization;

public class Example
{
   public static void Main()
   {
      string[] inputs = { "3", "16:42", "1:6:52:35.0625", 
                          "1:6:52:35,0625" }; 
      string[] formats = { "%h", "g", "G" };
      TimeSpan interval;
      CultureInfo culture = new CultureInfo("de-DE");
      
      // Parse each string in inputs using formats and the de-DE culture.
      foreach (string input in inputs) {
         try {
            interval = TimeSpan.ParseExact(input, formats, culture,
                                           TimeSpanStyles.AssumeNegative);
            Console.WriteLine("{0} --> {1:c}", input, interval);
         }
         catch (FormatException) {
            Console.WriteLine("{0} --> Bad Format", input);
         }      
         catch (OverflowException) {
            Console.WriteLine("{0} --> Overflow", input);   
         }            
      }
   }
}
// The example displays the following output:
//       3 --> -03:00:00
//       16:42 --> 16:42:00
//       1:6:52:35.0625 --> Bad Format
//       1:6:52:35,0625 --> 1.06:52:35.0625000
Imports System.Globalization

Module Example
   Public Sub Main()
      Dim inputs() As String = { "3", "16:42", "1:6:52:35.0625", 
                                 "1:6:52:35,0625" } 
      Dim formats() As String = { "%h", "g", "G" }
      Dim interval As TimeSpan
      Dim culture As New CultureInfo("de-DE")
      
      ' Parse each string in inputs using formats and the de-DE culture.
      For Each input As String In inputs
         Try
            interval = TimeSpan.ParseExact(input, formats, culture, 
                                           TimeSpanStyles.AssumeNegative)
            Console.WriteLine("{0} --> {1:c}", input, interval)   
         Catch e As FormatException
            Console.WriteLine("{0} --> Bad Format", input)   
         Catch e As OverflowException
            Console.WriteLine("{0} --> Overflow", input)   
         End Try            
      Next
   End Sub
End Module
' The example displays the following output:
'       3 --> -03:00:00
'       16:42 --> 16:42:00
'       1:6:52:35.0625 --> Bad Format
'       1:6:52:35,0625 --> 1.06:52:35.0625000

Commenti

Il ParseExact(String, String[], IFormatProvider, TimeSpanStyles) metodo analizza la rappresentazione di stringa di un intervallo di tempo, che deve essere in uno dei formati definiti formats dal parametro, ad eccezione del fatto che gli spazi vuoti iniziali e finali vengono ignorati.The ParseExact(String, String[], IFormatProvider, TimeSpanStyles) method parses the string representation of a time interval, which must be in one of the formats defined by the formats parameter, except that leading and trailing white-space characters are ignored. Poiché input deve essere esattamente conforme a uno dei formati specificati formatsin, è consigliabile usare sempre la gestione delle eccezioni durante la conversione di un input di stringa da parte dell'utente in un intervallo di tempo.Because input must exactly conform to one of the formats specified in formats, you should always use exception handling when converting a string input by the user to a time interval. Se si preferisce non utilizzare la gestione delle eccezioni, è invece possibile TryParseExact(String, String[], IFormatProvider, TimeSpanStyles, TimeSpan) chiamare il metodo.If you prefer not to use exception handling, you can call the TryParseExact(String, String[], IFormatProvider, TimeSpanStyles, TimeSpan) method instead.

Il formats parametro è una matrice di stringhe i cui elementi sono costituiti da un singolo identificatore di formato standard o da uno o più identificatori di formato personalizzati che inputdefiniscono il formato necessario di.The formats parameter is a string array whose elements consist of either a single standard format specifier, or one or more custom format specifiers that define the required format of input. Per altre informazioni sulle stringhe di formato valide, vedere stringhe di formato TimeSpan standard e stringhe di formato TimeSpan personalizzate.For more information about valid format strings, see Standard TimeSpan Format Strings and Custom TimeSpan Format Strings. inputdeve corrispondere esattamente a un membro di formats affinché l'operazione di analisi abbia esito positivo.input must correspond exactly to a member of formats for the parse operation to succeed. L'operazione di analisi tenta di input trovare una corrispondenza con formats ogni elemento in a partire dal primo elemento nella matrice.The parse operation attempts to match input to each element in formats starting with the first element in the array.

Importante

Il ParseExact metodo utilizza le convenzioni delle impostazioni cultura specificate formatProvider dal parametro solo se la stringa di formato utilizzata per input l'analisi è TimeSpan una stringa di formato standard il cui valore è "g" o "g".The ParseExact method uses the conventions of the culture specified by the formatProvider parameter only if the format string used to parse input is a standard TimeSpan format string whose value is either "g" or "G". Le stringhe di formato standard "c", "t" e "T" usano le convenzioni di formattazione delle impostazioni cultura invarianti.The "c", "t", and "T" standard format strings use the formatting conventions of the invariant culture. Le stringhe di formato personalizzate definiscono il formato preciso della stringa di input e utilizzano caratteri letterali per separare i componenti di un intervallo di tempo.Custom format strings define the precise format of the input string and use literal characters to separate the components of a time interval.

Il formatProvider parametro è un' IFormatProvider implementazione di che fornisce informazioni specifiche delle impostazioni cultura relative al formato della stringa restituita se la stringa di formato input utilizzata per l'analisi è una stringa di formato standard.The formatProvider parameter is an IFormatProvider implementation that provides culture-specific information about the format of the returned string if the format string used to parse input is a standard format string. Il formatProvider parametro può essere uno dei seguenti:The formatProvider parameter can be any of the following:

Se formatProvider DateTimeFormatInfo è null, viene utilizzato l'oggetto associato alle impostazioni cultura correnti.If formatProvider is null, the DateTimeFormatInfo object that is associated with the current culture is used.

Il styles parametro influiscono sull'interpretazione delle stringhe analizzate mediante stringhe di formato personalizzate.The styles parameter affects the interpretation of strings that are parsed using custom format strings. Determina se input viene interpretato come un intervallo di tempo negativo solo se è presente un segno negativo (TimeSpanStyles.None) o se viene sempre interpretato come un intervallo di tempo negativo (TimeSpanStyles.AssumeNegative).It determines whether input is interpreted as a negative time interval only if a negative sign is present (TimeSpanStyles.None), or whether it is always interpreted as a negative time interval (TimeSpanStyles.AssumeNegative). Se TimeSpanStyles.AssumeNegative non viene usato, format deve includere un simbolo di segno negativo letterale (ad\esempio "-") per analizzare correttamente un intervallo di tempo negativo.If TimeSpanStyles.AssumeNegative is not used, format must include a literal negative sign symbol (such as "\-") to successfully parse a negative time interval.

Vedi anche

ParseExact(String, String[], IFormatProvider)

Converte la rappresentazione di stringa di un intervallo di tempo nell'equivalente TimeSpan usando la matrice di stringhe di formato e le informazioni sul formato specifiche delle impostazioni cultura indicate.Converts the string representation of a time interval to its TimeSpan equivalent by using the specified array of format strings and culture-specific format information. Il formato della rappresentazione di stringa deve corrispondere esattamente a uno dei formati specificati.The format of the string representation must match one of the specified formats exactly.

public:
 static TimeSpan ParseExact(System::String ^ input, cli::array <System::String ^> ^ formats, IFormatProvider ^ formatProvider);
public static TimeSpan ParseExact (string input, string[] formats, IFormatProvider formatProvider);
static member ParseExact : string * string[] * IFormatProvider -> TimeSpan
Public Shared Function ParseExact (input As String, formats As String(), formatProvider As IFormatProvider) As TimeSpan

Parametri

input
String

Stringa che specifica l'intervallo di tempo da convertire.A string that specifies the time interval to convert.

formats
String[]

Matrice di stringhe di formato standard o personalizzate che definisce il formato richiesto di input.A array of standard or custom format strings that defines the required format of input.

formatProvider
IFormatProvider

Oggetto che fornisce informazioni di formattazione specifiche delle impostazioni cultura.An object that provides culture-specific formatting information.

Restituisce

Intervallo di tempo che corrisponde a input, come specificato da formats e formatProvider.A time interval that corresponds to input, as specified by formats and formatProvider.

Eccezioni

input è null.input is null.

Il formato di input non è valido.input has an invalid format.

L'oggetto input rappresenta un numero minore di MinValue o maggiore di MaxValue.input represents a number that is less than MinValue or greater than MaxValue.

-oppure--or- Almeno uno dei componenti giorni, ore, minuti o secondi in input non rientra nell'intervallo valido.At least one of the days, hours, minutes, or seconds components in input is outside its valid range.

Esempi

Nell'esempio seguente viene chiamato ParseExact(String, String[], IFormatProvider) il metodo per convertire ogni elemento di una matrice di stringhe TimeSpan in un valore.The following example calls the ParseExact(String, String[], IFormatProvider) method to convert each element of a string array to a TimeSpan value. L'esempio interpreta le stringhe usando le convenzioni di formattazione delle impostazioni cultura francese-Francia ("fr-FR").The example interprets the strings using the formatting conventions of the French - France ("fr-FR") culture. Le stringhe possono rappresentare un intervallo di tempo nel formato breve generale o nel formato esteso generale.The strings can represent a time interval in either the general short format or the general long format.

Inoltre, nell'esempio viene modificato il modo in cui i metodi di analisi dell'intervallo di tempo interpretano una singola cifra.In addition, the example changes the way in which the time interval parsing methods interpret a single digit. In genere, una singola cifra viene interpretata come il numero di giorni in un intervallo di tempo.Ordinarily, a single digit is interpreted as the number of days in a time interval. Al contrario, %h la stringa di formato personalizzata viene usata per interpretare una singola cifra come numero di ore.Instead, the %h custom format string is used to interpret a single digit as the number of hours. Affinché questa modifica sia effettiva, si noti che la %h stringa di formato personalizzata deve precedere le altre stringhe formats di formato nella matrice.For this change to be effective, note that the %h custom format string must precede the other format strings in the formats array.

using System;
using System.Globalization;

public class Example
{
   public static void Main()
   {
      string[] inputs = { "3", "16:42", "1:6:52:35.0625", 
                          "1:6:52:35,0625" }; 
      string[] formats = { "g", "G", "%h"};
      TimeSpan interval;
      CultureInfo culture = new CultureInfo("fr-FR");
      
      // Parse each string in inputs using formats and the fr-FR culture.
      foreach (string input in inputs) {
         try {
            interval = TimeSpan.ParseExact(input, formats, culture);
            Console.WriteLine("{0} --> {1:c}", input, interval);
         }
         catch (FormatException) {
            Console.WriteLine("{0} --> Bad Format", input);
         }      
         catch (OverflowException) {
            Console.WriteLine("{0} --> Overflow", input);   
         }            
      }
   }
}
// The example displays the following output:
//       3 --> 03:00:00
//       16:42 --> 16:42:00
//       1:6:52:35.0625 --> Bad Format
//       1:6:52:35,0625 --> 1.06:52:35.0625000
Imports System.Globalization

Module Example
   Public Sub Main()
      Dim inputs() As String = { "3", "16:42", "1:6:52:35.0625", 
                                 "1:6:52:35,0625" } 
      Dim formats() As String = { "%h", "g", "G" }
      Dim interval As TimeSpan
      Dim culture As New CultureInfo("fr-FR")
      
      ' Parse each string in inputs using formats and the fr-FR culture.
      For Each input As String In inputs
         Try
            interval = TimeSpan.ParseExact(input, formats, culture)
            Console.WriteLine("{0} --> {1:c}", input, interval)   
         Catch e As FormatException
            Console.WriteLine("{0} --> Bad Format", input)   
         Catch e As OverflowException
            Console.WriteLine("{0} --> Overflow", input)   
         End Try            
      Next
   End Sub
End Module
' The example displays the following output:
'       3 --> 3.00:00:00
'       16:42 --> 16:42:00
'       1:6:52:35.0625 --> Bad Format
'       1:6:52:35,0625 --> 1.06:52:35.0625000

Commenti

Il ParseExact(String, String, IFormatProvider) metodo analizza la rappresentazione di stringa di un intervallo di tempo, che deve essere in uno dei formati definiti formats dal parametro, ad eccezione del fatto che gli spazi vuoti iniziali e finali vengono ignorati.The ParseExact(String, String, IFormatProvider) method parses the string representation of a time interval, which must be in one of the formats defined by the formats parameter, except that leading and trailing white-space characters are ignored. Poiché input deve essere esattamente conforme a uno dei formati specificati formatsin, è consigliabile usare sempre la gestione delle eccezioni durante la conversione di un input di stringa da parte dell'utente in un intervallo di tempo.Because input must exactly conform to one of the formats specified in formats, you should always use exception handling when converting a string input by the user to a time interval. Se si preferisce non utilizzare la gestione delle eccezioni, è invece possibile TryParseExact(String, String[], IFormatProvider, TimeSpan) chiamare il metodo.If you prefer not to use exception handling, you can call the TryParseExact(String, String[], IFormatProvider, TimeSpan) method instead.

Il formats parametro è una matrice di stringhe i cui elementi sono costituiti da un singolo identificatore di formato standard o da uno o più identificatori di formato personalizzati che inputdefiniscono il formato necessario di.The formats parameter is a string array whose elements consist of either a single standard format specifier, or one or more custom format specifiers that define the required format of input. Per altre informazioni sulle stringhe di formato valide, vedere stringhe di formato TimeSpan standard e stringhe di formato TimeSpan personalizzate.For more information about valid format strings, see Standard TimeSpan Format Strings and Custom TimeSpan Format Strings. inputdeve corrispondere esattamente a un membro di formats affinché l'operazione di analisi abbia esito positivo.input must correspond exactly to a member of formats for the parse operation to succeed. L'operazione di analisi tenta di input trovare una corrispondenza con formats ogni elemento in a partire dal primo elemento nella matrice.The parse operation attempts to match input to each element in formats starting with the first element in the array.

Importante

Il ParseExact metodo utilizza le convenzioni delle impostazioni cultura specificate formatProvider dal parametro solo se la stringa di formato utilizzata per input l'analisi è TimeSpan una stringa di formato standard il cui valore è "g" o "g".The ParseExact method uses the conventions of the culture specified by the formatProvider parameter only if the format string used to parse input is a standard TimeSpan format string whose value is either "g" or "G". Le stringhe di formato standard "c", "t" e "T" usano le convenzioni di formattazione delle impostazioni cultura invarianti.The "c", "t", and "T" standard format strings use the formatting conventions of the invariant culture. Le stringhe di formato personalizzate definiscono il formato preciso della stringa di input e utilizzano caratteri letterali per separare i componenti di un intervallo di tempo.Custom format strings define the precise format of the input string and use literal characters to separate the components of a time interval.

Il formatProvider parametro è un' IFormatProvider implementazione di che fornisce informazioni specifiche delle impostazioni cultura relative al formato della stringa restituita se la stringa di formato input utilizzata per l'analisi è una stringa di formato standard.The formatProvider parameter is an IFormatProvider implementation that provides culture-specific information about the format of the returned string if the format string used to parse input is a standard format string. Il formatProvider parametro può essere uno dei seguenti:The formatProvider parameter can be any of the following:

Se formatProvider DateTimeFormatInfo è null, viene utilizzato l'oggetto associato alle impostazioni cultura correnti.If formatProvider is null, the DateTimeFormatInfo object that is associated with the current culture is used.

Vedi anche

ParseExact(String, String, IFormatProvider)

Converte la rappresentazione di stringa di un intervallo di tempo nell'equivalente TimeSpan usando le informazioni sul formato specifiche delle impostazioni cultura indicate.Converts the string representation of a time interval to its TimeSpan equivalent by using the specified format and culture-specific format information. Il formato della rappresentazione di stringa deve corrispondere esattamente al formato specificato.The format of the string representation must match the specified format exactly.

public:
 static TimeSpan ParseExact(System::String ^ input, System::String ^ format, IFormatProvider ^ formatProvider);
public static TimeSpan ParseExact (string input, string format, IFormatProvider formatProvider);
static member ParseExact : string * string * IFormatProvider -> TimeSpan
Public Shared Function ParseExact (input As String, format As String, formatProvider As IFormatProvider) As TimeSpan

Parametri

input
String

Stringa che specifica l'intervallo di tempo da convertire.A string that specifies the time interval to convert.

format
String

Stringa di formato standard o personalizzato che definisce il formato richiesto di input.A standard or custom format string that defines the required format of input.

formatProvider
IFormatProvider

Oggetto che fornisce informazioni di formattazione specifiche delle impostazioni cultura.An object that provides culture-specific formatting information.

Restituisce

Intervallo di tempo che corrisponde a input, come specificato da format e formatProvider.A time interval that corresponds to input, as specified by format and formatProvider.

Eccezioni

input è null.input is null.

Il formato di input non è valido.input has an invalid format.

L'oggetto input rappresenta un numero minore di MinValue o maggiore di MaxValue.input represents a number that is less than MinValue or greater than MaxValue.

-oppure--or- Almeno uno dei componenti giorni, ore, minuti o secondi in input non rientra nell'intervallo valido.At least one of the days, hours, minutes, or seconds components in input is outside its valid range.

Esempi

Nell'esempio seguente viene usato ParseExact(String, String, IFormatProvider) il metodo per analizzare più rappresentazioni di stringa di intervalli temporali usando varie stringhe di formato e impostazioni cultura.The following example uses the ParseExact(String, String, IFormatProvider) method to parse several string representations of time intervals using various format strings and cultures.

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
Imports System.Globalization

Module Example
   Public Sub Main()
      Dim intervalString, format As String
      Dim interval As TimeSpan
      Dim culture As CultureInfo
      
      ' 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 e As FormatException
         Console.WriteLine("'{0}': Bad Format for '{1}'", intervalString, format)
      Catch e As OverflowException
         Console.WriteLine("'{0}': Overflow", intervalString)
      End Try      
      
      ' 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 e As FormatException
         Console.WriteLine("'{0}': Bad Format for '{1}'", intervalString, format)
      Catch e As OverflowException
         Console.WriteLine("'{0}': Overflow", intervalString)
      End Try 
      
      ' 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 e As FormatException
         Console.WriteLine("'{0}': Bad Format for '{1}'", intervalString, format)
      Catch e As OverflowException
         Console.WriteLine("'{0}': Overflow", intervalString)
      End Try 

      ' 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 e As FormatException
         Console.WriteLine("'{0}': Bad Format for '{1}'", intervalString, format)
      Catch e As OverflowException
         Console.WriteLine("'{0}': Overflow", intervalString)
      End Try 
            
      ' 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 e As FormatException
         Console.WriteLine("'{0}': Bad Format for '{1}'", intervalString, format)
      Catch e As OverflowException
         Console.WriteLine("'{0}': Overflow", intervalString)
      End Try 
      
      ' 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 e As FormatException
         Console.WriteLine("'{0}': Bad Format for '{1}'", intervalString, format)
      Catch e As OverflowException
         Console.WriteLine("'{0}': Overflow", intervalString)
      End Try 

      ' Parse a single number using the "c" standard format string. 
      intervalString = "12"
      format = "c"
      Try
         interval = TimeSpan.ParseExact(intervalString, format, Nothing)
         Console.WriteLine("'{0}' --> {1}", intervalString, interval)
      Catch e As FormatException
         Console.WriteLine("'{0}': Bad Format for '{1}'", intervalString, format)
      Catch e As OverflowException
         Console.WriteLine("'{0}': Overflow", intervalString)
      End Try 
      
      ' Parse a single number using the "%h" custom format string. 
      format = "%h"
      Try
         interval = TimeSpan.ParseExact(intervalString, format, Nothing)
         Console.WriteLine("'{0}' --> {1}", intervalString, interval)
      Catch e As FormatException
         Console.WriteLine("'{0}': Bad Format for '{1}'", intervalString, format)
      Catch e As OverflowException
         Console.WriteLine("'{0}': Overflow", intervalString)
      End Try 
      
      ' Parse a single number using the "%s" custom format string. 
      format = "%s"
      Try
         interval = TimeSpan.ParseExact(intervalString, format, Nothing)
         Console.WriteLine("'{0}' --> {1}", intervalString, interval)
      Catch e As FormatException
         Console.WriteLine("'{0}': Bad Format for '{1}'", intervalString, format)
      Catch e As OverflowException
         Console.WriteLine("'{0}': Overflow", intervalString)
      End Try 
   End Sub
End Module
' 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

Commenti

Il ParseExact(String, String, IFormatProvider) metodo analizza la rappresentazione di stringa di un intervallo di tempo, che deve essere nel formato definito format dal parametro, ad eccezione del fatto che gli spazi vuoti iniziali e finali vengono ignorati.The ParseExact(String, String, IFormatProvider) method parses the string representation of a time interval, which must be in the format defined by the format parameter, except that leading and trailing white-space characters are ignored. Poiché input deve essere conforme al format formato esatto, è consigliabile usare sempre la gestione delle eccezioni durante la conversione di un input di stringa da parte dell'utente in un intervallo di tempo.Because input must conform to the format of format exactly, you should always use exception handling when converting a string input by the user to a time interval. Se si preferisce non utilizzare la gestione delle eccezioni, è invece possibile TryParseExact(String, String, IFormatProvider, TimeSpan) chiamare il metodo.If you prefer not to use exception handling, you can call the TryParseExact(String, String, IFormatProvider, TimeSpan) method instead.

Il format parametro è una stringa che contiene un singolo identificatore di formato standard o uno o più identificatori di formato personalizzati che definiscono il formato necessario di input.The format parameter is a string that contains either a single standard format specifier, or one or more custom format specifiers that define the required format of input. Per altre informazioni sulle stringhe di formato valide, vedere stringhe di formato TimeSpan standard e stringhe di formato TimeSpan personalizzate.For more information about valid format strings, see Standard TimeSpan Format Strings and Custom TimeSpan Format Strings.

Importante

Il ParseExact metodo usa le convenzioni delle impostazioni cultura specificate formatProvider dal parametro solo se format è una stringa TimeSpan di formato standard il cui valore è "g" o "g".The ParseExact method uses the conventions of the culture specified by the formatProvider parameter only if format is a standard TimeSpan format string whose value is either "g" or "G". Le stringhe di formato standard "c", "t" e "T" usano le convenzioni di formattazione delle impostazioni cultura invarianti.The "c", "t", and "T" standard format strings use the formatting conventions of the invariant culture. Le stringhe di formato personalizzate definiscono il formato preciso della stringa di input e utilizzano caratteri letterali per separare i componenti di un intervallo di tempo.Custom format strings define the precise format of the input string and use literal characters to separate the components of a time interval.

Il formatProvider parametro è un' IFormatProvider implementazione di che fornisce informazioni specifiche delle impostazioni cultura relative al formato della stringa restituita se format è una stringa di formato standard.The formatProvider parameter is an IFormatProvider implementation that provides culture-specific information about the format of the returned string if format is a standard format string. Il formatProvider parametro può essere uno dei seguenti:The formatProvider parameter can be any of the following:

Se formatProvider DateTimeFormatInfo è null, viene utilizzato l'oggetto associato alle impostazioni cultura correnti.If formatProvider is null, the DateTimeFormatInfo object that is associated with the current culture is used.

Vedi anche

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

public static TimeSpan ParseExact (ReadOnlySpan<char> input, ReadOnlySpan<char> format, IFormatProvider formatProvider, System.Globalization.TimeSpanStyles styles = System.Globalization.TimeSpanStyles.None);
static member ParseExact : ReadOnlySpan<char> * ReadOnlySpan<char> * IFormatProvider * System.Globalization.TimeSpanStyles -> TimeSpan
Public Shared Function ParseExact (input As ReadOnlySpan(Of Char), format As ReadOnlySpan(Of Char), formatProvider As IFormatProvider, Optional styles As TimeSpanStyles = System.Globalization.TimeSpanStyles.None) As TimeSpan

Parametri

format
ReadOnlySpan<Char>
formatProvider
IFormatProvider

Restituisce

Si applica a