TimeSpan.TryParseExact TimeSpan.TryParseExact TimeSpan.TryParseExact TimeSpan.TryParseExact Method

Definizione

Converte la rappresentazione di stringa di un intervallo di tempo nell'equivalente TimeSpan e restituisce un valore che indica se la conversione è stata eseguita correttamente.Converts the string representation of a time interval to its TimeSpan equivalent, and returns a value that indicates whether the conversion succeeded. 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

TryParseExact(String, String, IFormatProvider, TimeSpanStyles, TimeSpan) TryParseExact(String, String, IFormatProvider, TimeSpanStyles, TimeSpan) TryParseExact(String, String, IFormatProvider, TimeSpanStyles, TimeSpan) TryParseExact(String, String, IFormatProvider, TimeSpanStyles, TimeSpan)

Converte la rappresentazione di stringa di un intervallo di tempo nell'equivalente TimeSpan usando il formato, le informazioni sul formato specifiche delle impostazioni cultura e gli stili specificati e restituisce un valore che indica se la conversione è stata eseguita correttamente.Converts the string representation of a time interval to its TimeSpan equivalent by using the specified format, culture-specific format information, and styles, and returns a value that indicates whether the conversion succeeded. Il formato della rappresentazione di stringa deve corrispondere esattamente al formato specificato.The format of the string representation must match the specified format exactly.

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

Converte la rappresentazione di stringa specificata di un intervallo di tempo nell'equivalente TimeSpan usando i formati specificati e le informazioni sul formato specifiche delle impostazioni cultura e restituisce un valore che indica se la conversione è stata eseguita correttamente.Converts the specified string representation of a time interval to its TimeSpan equivalent by using the specified formats and culture-specific format information, and returns a value that indicates whether the conversion succeeded. 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.

TryParseExact(String, String[], IFormatProvider, TimeSpanStyles, TimeSpan) TryParseExact(String, String[], IFormatProvider, TimeSpanStyles, TimeSpan) TryParseExact(String, String[], IFormatProvider, TimeSpanStyles, TimeSpan) TryParseExact(String, String[], IFormatProvider, TimeSpanStyles, TimeSpan)

Converte la rappresentazione di stringa specificata di un intervallo di tempo nell'equivalente TimeSpan usando i formati, le informazioni sul formato specifiche delle impostazioni cultura e gli stili specificati e restituisce un valore che indica se la conversione è stata eseguita correttamente.Converts the specified string representation of a time interval to its TimeSpan equivalent by using the specified formats, culture-specific format information, and styles, and returns a value that indicates whether the conversion succeeded. 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.

TryParseExact(ReadOnlySpan<Char>, String[], IFormatProvider, TimeSpan) TryParseExact(ReadOnlySpan<Char>, String[], IFormatProvider, TimeSpan) TryParseExact(ReadOnlySpan<Char>, String[], IFormatProvider, TimeSpan) TryParseExact(ReadOnlySpan<Char>, String[], IFormatProvider, TimeSpan)
TryParseExact(ReadOnlySpan<Char>, ReadOnlySpan<Char>, IFormatProvider, TimeSpan) TryParseExact(ReadOnlySpan<Char>, ReadOnlySpan<Char>, IFormatProvider, TimeSpan) TryParseExact(ReadOnlySpan<Char>, ReadOnlySpan<Char>, IFormatProvider, TimeSpan) TryParseExact(ReadOnlySpan<Char>, ReadOnlySpan<Char>, IFormatProvider, TimeSpan)
TryParseExact(String, String, IFormatProvider, TimeSpan) TryParseExact(String, String, IFormatProvider, TimeSpan) TryParseExact(String, String, IFormatProvider, TimeSpan) TryParseExact(String, String, IFormatProvider, TimeSpan)

Converte la rappresentazione di stringa di un intervallo di tempo nell'equivalente TimeSpan usando il formato specificato e le informazioni sul formato specifiche delle impostazioni cultura e restituisce un valore che indica se la conversione è stata eseguita correttamente.Converts the string representation of a time interval to its TimeSpan equivalent by using the specified format and culture-specific format information, and returns a value that indicates whether the conversion succeeded. Il formato della rappresentazione di stringa deve corrispondere esattamente al formato specificato.The format of the string representation must match the specified format exactly.

TryParseExact(String, String, IFormatProvider, TimeSpanStyles, TimeSpan) TryParseExact(String, String, IFormatProvider, TimeSpanStyles, TimeSpan) TryParseExact(String, String, IFormatProvider, TimeSpanStyles, TimeSpan) TryParseExact(String, String, IFormatProvider, TimeSpanStyles, TimeSpan)

Converte la rappresentazione di stringa di un intervallo di tempo nell'equivalente TimeSpan usando il formato, le informazioni sul formato specifiche delle impostazioni cultura e gli stili specificati e restituisce un valore che indica se la conversione è stata eseguita correttamente.Converts the string representation of a time interval to its TimeSpan equivalent by using the specified format, culture-specific format information, and styles, and returns a value that indicates whether the conversion succeeded. 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 bool TryParseExact(System::String ^ input, System::String ^ format, IFormatProvider ^ formatProvider, System::Globalization::TimeSpanStyles styles, [Runtime::InteropServices::Out] TimeSpan % result);
public static bool TryParseExact (string input, string format, IFormatProvider formatProvider, System.Globalization.TimeSpanStyles styles, out TimeSpan result);
static member TryParseExact : string * string * IFormatProvider * System.Globalization.TimeSpanStyles * TimeSpan -> bool
Public Shared Function TryParseExact (input As String, format As String, formatProvider As IFormatProvider, styles As TimeSpanStyles, ByRef result As TimeSpan) As Boolean

Parametri

input
String String String String

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

format
String String String 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 IFormatProvider IFormatProvider IFormatProvider

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

styles
TimeSpanStyles TimeSpanStyles TimeSpanStyles TimeSpanStyles

Uno o più valori di enumerazione che indicano lo stile di input.One or more enumeration values that indicate the style of input.

result
TimeSpan TimeSpan TimeSpan TimeSpan

Quando questo metodo viene restituito, contiene un oggetto che rappresenta l'intervallo di tempo specificato da input o Zero in caso di conversione non riuscita.When this method returns, contains an object that represents the time interval specified by input, or Zero if the conversion failed. Questo parametro viene passato non inizializzato.This parameter is passed uninitialized.

Restituisce

true se input è stato convertito correttamente; in caso contrario, false.true if input was converted successfully; otherwise, false.

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;
      if (TimeSpan.TryParseExact(intervalString, format, 
                                 culture, TimeSpanStyles.AssumeNegative, out interval))
         Console.WriteLine("'{0}' ({1}) --> {2}", intervalString, format, interval);
      else   
         Console.WriteLine("Unable to parse '{0}' using format {1}",
                           intervalString, format);
      
      // Parse hour:minute:second value with "g" specifier.
      intervalString = "17:14:48";
      format = "g";
      culture = CultureInfo.InvariantCulture;
      if (TimeSpan.TryParseExact(intervalString, format, 
                                 culture, TimeSpanStyles.AssumeNegative, out interval))
         Console.WriteLine("'{0}' ({1}) --> {2}", intervalString, format, interval);
      else
         Console.WriteLine("Unable to parse '{0}' using format {1}",
                           intervalString, format);
      
      // Parse hours:minute.second value with custom format specifier.     
      intervalString = "17:14:48.153";
      format = @"h\:mm\:ss\.fff";
      culture = null;
      if (TimeSpan.TryParseExact(intervalString, format, 
                                 culture, TimeSpanStyles.AssumeNegative, out interval))
         Console.WriteLine("'{0}' ({1}) --> {2}", intervalString, format, interval);
      else
         Console.WriteLine("Unable to parse '{0}' using format {1}",
                           intervalString, format);   

      // 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;
      if (TimeSpan.TryParseExact(intervalString, format, 
                                 culture, TimeSpanStyles.AssumeNegative, out interval))
         Console.WriteLine("'{0}' ({1}) --> {2}", intervalString, format, interval);
      else   
         Console.WriteLine("Unable to parse '{0}' using format {1}",
                           intervalString, format);   
            
      // 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;
      if (TimeSpan.TryParseExact(intervalString, format, 
                                 culture, TimeSpanStyles.AssumeNegative, out interval))
         Console.WriteLine("'{0}' ({1}) --> {2}", intervalString, format, interval);
      else   
         Console.WriteLine("Unable to parse '{0}' using format {1}",
                           intervalString, format);
      
      // 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");
      if (TimeSpan.TryParseExact(intervalString, format, 
                                 culture, TimeSpanStyles.AssumeNegative, out interval))
         Console.WriteLine("'{0}' ({1}) --> {2}", intervalString, format, interval);
      else   
         Console.WriteLine("Unable to parse '{0}' using format {1}",
                           intervalString, format);

      // Parse a single number using the "c" standard format string. 
      intervalString = "12";
      format = "c";
      if (TimeSpan.TryParseExact(intervalString, format, 
                                 null, TimeSpanStyles.AssumeNegative, out interval))
         Console.WriteLine("'{0}' ({1}) --> {2}", intervalString, format, interval);
      else   
         Console.WriteLine("Unable to parse '{0}' using format {1}",
                           intervalString, format);
      
      // Parse a single number using the "%h" custom format string. 
      format = "%h";
      if (TimeSpan.TryParseExact(intervalString, format, 
                                 null, TimeSpanStyles.AssumeNegative, out interval))
         Console.WriteLine("'{0}' ({1}) --> {2}", intervalString, format, interval);
      else   
         Console.WriteLine("Unable to parse '{0}' using format {1}",
                           intervalString, format);
      
      // Parse a single number using the "%s" custom format string. 
      format = "%s";
      if (TimeSpan.TryParseExact(intervalString, format, 
                                 null, TimeSpanStyles.AssumeNegative, out interval))
         Console.WriteLine("'{0}' ({1}) --> {2}", intervalString, format, interval);
      else   
         Console.WriteLine("Unable to parse '{0}' using format {1}",
                           intervalString, format);
   }
}
// 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
      If TimeSpan.TryParseExact(intervalString, format, 
                                culture, TimeSpanStyles.AssumeNegative, interval) Then
         Console.WriteLine("'{0}' ({1}) --> {2}", intervalString, format, interval)
      Else
         Console.WriteLine("Unable to parse '{0}' using format {1}",
                           intervalString, format)   
      End If
      
      ' Parse hour:minute:second value with "g" specifier.
      intervalString = "17:14:48"
      format = "g"
      culture = CultureInfo.InvariantCulture
      If TimeSpan.TryParseExact(intervalString, format, 
                                culture, TimeSpanStyles.AssumeNegative, interval) Then
         Console.WriteLine("'{0}' ({1}) --> {2}", intervalString, format, interval)
      Else
         Console.WriteLine("Unable to parse '{0}' using format {1}",
                           intervalString, format)   
      End If
      
      ' Parse hours:minute.second value with custom format specifier.     
      intervalString = "17:14:48.153"
      format = "h\:mm\:ss\.fff"
      culture = Nothing
      If TimeSpan.TryParseExact(intervalString, format, 
                                culture, TimeSpanStyles.AssumeNegative, interval) Then
         Console.WriteLine("'{0}' ({1}) --> {2}", intervalString, format, interval)
      Else
         Console.WriteLine("Unable to parse '{0}' using format {1}",
                           intervalString, format)   
      End If 

      ' 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
      If TimeSpan.TryParseExact(intervalString, format, 
                                culture, TimeSpanStyles.AssumeNegative, interval) Then
         Console.WriteLine("'{0}' ({1}) --> {2}", intervalString, format, interval)
      Else
         Console.WriteLine("Unable to parse '{0}' using format {1}",
                           intervalString, format)   
      End If 
            
      ' 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
      If TimeSpan.TryParseExact(intervalString, format, 
                                culture, TimeSpanStyles.AssumeNegative, interval) Then
         Console.WriteLine("'{0}' ({1}) --> {2}", intervalString, format, interval)
      Else
         Console.WriteLine("Unable to parse '{0}' using format {1}",
                           intervalString, format)   
      End If 
      
      ' 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")
      If TimeSpan.TryParseExact(intervalString, format, 
                                culture, TimeSpanStyles.AssumeNegative, interval) Then
         Console.WriteLine("'{0}' ({1}) --> {2}", intervalString, format, interval)
      Else
         Console.WriteLine("Unable to parse '{0}' using format {1}",
                           intervalString, format)
      End If 

      ' Parse a single number using the "c" standard format string. 
      intervalString = "12"
      format = "c"
      If TimeSpan.TryParseExact(intervalString, format, 
                                Nothing, TimeSpanStyles.AssumeNegative, interval) Then
         Console.WriteLine("'{0}' ({1}) --> {2}", intervalString, format, interval)
      Else
         Console.WriteLine("Unable to parse '{0}' using format {1}",
                           intervalString, format)   
      End If 
      
      ' Parse a single number using the "%h" custom format string. 
      format = "%h"
      If TimeSpan.TryParseExact(intervalString, format, 
                                Nothing, TimeSpanStyles.AssumeNegative, interval) Then
         Console.WriteLine("'{0}' ({1}) --> {2}", intervalString, format, interval)
      Else
         Console.WriteLine("Unable to parse '{0}' using format {1}",
                           intervalString, format)   
      End If 
      
      ' Parse a single number using the "%s" custom format string. 
      format = "%s"
      If TimeSpan.TryParseExact(intervalString, format, 
                                Nothing, TimeSpanStyles.AssumeNegative, interval) Then
         Console.WriteLine("'{0}' ({1}) --> {2}", intervalString, format, interval)
      Else
         Console.WriteLine("Unable to parse '{0}' using format {1}",
                           intervalString, format)   
      End If 
   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 TryParseExact(String, String, IFormatProvider, TimeSpanStyles, TimeSpan) 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 TryParseExact(String, String, IFormatProvider, TimeSpanStyles, TimeSpan) 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. Questo metodo è simile al ParseExact(String, String, IFormatProvider, TimeSpanStyles) metodo, ad eccezione del fatto che non genera un'eccezione se la conversione non riesce.This method is similar to the ParseExact(String, String, IFormatProvider, TimeSpanStyles) method, except that it does not throw an exception if the conversion fails.

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.

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 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

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

public:
 static bool TryParseExact(ReadOnlySpan<char> input, cli::array <System::String ^> ^ formats, IFormatProvider ^ formatProvider, System::Globalization::TimeSpanStyles styles, [Runtime::InteropServices::Out] TimeSpan % result);
public static bool TryParseExact (ReadOnlySpan<char> input, string[] formats, IFormatProvider formatProvider, System.Globalization.TimeSpanStyles styles, out TimeSpan result);
static member TryParseExact : ReadOnlySpan<char> * string[] * IFormatProvider * System.Globalization.TimeSpanStyles * TimeSpan -> bool
Public Shared Function TryParseExact (input As ReadOnlySpan(Of Char), formats As String(), formatProvider As IFormatProvider, styles As TimeSpanStyles, ByRef result As TimeSpan) As Boolean

Parametri

formats
String[]

Restituisce

TryParseExact(ReadOnlySpan<Char>, ReadOnlySpan<Char>, IFormatProvider, TimeSpanStyles, TimeSpan) TryParseExact(ReadOnlySpan<Char>, ReadOnlySpan<Char>, IFormatProvider, TimeSpanStyles, TimeSpan) TryParseExact(ReadOnlySpan<Char>, ReadOnlySpan<Char>, IFormatProvider, TimeSpanStyles, TimeSpan) TryParseExact(ReadOnlySpan<Char>, ReadOnlySpan<Char>, IFormatProvider, TimeSpanStyles, TimeSpan)

public:
 static bool TryParseExact(ReadOnlySpan<char> input, ReadOnlySpan<char> format, IFormatProvider ^ formatProvider, System::Globalization::TimeSpanStyles styles, [Runtime::InteropServices::Out] TimeSpan % result);
public static bool TryParseExact (ReadOnlySpan<char> input, ReadOnlySpan<char> format, IFormatProvider formatProvider, System.Globalization.TimeSpanStyles styles, out TimeSpan result);
static member TryParseExact : ReadOnlySpan<char> * ReadOnlySpan<char> * IFormatProvider * System.Globalization.TimeSpanStyles * TimeSpan -> bool
Public Shared Function TryParseExact (input As ReadOnlySpan(Of Char), format As ReadOnlySpan(Of Char), formatProvider As IFormatProvider, styles As TimeSpanStyles, ByRef result As TimeSpan) As Boolean

Parametri

format
ReadOnlySpan<Char>

Restituisce

TryParseExact(String, String[], IFormatProvider, TimeSpan) TryParseExact(String, String[], IFormatProvider, TimeSpan) TryParseExact(String, String[], IFormatProvider, TimeSpan) TryParseExact(String, String[], IFormatProvider, TimeSpan)

Converte la rappresentazione di stringa specificata di un intervallo di tempo nell'equivalente TimeSpan usando i formati specificati e le informazioni sul formato specifiche delle impostazioni cultura e restituisce un valore che indica se la conversione è stata eseguita correttamente.Converts the specified string representation of a time interval to its TimeSpan equivalent by using the specified formats and culture-specific format information, and returns a value that indicates whether the conversion succeeded. 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 bool TryParseExact(System::String ^ input, cli::array <System::String ^> ^ formats, IFormatProvider ^ formatProvider, [Runtime::InteropServices::Out] TimeSpan % result);
public static bool TryParseExact (string input, string[] formats, IFormatProvider formatProvider, out TimeSpan result);
static member TryParseExact : string * string[] * IFormatProvider * TimeSpan -> bool
Public Shared Function TryParseExact (input As String, formats As String(), formatProvider As IFormatProvider, ByRef result As TimeSpan) As Boolean

Parametri

input
String String String 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 personalizzato che definiscono i formati accettabili di input.A array of standard or custom format strings that define the acceptable formats of input.

formatProvider
IFormatProvider IFormatProvider IFormatProvider IFormatProvider

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

result
TimeSpan TimeSpan TimeSpan TimeSpan

Quando questo metodo viene restituito, contiene un oggetto che rappresenta l'intervallo di tempo specificato da input o Zero in caso di conversione non riuscita.When this method returns, contains an object that represents the time interval specified by input, or Zero if the conversion failed. Questo parametro viene passato non inizializzato.This parameter is passed uninitialized.

Restituisce

true se input è stato convertito correttamente; in caso contrario, false.true if input was converted successfully; otherwise, false.

Esempi

Nell'esempio seguente viene chiamato TryParseExact(String, String[], IFormatProvider, TimeSpan) il metodo per convertire ogni elemento di una matrice di stringhe TimeSpan in un valore.The following example calls the TryParseExact(String, String[], IFormatProvider, TimeSpan) 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 by 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) {
         if(TimeSpan.TryParseExact(input, formats, culture, out interval))
            Console.WriteLine("{0} --> {1:c}", input, interval);
         else
            Console.WriteLine("Unable to parse {0}", input);   
      }
   }
}
// The example displays the following output:
//       3 --> 03:00:00
//       16:42 --> 16:42:00
//       Unable to parse 1:6:52:35.0625
//       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
         If TimeSpan.TryParseExact(input, formats, culture, interval) Then
            Console.WriteLine("{0} --> {1:c}", input, interval)   
         Else
            Console.WriteLine("Unable to parse {0}", input)   
         End If            
      Next
   End Sub
End Module
' The example displays the following output:
'       3 --> 03:00:00
'       16:42 --> 16:42:00
'       Unable to parse 1:6:52:35.0625
'       1:6:52:35,0625 --> 1.06:52:35.0625000

Commenti

Il TryParseExact(String, String[], IFormatProvider, TimeSpan) metodo analizza la rappresentazione di stringa di un intervallo di tempo, che deve essere nel formato definito da una delle stringhe di formato specificate formats dal parametro, ad eccezione del fatto che gli spazi vuoti iniziali e finali vengono ignorati.The TryParseExact(String, String[], IFormatProvider, TimeSpan) method parses the string representation of a time interval, which must be in the format defined by one of the format strings specified by the formats parameter, except that leading and trailing white-space characters are ignored. Questo metodo è simile al ParseExact(String, String[], IFormatProvider) metodo, ad eccezione del fatto che non genera un'eccezione se la conversione non riesce.This method is similar to the ParseExact(String, String[], IFormatProvider) method, except that it does not throw an exception if the conversion fails.

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 TryParseExact 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 TryParseExact 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

TryParseExact(String, String[], IFormatProvider, TimeSpanStyles, TimeSpan) TryParseExact(String, String[], IFormatProvider, TimeSpanStyles, TimeSpan) TryParseExact(String, String[], IFormatProvider, TimeSpanStyles, TimeSpan) TryParseExact(String, String[], IFormatProvider, TimeSpanStyles, TimeSpan)

Converte la rappresentazione di stringa specificata di un intervallo di tempo nell'equivalente TimeSpan usando i formati, le informazioni sul formato specifiche delle impostazioni cultura e gli stili specificati e restituisce un valore che indica se la conversione è stata eseguita correttamente.Converts the specified string representation of a time interval to its TimeSpan equivalent by using the specified formats, culture-specific format information, and styles, and returns a value that indicates whether the conversion succeeded. 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 bool TryParseExact(System::String ^ input, cli::array <System::String ^> ^ formats, IFormatProvider ^ formatProvider, System::Globalization::TimeSpanStyles styles, [Runtime::InteropServices::Out] TimeSpan % result);
public static bool TryParseExact (string input, string[] formats, IFormatProvider formatProvider, System.Globalization.TimeSpanStyles styles, out TimeSpan result);
static member TryParseExact : string * string[] * IFormatProvider * System.Globalization.TimeSpanStyles * TimeSpan -> bool
Public Shared Function TryParseExact (input As String, formats As String(), formatProvider As IFormatProvider, styles As TimeSpanStyles, ByRef result As TimeSpan) As Boolean

Parametri

input
String String String 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 personalizzato che definiscono i formati accettabili di input.A array of standard or custom format strings that define the acceptable formats of input.

formatProvider
IFormatProvider IFormatProvider IFormatProvider IFormatProvider

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

styles
TimeSpanStyles TimeSpanStyles TimeSpanStyles TimeSpanStyles

Uno o più valori di enumerazione che indicano lo stile di input.One or more enumeration values that indicate the style of input.

result
TimeSpan TimeSpan TimeSpan TimeSpan

Quando questo metodo viene restituito, contiene un oggetto che rappresenta l'intervallo di tempo specificato da input o Zero in caso di conversione non riuscita.When this method returns, contains an object that represents the time interval specified by input, or Zero if the conversion failed. Questo parametro viene passato non inizializzato.This parameter is passed uninitialized.

Restituisce

true se input è stato convertito correttamente; in caso contrario, false.true if input was converted successfully; otherwise, false.

Esempi

Nell'esempio seguente viene chiamato TryParseExact(String, String[], IFormatProvider, TimeSpanStyles, TimeSpan) il metodo per convertire ogni elemento di una matrice di stringhe TimeSpan in un valore.The following example calls the TryParseExact(String, String[], IFormatProvider, TimeSpanStyles, TimeSpan) 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("fr-FR");
      
      // Parse each string in inputs using formats and the fr-FR culture.
      foreach (string input in inputs) {
         if(TimeSpan.TryParseExact(input, formats, culture, 
                                   TimeSpanStyles.AssumeNegative, out interval))
            Console.WriteLine("{0} --> {1:c}", input, interval);
         else
            Console.WriteLine("Unable to parse {0}", input);   
      }
   }
}
// The example displays the following output:
//       3 --> -03:00:00
//       16:42 --> 16:42:00
//       Unable to parse 1:6:52:35.0625
//       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 fr-FR culture.
      For Each input As String In inputs
         If TimeSpan.TryParseExact(input, formats, culture, 
                                   TimeSpanStyles.AssumeNegative, interval) Then
            Console.WriteLine("{0} --> {1:c}", input, interval)   
         Else
            Console.WriteLine("Unable to parse {0}", input)   
         End If            
      Next
   End Sub
End Module
' The example displays the following output:
'       3 --> -03:00:00
'       16:42 --> 16:42:00
'       Unable to parse 1:6:52:35.0625
'       1:6:52:35,0625 --> 1.06:52:35.0625000

Commenti

Il TryParseExact(String, String[], IFormatProvider, TimeSpanStyles, TimeSpan) metodo analizza la rappresentazione di stringa di un intervallo di tempo, che deve essere nel formato definito da una delle stringhe di formato specificate formats dal parametro, ad eccezione del fatto che gli spazi vuoti iniziali e finali vengono ignorati.The TryParseExact(String, String[], IFormatProvider, TimeSpanStyles, TimeSpan) method parses the string representation of a time interval, which must be in the format defined by one of the format strings specified by the formats parameter, except that leading and trailing white-space characters are ignored. Questo metodo è simile al ParseExact(String, String[], IFormatProvider, TimeSpanStyles) metodo, ad eccezione del fatto che non genera un'eccezione se la conversione non riesce.This method is similar to the ParseExact(String, String[], IFormatProvider, TimeSpanStyles) method, except that it does not throw an exception if the conversion fails.

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

TryParseExact(ReadOnlySpan<Char>, String[], IFormatProvider, TimeSpan) TryParseExact(ReadOnlySpan<Char>, String[], IFormatProvider, TimeSpan) TryParseExact(ReadOnlySpan<Char>, String[], IFormatProvider, TimeSpan) TryParseExact(ReadOnlySpan<Char>, String[], IFormatProvider, TimeSpan)

public:
 static bool TryParseExact(ReadOnlySpan<char> input, cli::array <System::String ^> ^ formats, IFormatProvider ^ formatProvider, [Runtime::InteropServices::Out] TimeSpan % result);
public static bool TryParseExact (ReadOnlySpan<char> input, string[] formats, IFormatProvider formatProvider, out TimeSpan result);
static member TryParseExact : ReadOnlySpan<char> * string[] * IFormatProvider * TimeSpan -> bool
Public Shared Function TryParseExact (input As ReadOnlySpan(Of Char), formats As String(), formatProvider As IFormatProvider, ByRef result As TimeSpan) As Boolean

Parametri

formats
String[]

Restituisce

TryParseExact(ReadOnlySpan<Char>, ReadOnlySpan<Char>, IFormatProvider, TimeSpan) TryParseExact(ReadOnlySpan<Char>, ReadOnlySpan<Char>, IFormatProvider, TimeSpan) TryParseExact(ReadOnlySpan<Char>, ReadOnlySpan<Char>, IFormatProvider, TimeSpan) TryParseExact(ReadOnlySpan<Char>, ReadOnlySpan<Char>, IFormatProvider, TimeSpan)

public:
 static bool TryParseExact(ReadOnlySpan<char> input, ReadOnlySpan<char> format, IFormatProvider ^ formatProvider, [Runtime::InteropServices::Out] TimeSpan % result);
public static bool TryParseExact (ReadOnlySpan<char> input, ReadOnlySpan<char> format, IFormatProvider formatProvider, out TimeSpan result);
static member TryParseExact : ReadOnlySpan<char> * ReadOnlySpan<char> * IFormatProvider * TimeSpan -> bool
Public Shared Function TryParseExact (input As ReadOnlySpan(Of Char), format As ReadOnlySpan(Of Char), formatProvider As IFormatProvider, ByRef result As TimeSpan) As Boolean

Parametri

format
ReadOnlySpan<Char>

Restituisce

TryParseExact(String, String, IFormatProvider, TimeSpan) TryParseExact(String, String, IFormatProvider, TimeSpan) TryParseExact(String, String, IFormatProvider, TimeSpan) TryParseExact(String, String, IFormatProvider, TimeSpan)

Converte la rappresentazione di stringa di un intervallo di tempo nell'equivalente TimeSpan usando il formato specificato e le informazioni sul formato specifiche delle impostazioni cultura e restituisce un valore che indica se la conversione è stata eseguita correttamente.Converts the string representation of a time interval to its TimeSpan equivalent by using the specified format and culture-specific format information, and returns a value that indicates whether the conversion succeeded. 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 bool TryParseExact(System::String ^ input, System::String ^ format, IFormatProvider ^ formatProvider, [Runtime::InteropServices::Out] TimeSpan % result);
public static bool TryParseExact (string input, string format, IFormatProvider formatProvider, out TimeSpan result);
static member TryParseExact : string * string * IFormatProvider * TimeSpan -> bool
Public Shared Function TryParseExact (input As String, format As String, formatProvider As IFormatProvider, ByRef result As TimeSpan) As Boolean

Parametri

input
String String String String

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

format
String String String 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 IFormatProvider IFormatProvider IFormatProvider

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

result
TimeSpan TimeSpan TimeSpan TimeSpan

Quando questo metodo viene restituito, contiene un oggetto che rappresenta l'intervallo di tempo specificato da input o Zero in caso di conversione non riuscita.When this method returns, contains an object that represents the time interval specified by input, or Zero if the conversion failed. Questo parametro viene passato non inizializzato.This parameter is passed uninitialized.

Restituisce

true se input è stato convertito correttamente; in caso contrario, false.true if input was converted successfully; otherwise, false.

Esempi

Nell'esempio seguente viene usato TryParseExact(String, String, IFormatProvider, TimeSpanStyles, TimeSpan) il metodo per analizzare più rappresentazioni di stringa di intervalli temporali usando varie stringhe di formato e impostazioni cultura.The following example uses the TryParseExact(String, String, IFormatProvider, TimeSpanStyles, TimeSpan) 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;
      if (TimeSpan.TryParseExact(intervalString, format, culture, out interval))
         Console.WriteLine("'{0}' --> {1}", intervalString, interval);
      else
         Console.WriteLine("Unable to parse {0}", intervalString);
      
      // Parse hour:minute:second value with "G" specifier.
      intervalString = "17:14:48";
      format = "G";
      culture = CultureInfo.InvariantCulture;
      if (TimeSpan.TryParseExact(intervalString, format, culture, out interval))
         Console.WriteLine("'{0}' --> {1}", intervalString, interval);
      else
         Console.WriteLine("Unable to parse {0}", intervalString);
      
      // Parse hours:minute.second value with "G" specifier 
      // and current (en-US) culture.     
      intervalString = "17:14:48.153";
      format = "G";
      culture = CultureInfo.CurrentCulture;
      if (TimeSpan.TryParseExact(intervalString, format, culture, out interval))
         Console.WriteLine("'{0}' --> {1}", intervalString, interval);
      else
         Console.WriteLine("Unable to parse {0}", 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;
      if (TimeSpan.TryParseExact(intervalString, format, culture, out interval))
         Console.WriteLine("'{0}' --> {1}", intervalString, interval);
      else
         Console.WriteLine("Unable to parse {0}", 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");
      if (TimeSpan.TryParseExact(intervalString, format, culture, out interval))
         Console.WriteLine("'{0}' --> {1}", intervalString, interval);
      else
         Console.WriteLine("Unable to parse {0}", intervalString);
      
      // Parse days:hours:minute.second value with "G" specifier 
      // and fr-FR culture.     
      intervalString = "3:17:14:48,153";
      format = "G";
      if (TimeSpan.TryParseExact(intervalString, format, culture, out interval))
         Console.WriteLine("'{0}' --> {1}", intervalString, interval);
      else
         Console.WriteLine("Unable to parse {0}", intervalString);

      // Parse a single number using the "c" standard format string. 
      intervalString = "12";
      format = "c";
      if (TimeSpan.TryParseExact(intervalString, format, null, out interval))
         Console.WriteLine("'{0}' --> {1}", intervalString, interval);
      else
         Console.WriteLine("Unable to parse {0}", intervalString);
      
      // Parse a single number using the "%h" custom format string. 
      format = "%h";
      if (TimeSpan.TryParseExact(intervalString, format, null, out interval))
         Console.WriteLine("'{0}' --> {1}", intervalString, interval);
      else
         Console.WriteLine("Unable to parse {0}", intervalString);
      
      // Parse a single number using the "%s" custom format string. 
      format = "%s";
      if (TimeSpan.TryParseExact(intervalString, format, null, out interval))
         Console.WriteLine("'{0}' --> {1}", intervalString, interval);
      else
         Console.WriteLine("Unable to parse {0}", intervalString);
   }
}
// The example displays the following output:
//       '17:14' --> 17:14:00
//       Unable to parse 17:14:48
//       Unable to parse 17:14:48.153
//       '3:17:14:48.153' --> 3.17:14:48.1530000
//       Unable to parse 3:17:14:48.153
//       '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
      If TimeSpan.TryParseExact(intervalString, format, culture, interval) Then
         Console.WriteLine("'{0}' --> {1}", intervalString, interval)
      Else
         Console.WriteLine("Unable to parse {0}", intervalString)
      End If
      
      ' Parse hour:minute:second value with "G" specifier.
      intervalString = "17:14:48"
      format = "G"
      culture = CultureInfo.InvariantCulture
      If TimeSpan.TryParseExact(intervalString, format, culture, interval) Then
         Console.WriteLine("'{0}' --> {1}", intervalString, interval)
      Else
         Console.WriteLine("Unable to parse {0}", intervalString)
      End If

      ' Parse hours:minute.second value with "G" specifier 
      ' and current (en-US) culture.     
      intervalString = "17:14:48.153"
      format = "G"
      culture = CultureInfo.CurrentCulture
      If TimeSpan.TryParseExact(intervalString, format, culture, interval) Then
         Console.WriteLine("'{0}' --> {1}", intervalString, interval)
      Else
         Console.WriteLine("Unable to parse {0}", intervalString)
      End If

      ' 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
      If TimeSpan.TryParseExact(intervalString, format, culture, interval) Then
         Console.WriteLine("'{0}' --> {1}", intervalString, interval)
      Else
         Console.WriteLine("Unable to parse {0}", intervalString)
      End If
            
      ' 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")
      If TimeSpan.TryParseExact(intervalString, format, culture, interval) Then
         Console.WriteLine("'{0}' --> {1}", intervalString, interval)
      Else
         Console.WriteLine("Unable to parse {0}", intervalString)
      End If
      
      ' 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")
      If TimeSpan.TryParseExact(intervalString, format, culture, interval) Then
         Console.WriteLine("'{0}' --> {1}", intervalString, interval)
      Else
         Console.WriteLine("Unable to parse {0}", intervalString)
      End If

      ' Parse a single number using the "c" standard format string. 
      intervalString = "12"
      format = "c"
      If TimeSpan.TryParseExact(intervalString, format, Nothing, interval)
         Console.WriteLine("'{0}' --> {1}", intervalString, interval)
      Else
         Console.WriteLine("Unable to parse {0}", intervalString)
      End If
      
      ' Parse a single number using the "%h" custom format string. 
      format = "%h"
      If TimeSpan.TryParseExact(intervalString, format, Nothing, interval)
         Console.WriteLine("'{0}' --> {1}", intervalString, interval)
      Else
         Console.WriteLine("Unable to parse {0}", intervalString)
      End If
      
      ' Parse a single number using the "%s" custom format string. 
      format = "%s"
      If TimeSpan.TryParseExact(intervalString, format, Nothing, interval) Then
         Console.WriteLine("'{0}' --> {1}", intervalString, interval)
      Else
         Console.WriteLine("Unable to parse {0}", intervalString)
      End If
   End Sub
End Module
' The example displays the following output:
'       '17:14' --> 17:14:00
'       Unable to parse 17:14:48
'       Unable to parse 17:14:48.153
'       '3:17:14:48.153' --> 3.17:14:48.1530000
'       Unable to parse 3:17:14:48.153
'       '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 TryParseExact(String, String, IFormatProvider, TimeSpan) 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 TryParseExact(String, String, IFormatProvider, TimeSpan) 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. Questo metodo è simile al ParseExact(String, String, IFormatProvider) metodo, ad eccezione del fatto che non genera un'eccezione se la conversione non riesce.This method is similar to the ParseExact(String, String, IFormatProvider) method, except that it does not throw an exception if the conversion fails.

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 TryParseExact(String, String, IFormatProvider, TimeSpan) 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 TryParseExact(String, String, IFormatProvider, TimeSpan) 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

Si applica a