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)

.NET Framework (current version)
 

Converte a representação de cadeia de caracteres de um intervalo de hora em seu equivalente de TimeSpan usando o formato e as informações de formato específicas da cultura especificadas. O formato de 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
)

Parâmetros

input
Type: System.String

Uma cadeia de caracteres que especifica o intervalo de tempo a ser convertido.

format
Type: System.String

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

formatProvider
Type: System.IFormatProvider

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

Valor Retornado

Type: System.TimeSpan

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

Exception Condition
ArgumentNullException

input é null.

FormatException

input tem um formato inválido.

OverflowException

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

-ou-

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

O ParseExact(String, String, IFormatProvider) método analisa a representação de cadeia de caracteres de um intervalo de tempo deve estar no formato definido pelo format parâmetro, exceto que à esquerda e caracteres de espaço em branco à direita são ignorados. Porque input devem estar em conformidade com o formato de format exatamente, você sempre deve 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, TimeSpan) método em vez disso.

O parâmetro format é uma cadeia de caracteres que contém um único especificador de formato padrão ou um ou mais especificadores de formato que definem o formato exigido 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 de cultura especificado pelo formatProvider parâmetro somente se format é um padrão TimeSpan formato de cadeia de caracteres cujo valor é "g" ou "G". As cadeias de caracteres de formato padrão "c", "t" e "T" usam as convenções de formatação da cultura invariável. As 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 parâmetro formatProvider é uma implementação de IFormatProvider que fornece informações específicas de cultura sobre o formato da cadeia de caracteres retornado caso format seja uma cadeia de caracteres de formato padrão. O parâmetro formatProvider pode ser um dos seguintes:

Caso formatProvider seja null, o objeto DateTimeFormatInfo que está associado à cultura atual é usado.

O exemplo a seguir usa a 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.

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

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: