Questo articolo è stato tradotto automaticamente. Per visualizzare l'articolo in inglese, selezionare la casella di controllo Inglese. È possibile anche visualizzare il testo inglese in una finestra popup posizionando il puntatore del mouse sopra il testo.
Traduzione
Inglese

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

 

Data di pubblicazione: ottobre 2016

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. Il formato della rappresentazione di stringa deve corrispondere esattamente al formato specificato.

Spazio dei nomi:   System
Assembly:  mscorlib (in mscorlib.dll)

public static bool TryParseExact(
	string input,
	string format,
	IFormatProvider formatProvider,
	TimeSpanStyles styles,
	out TimeSpan result
)

Parametri

input
Type: System.String

Stringa che specifica l'intervallo di tempo da convertire.

format
Type: System.String

Stringa di formato standard o personalizzato che definisce il formato richiesto di input.

formatProvider
Type: System.IFormatProvider

Oggetto che fornisce informazioni di formattazione specifiche delle impostazioni cultura.

styles
Type: System.Globalization.TimeSpanStyles

Uno o più valori di enumerazione che indicano lo stile di input.

result
Type: System.TimeSpan

Quando questo metodo viene restituito, contiene un oggetto che rappresenta l'intervallo di tempo specificato da input o TimeSpan.Zero in caso di conversione non riuscita. Questo parametro viene passato non inizializzato.

Valore restituito

Type: System.Boolean

true se input è stato convertito correttamente; in caso contrario, false.

Il TryParseExact(String, String, IFormatProvider, TimeSpanStyles, TimeSpan) metodo analizza la rappresentazione di stringa di un intervallo di tempo che deve essere nel formato definito per il format parametro, ad eccezione del fatto che gli e gli spazi vuoti finali vengono ignorati. Questo metodo è simile al ParseExact(String, String, IFormatProvider, TimeSpanStyles) metodo, ad eccezione del fatto che non genera un'eccezione se la conversione non riesce.

Il format parametro è una stringa che contiene un identificatore di formato standard singolo o uno o più identificatori di formato personalizzate che definiscono il formato richiesto di input. Per ulteriori informazioni sulle stringhe di formato valido, vedere Stringhe di formato TimeSpan standard e Stringhe di formato TimeSpan personalizzate.

Il formatProvider parametro è un IFormatProvider implementazione che fornisce informazioni specifiche delle impostazioni cultura sul formato della stringa restituita se format è una stringa di formato standard. Il formatProvider parametro può essere uno dei seguenti:

Se formatProvider è null, DateTimeFormatInfo viene utilizzato l'oggetto associato con le impostazioni cultura correnti.

Il styles parametro influisce sull'interpretazione delle stringhe analizzate tramite stringhe di formato personalizzata. 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). Se TimeSpanStyles.AssumeNegative non viene utilizzato, format deve includere un simbolo di segno negativo letterale (ad esempio "\-") per analizzare correttamente un intervallo di tempo negativo.

L'esempio seguente usa il ParseExact(String, String, IFormatProvider) metodo analizzare varie rappresentazioni di stringa di intervalli di tempo utilizzando diverse stringhe di formato e le impostazioni cultura. Utilizza inoltre il TimeSpanStyles.AssumeNegative valore interpreti ogni stringa come un intervallo di tempo negativo. L'output dell'esempio mostra che il TimeSpanStyles.AssumeNegative stile influisce sul valore restituito solo quando viene utilizzato con stringhe di formato personalizzata.

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

Universal Windows Platform
Disponibile da 8
.NET Framework
Disponibile da 4.0
Libreria di classi portabile
Supportato in: piattaforme .NET portabili
Silverlight
Disponibile da 4.0
Windows Phone Silverlight
Disponibile da 7.1
Windows Phone
Disponibile da 8.1
Torna all'inizio
Mostra: