Esta página foi útil?
Seus comentários sobre este conteúdo são importantes. Queremos saber sua opinião.
Comentários adicionais?
1500 caracteres restantes
Exportar (0) Imprimir
Expandir Tudo
Este artigo foi traduzido por máquina. Coloque o ponteiro do mouse sobre as frases do artigo para ver o texto original. Mais informações.
Tradução
Original
Importante Este documento pode não descrever as práticas recomendadas para o desenvolvimento atual, links para downloads e outros recursos podem não ser mais válidos. A versão atual recomendada pode ser encontrada aqui.

Sequências de Caracteres de Formato Numérico Padrão

Sequências de Caracteres de Formatação Numérica Padrão são usadas para formatar tipos numéricos comuns. Uma sequência de caracteres de formato numérico padrão assume a forma Axx, onde A é um caractere alfabético chamado de especificador de formato e xx é um inteiro opcional chamado de especificador de precisão. O especificador de precisão varia de 0 a 99 e afeta o número de dígitos no resultado. Qualquer sequência de caracteres de formato numérico que contenha mais de um caractere alfabético, incluindo espaço em branco, é interpretada como uma sequência de formato numérico personalizado.

A tabela a seguir descreve os especificadores de formato numérico padrão e exibe exemplos de saída produzidas por cada especificador de formato. Para obter mais informações, consulte as notas que seguem a tabela.

Especificador de Formato

Nome

Descrição

C ou c

Moeda

O número é convertido para uma sequência que representa um valor de moeda. A conversão é controlada pelas informações de formato da moeda do objeto NumberFormatInfo atual.

O especificador de precisão indica o número de casas decimais desejadas. Se o especificador deprecisão for omitido, a precisão de moeda padrão fornecida pelo objeto NumberFormatInfo atual será usada.

O exemplo a seguir formata um valor Double com o especificador de formato de moeda.

double value = 12345.6789;
Console.WriteLine(value.ToString("C", CultureInfo.InvariantCulture));
// Displays 12,345.68 

Console.WriteLine(value.ToString("C3", CultureInfo.InvariantCulture));
// Displays 12,345.679

Console.WriteLine(value.ToString("C3", 
                  CultureInfo.CreateSpecificCulture("en-US")));
// Displays $12,345.679


D ou d

Decimal

Esse formato é suportado apenas para tipos inteiros. O número é convertido para uma sequência de dígitos decimais (0-9), prefixados por um sinal de menos se o número for negativo.

O especificador de precisão indica o número mínimo de dígitos desejados na sequência resultante. Se necessário, o número é preenchido com zeros à esquerda para produzir o número de dígitos fornecido pelo especificador de precisão.

O exemplo a seguir formata um valor Int32 com o especificador de formato decimal.

int value; 

value = 12345;
Console.WriteLine(value.ToString("D"));
// Displays 12345
Console.WriteLine(value.ToString("D8"));
// Displays 00012345

value = -12345;
Console.WriteLine(value.ToString("D"));
// Displays -12345
Console.WriteLine(value.ToString("D8"));
// Displays -00012345


E ou e

Científica (exponencial)

O número é convertido em uma sequência de caracteres do formulário "-d.ddd…E+ddd" ou "-d.ddd…e+ddd", onde cada seria 'd' indica um dígito (0-9). A sequência inicia com um sinal de menos se o número for negativo. Um dígito sempre precede a ponto decimal.

O especificador de precisão indica o número desejado de dígitos após o ponto decimal. Se o especificador de precisão for omitido, um padrão de seis dígitos após o ponto decimal é usado.

A caixa do especificador de formato indica se o expoente for prefixado com um 'E' ou um 'e'. O expoente sempre é constituído de um sinal de mais ou de menos e um mínimo de três dígitos. O exponente é preenchido com zeros para atender esse mínimo, se necessário.

O exemplo a seguir formata um valor Double com o especificador de formato científico.

double value = 12345.6789;
Console.WriteLine(value.ToString("E", CultureInfo.InvariantCulture));
// Displays 1.234568E+004

Console.WriteLine(value.ToString("E10", CultureInfo.InvariantCulture));
// Displays 1.2345678900E+004

Console.WriteLine(value.ToString("e4", CultureInfo.InvariantCulture));
// Displays 1.2346e+004

Console.WriteLine(value.ToString("E", 
                  CultureInfo.CreateSpecificCulture("fr-FR")));
// Displays 1,234568E+004


F ou f

Ponto fixo

O número é convertido em uma sequência de caracteres do formulário "-ddd.ddd…" onde cada 'd' indica um dígito (0-9). A sequência inicia com um sinal de menos se o número for negativo.

O especificador de precisão indica o número de casas decimais desejadas. Se o especificador de precisão for omitido, a precisão numérica padrão é dada pela propriedade NumberDecimalDigits do objeto NumberFormatInfo atual.

O exemplo a seguir formata um valor Double e um valor Int32 com o especificador de formato de ponto fixo.

int integerNumber;
integerNumber = 17843;
Console.WriteLine(integerNumber.ToString("F", 
                  CultureInfo.InvariantCulture));
// Displays 17843.00

integerNumber = -29541;
Console.WriteLine(integerNumber.ToString("F3", 
                  CultureInfo.InvariantCulture));
// Displays -29541.000

double doubleNumber;
doubleNumber = 18934.1879;
Console.WriteLine(doubleNumber.ToString("F", CultureInfo.InvariantCulture));
// Displays 18934.19

Console.WriteLine(doubleNumber.ToString("F0", CultureInfo.InvariantCulture));
// Displays 18934

doubleNumber = -1898300.1987;
Console.WriteLine(doubleNumber.ToString("F1", CultureInfo.InvariantCulture));  
// Displays -1898300.2

Console.WriteLine(doubleNumber.ToString("F3", 
                  CultureInfo.CreateSpecificCulture("es-ES")));
// Displays -1898300,199                        


G ou g

Geral

O número é convertido para a notação de ponto fixo ou científica que seja mais compacta, dependendo do tipo do número e se um especificador de precisão está presente. Se o especificador de precisão for omitido ou for zero, o tipo do número determina a precisão padrão, conforme indicado pela lista a seguir.

A notação de ponto fixo é usada se o expoente que resultaria ao expressar o número na notação científica é maior do que -5 e menor que o especificador de precisão; caso contrário, a notação científica é usada. Se necessário, o resultado contém um ponto decimal e os zeros à direita são omitidos. Se o especificador de precisão estiver presente e o número de dígitos significativos no resultado excede a precisão especificada, então o excesso de dígitos à direita será removido por arredondamento.

A exceção à regra anterior é se o número for um Decimal e o especificador de padrão for omitido. Nesse caso, a notação de ponto fixo é sempre usada e zeros à direita são preservados.

Se a notação científica for usada, o expoente no resultado é prefixado com 'E' se o especificador de formato for 'G', ou 'e' se o especificador de formato é 'g'.

O exemplo a seguir formata valores de ponto flutuante variados com o especificador de formato geral.

double number;

number = 12345.6789;      
Console.WriteLine(number.ToString("G", CultureInfo.InvariantCulture));
// Displays  12345.6789
Console.WriteLine(number.ToString("G", 
                  CultureInfo.CreateSpecificCulture("fr-FR")));
// Displays 12345,6789

Console.WriteLine(number.ToString("G7", CultureInfo.InvariantCulture));
// Displays 12345.68 

number = .0000023;
Console.WriteLine(number.ToString("G", CultureInfo.InvariantCulture));
// Displays 2.3E-06       
Console.WriteLine(number.ToString("G", 
                  CultureInfo.CreateSpecificCulture("fr-FR")));
// Displays 2,3E-06

number = .0023;
Console.WriteLine(number.ToString("G", CultureInfo.InvariantCulture));
// Displays 0.0023

number = 1234;
Console.WriteLine(number.ToString("G2", CultureInfo.InvariantCulture));
// Displays 1.2E+03

number = Math.PI;
Console.WriteLine(number.ToString("G5", CultureInfo.InvariantCulture));
// Displays 3.1416    


N ou n

Número

O número é convertido em uma sequência de caracteres do formulário "-d,ddd,ddd.ddd…", onde '-' indica um símbolo de número negativo, se necessário, 'd' indica um dígito (0-9), ',' indica um separador de milhar entre grupos de número, e '.' indica um símbolo de ponto decimal. O padrão de número negativo real, tamanho do grupo numérico, separador de milhar e separador decimal são especificados pelas propriedades NumberNegativePattern,NumberGroupSizes,NumberGroupSeparator e NumberDecimalSeparator, respectivamente, do objetoNumberFormatInfo atual.

O especificador de precisão indica o número de casas decimais desejadas. Se o especificador de precisão for omitido, a precisão numérica padrão é dada pela propriedade NumberDecimalDigits do objeto NumberFormatInfo atual.

O exemplo a seguir formata valores de ponto flutuante variados com o especificador de formato numérico.

double dblValue = -12445.6789;
Console.WriteLine(dblValue.ToString("N", CultureInfo.InvariantCulture));
// Displays -12,445.68
Console.WriteLine(dblValue.ToString("N1", 
                  CultureInfo.CreateSpecificCulture("sv-SE")));
// Displays -12445,7

int intValue = 123456789;
Console.WriteLine(intValue.ToString("N1", CultureInfo.InvariantCulture));
// Displays 123,456,789.0 


P ou p

Porcentagem

O número é convertido em uma sequência de caracteres que representa um porcentagem conforme definido pela propriedade NumberFormatInfo.PercentNegativePattern se o número for negativo, ou pela propriedade NumberFormatInfo.PercentPositivePattern se o número for positivo. O número convertido é multiplicado por 100 para ser apresentado como uma porcentagem.

O especificador de precisão indica o número de casas decimais desejadas. Se o especificador deprecisão for omitido, a precisão numérica padrão fornecida pelo objeto NumberFormatInfo atual será usada.

O exemplo a seguir formata valores de ponto flutuante variados com o especificador de formato de percentagem.

double number = .2468013;
Console.WriteLine(number.ToString("P", CultureInfo.InvariantCulture));
// Displays 24.68 %
Console.WriteLine(number.ToString("P", 
                  CultureInfo.CreateSpecificCulture("hr-HR")));
// Displays 24,68%     
Console.WriteLine(number.ToString("P1", CultureInfo.InvariantCulture));
// Displays 24.7 %


R ou r

Processamento

Esse formato é suportado apenas para os tipos Single e Double. Especificador de processamento garante que um valor numérico convertido em uma sequência de caracteres será analisado de volta ao mesmo valor numérico. Quando um valor numérico é formatado usando esse especificador, ele é primeiro testado usando o formato geral, com 15 espaços de precisão para um Double e 7 espaços de precisão para um Single . Se o valor é analisado com êxito de volta ao mesmo valor numérico, ele é formatado usando o especificador de formato geral. No entanto, se o valor é analisado com êxito de volta para o mesmo valor numérico, em seguida, o valor é formatado usando 17 dígitos de precisão para um Double e 9 dígitos de precisão para um Single .

Embora um especificador de precisão possa estar presente, ele será ignorado. O processamento recebe precedência sobre a precisão ao usar esse especificador.

O exemplo a seguir formata valores Double com o especificador de formato de processamento.

double value;

value = Math.PI;
Console.WriteLine(value.ToString("r"));
// Displays 3.1415926535897931
Console.WriteLine(value.ToString("r", 
                  CultureInfo.CreateSpecificCulture("fr-FR")));
// Displays 3,1415926535897931
value = 1.623e-21;
Console.WriteLine(value.ToString("r"));
// Displays 1.623E-21


X ou x

Hexadecimal

Esse formato é suportado apenas para tipos inteiros. O número é convertido para uma sequência de dígitos hexadecimais. No caso do especificador de formato indica se é necessário usar caracteres maiúsculos ou minúsculos para os dígitos hexadecimais maiores que 9. Por exemplo, use 'X' para produzir "ABCDEF" e 'x' para produzir "abcdef".

O especificador de precisão indica o número mínimo de dígitos desejados na sequência resultante. Se necessário, o número é preenchido com zeros à esquerda para produzir o número de dígitos fornecido pelo especificador de precisão.

O exemplo a seguir formata valores Int32 com o especificador de formato hexadecimal.

int value; 

value = 0x2045e;
Console.WriteLine(value.ToString("x"));
// Displays 2045e
Console.WriteLine(value.ToString("X"));
// Displays 2045E
Console.WriteLine(value.ToString("X8"));
// Displays 0002045E

value = 123456789;
Console.WriteLine(value.ToString("X"));
// Displays 75BCD15
Console.WriteLine(value.ToString("X2"));
// Displays 75BCD15


Qualquer outro caractere único

(Especificador desconhecido)

(Um especificador desconhecido gera uma FormatException em tempo de execução.)

Configurações do Painel de controle

As configurações no item Opções regionais e de idioma no Painel de Controle influenciam a sequência de resultado produzida por uma operação de formatação. Essas configurações são usadas para inicializar o objeto NumberFormatInfo associado a cultura de segmento atual, que fornece valores usados para controlar a formatação. Computadores usando configurações diferentes vão gerar diferentes sequências de caracteres como resultado.

Além disso, se o construtor CultureInfo.CultureInfo(String) for usado para criar uma instância de um novo objeto CultureInfo que representa a mesma cultura que a cultura atual do sistema, quaisquer personalizações estabelecidas pelo item Opções Regionais e de Idioma no Painel de controle serão aplicadas ao novo objeto CultureInfo. Você pode usar o método CultureInfo.CreateSpecificCulture para criar um CultureInfo que não reflita a adaptações de um sistema.

Propriedades de NumberFormatInfo

A formatação é influenciada pelas propriedades do objeto NumberFormatInfo atual, que é fornecido implicitamente pela cultura de segmento atual ou explicitamente pelo parâmetro IFormatProvider do método que invoca a formatação. Especifique um objeto NumberFormatInfo ou CultureInfo para esse parâmetro.

Tipos numéricos inteiros e pontos flutuantes

Algumas descrições dos especificadores de formato numérico padrão se referem a tipos inteiros ou de ponto flutuante. Os tipos numéricos de inteiros são Byte, SByte, Int16, Int32, Int64, UInt16, UInt32 e UInt64. Os tipos numéricos de ponto flutuante são Decimal, Single e Double.

Pontos Flutuantes Infinitos e NaN (Não Números)

Observe que, independentemente da sequência de caracteres de formato, se o valor de um tipo ponto flutuante éSingle ou Double infinito positivo, negativo infinito ou um não número (NaN), a sequência de caracteres formatada é o valor das respectivas propriedades PositiveInfinitySymbol os respectivos, NegativeInfinitySymbol ou NaNSymbol especificada pelo objeto NumberFormatInfo aplicável no momento.

O exemplo a seguir formata um inteiro e um valor numérico de ponto flutuante usando a cultura en-us e todos os especificadores de formato numérico padrão. Este exemplo usa dois tipos numéricos específicos, mas poderia produzir resultados semelhantes para qualquer um dos tipos base numéricos (Byte,SByte,Int16,Int32,Int64,UInt16,UInt32,UInt64,Decimal,Single e Double).

using System;
using System.Globalization;
using System.Threading;

public class NumericFormats
{
   public static void Main()
   {
      // Display string representations of numbers for en-us culture
      CultureInfo ci = new CultureInfo("en-us");

      // Output floating point values
      double floating = 10761.937554;
      Console.WriteLine("C: {0}", 
              floating.ToString("C", ci));           // Displays "C: $10,761.94"
      Console.WriteLine("E: {0}", 
              floating.ToString("E03", ci));         // Displays "E: 1.076E+004"
      Console.WriteLine("F: {0}", 
              floating.ToString("F04", ci));         // Displays "F: 10761.9376"         
      Console.WriteLine("G: {0}",  
              floating.ToString("G", ci));           // Displays "G: 10761.937554"
      Console.WriteLine("N: {0}", 
              floating.ToString("N03", ci));         // Displays "N: 10,761.938"
      Console.WriteLine("P: {0}", 
              (floating/10000).ToString("P02", ci)); // Displays "P: 107.62 %"
      Console.WriteLine("R: {0}", 
              floating.ToString("R", ci));           // Displays "R: 10761.937554"            
      Console.WriteLine();

      // Output integral values
      int integral = 8395;
      Console.WriteLine("C: {0}", 
              integral.ToString("C", ci));           // Displays "C: $8,395.00"
      Console.WriteLine("D: {0}", 
              integral.ToString("D6", ci));          // Displays D: 008395"" 
      Console.WriteLine("E: {0}", 
              integral.ToString("E03", ci));         // Displays "E: 8.395E+003"
      Console.WriteLine("F: {0}", 
              integral.ToString("F01", ci));         // Displays "F: 8395.0"    
      Console.WriteLine("G: {0}",  
              integral.ToString("G", ci));           // Displays "G: 8395"
      Console.WriteLine("N: {0}", 
              integral.ToString("N01", ci));         // Displays "N: 8,395.0"
      Console.WriteLine("P: {0}", 
              (integral/10000).ToString("P02", ci)); // Displays "P: 83.95 %"
      Console.WriteLine("X: 0x{0}", 
              integral.ToString("X", ci));           // Displays "X: 0x20CB"
      Console.WriteLine();
   }
}


Contribuições da comunidade

ADICIONAR
A Microsoft está realizando uma pesquisa online para saber sua opinião sobre o site do MSDN. Se você optar por participar, a pesquisa online lhe será apresentada quando você sair do site do MSDN.

Deseja participar?
Mostrar:
© 2015 Microsoft