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.ParseExact (String, String, IFormatProvider)

 

Data di pubblicazione: ottobre 2016

Converte la rappresentazione di stringa di un intervallo di tempo nell'equivalente TimeSpan usando le informazioni sul formato specifiche delle impostazioni cultura indicate. Il formato della rappresentazione di stringa deve corrispondere esattamente al formato specificato.

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

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

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.

Valore restituito

Type: System.TimeSpan

Intervallo di tempo che corrisponde a input, come specificato da format e formatProvider.

Exception Condition
ArgumentNullException

input è null.

FormatException

Il formato di input non è valido.

OverflowException

input rappresenta un numero minore di TimeSpan.MinValue o maggiore di TimeSpan.MaxValue.

-oppure-

Almeno uno dei componenti giorni, ore, minuti o secondi in input non rientra nell'intervallo valido.

Il ParseExact(String, String, IFormatProvider) 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. Poiché input deve essere conforme al formato di format esattamente, è necessario utilizzare sempre la gestione delle eccezioni durante la conversione di una stringa in input dall'utente in un intervallo di tempo. Se si preferisce non utilizzare la gestione delle eccezioni, è possibile chiamare la TryParseExact(String, String, IFormatProvider, TimeSpan) metodo invece.

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.

System_CAPS_importantImportante

Il ParseExact metodo utilizza le convenzioni delle impostazioni cultura specificate per il formatProvider parametro solo se format è uno standard TimeSpan il cui valore è "g" o "G" stringa di formato. Stringhe di formato standard "T", "c" e "t" utilizzano le convenzioni di formattazione delle impostazioni cultura invarianti. Stringhe di formato personalizzate definiscono il formato preciso della stringa di input e utilizzano i caratteri letterali per separare i componenti di un intervallo di tempo.

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.

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.

using System;
using System.Globalization;

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

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

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

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

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

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

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

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

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

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

Universal Windows Platform
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: