Este artigo foi traduzido por máquina. Para visualizar o arquivo em inglês, marque a caixa de seleção Inglês. Você também pode exibir o texto Em inglês em uma janela pop-up, movendo o ponteiro do mouse sobre o texto.
Tradução
Inglês

Método TimeSpan.ParseExact (String, String, IFormatProvider, TimeSpanStyles)

.NET Framework (current version)
 

Converte a representação de cadeia de caracteres de um intervalo de tempo para seu TimeSpan equivalente usando o formato especificado, informações de formato específicas da cultura e estilos. O formato da representação da cadeia de caracteres deve corresponder exatamente ao formato especificado.

Namespace:   System
Assembly:  mscorlib (em mscorlib.dll)

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

Parâmetros

input
Type: System.String

Uma cadeia de caracteres que especifica o intervalo de tempo para converter.

format
Type: System.String

Uma cadeia de caracteres de formato padrão ou personalizado que define o formato obrigatório de input.

formatProvider
Type: System.IFormatProvider

Um objeto que fornece informações de formatação específicas da cultura.

styles
Type: System.Globalization.TimeSpanStyles

Uma combinação bit a bit dos valores de enumeração que define os elementos de estilo que podem estar presentes no input.

Valor Retornado

Type: System.TimeSpan

Um intervalo de tempo que corresponde a input, conforme especificado por format, formatProvider, e styles.

Exception Condition
ArgumentException

styles é inválido TimeSpanStyles valor.

ArgumentNullException

input é null.

FormatException

input tem um formato inválido.

OverflowException

input representa um número que seja menor que TimeSpan.MinValue ou maior que TimeSpan.MaxValue.

- ou -

Pelo menos um dos dias, horas, minutos ou componentes de segundos em input está fora do intervalo válido.

O ParseExact método analisa a representação de cadeia de caracteres de um intervalo de tempo que deve estar no formato definido pelo format parâmetro, exceto que líderes e caracteres de espaço em branco à direita são ignorados. Porque input deve seguir o formato do format exatamente, você deve sempre usar tratamento de exceções ao converter uma entrada de cadeia de caracteres pelo usuário em um intervalo de tempo. Se você preferir não usar tratamento de exceções, você pode chamar o TryParseExact(String, String, IFormatProvider, TimeSpanStyles, TimeSpan) método em vez disso.

O format parâmetro é uma cadeia de caracteres que contém um especificador de formato único padrão ou um ou mais especificadores de formato personalizado que definem o formato obrigatório de input. Para obter mais informações sobre cadeias de caracteres de formato válido, consulte Cadeias de caracteres de formato TimeSpan padrão e Cadeias de caracteres de formato TimeSpan personalizado.

System_CAPS_importantImportante

O ParseExact método usa as convenções da cultura especificada pelo formatProvider parâmetro somente se format é um padrão TimeSpan formato de cadeia de caracteres cujo valor é "g" ou "G". Cadeias de caracteres de formato padrão "T", "c" e "t" usam as convenções de formatação da cultura invariável. Cadeias de caracteres de formato personalizado definem o formato preciso da cadeia de caracteres de entrada e usam caracteres literais para separar os componentes de um intervalo de tempo.

O formatProvider parâmetro é um IFormatProvider implementação que fornece informações específicas da cultura sobre o formato de cadeia de caracteres retornada se format é uma cadeia de caracteres de formato padrão. O formatProvider parâmetro pode ser qualquer um dos seguintes:

Se formatProvider for null, o DateTimeFormatInfo objeto que está associado com a cultura atual é usado.

O styles parâmetro afeta a interpretação de cadeias de caracteres que são analisados usando cadeias de caracteres de formato personalizado. Determina se input é interpretado como um intervalo de tempo negativo somente se houver um sinal negativo (TimeSpanStyles.None), ou se ele sempre será interpretado como um intervalo de tempo negativo (TimeSpanStyles.AssumeNegative). Se TimeSpanStyles.AssumeNegative não for usado, format deve incluir um símbolo de sinal negativo literal (como "\-") para analisar com êxito um intervalo de tempo negativo.

O exemplo a seguir usa o ParseExact(String, String, IFormatProvider) método analisar várias representações de cadeia de caracteres de intervalos de tempo usando várias cadeias de caracteres de formato e culturas. Ele também usa o TimeSpanStyles.AssumeNegative valor interpretar cada cadeia de caracteres como um intervalo de tempo negativo. A saída do exemplo ilustra que a TimeSpanStyles.AssumeNegative estilo afeta o valor de retorno apenas quando ele é usado com cadeias de caracteres de formato personalizado.

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

Plataforma Universal do Windows
Disponível desde 8
.NET Framework
Disponível desde 4.0
Biblioteca de Classes Portátil
Com suporte no: plataformas portáteis do .NET
Silverlight
Disponível desde 4.0
Windows Phone Silverlight
Disponível desde 7.1
Windows Phone
Disponível desde 8.1
Retornar ao início
Mostrar: