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

  • Artigo

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. Para obter mais informações, consulte Sequências de Caracteres de Formato Numérico Personalizado.

Seqüências de caracteres de formato numérico padrão são suportadas por algumas sobrecargas do ToString o método de todos os tipos numéricos. Por exemplo, você pode fornecer uma seqüência de caracteres de formato numérico para o ToString(String) e ToString(String, IFormatProvider) métodos para a Int32 tipo. Também há suporte para seqüências de caracteres de formato numérico padrão do.NET Framework composto recurso formatação, que é usado por alguns Write e WriteLine métodos para a Console e StreamWriter classes, o String.Format método e o StringBuilder.AppendFormat método.

Observação

Você pode baixar o O utilitário de formato, seqüências de caracteres de um aplicativo que permite que você aplique o formato numérico ou a data e hora, valores e exibe a seqüência de resultado.

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. Consulte o anotações seção para obter informações adicionais sobre como usar seqüências de caracteres de formato numérico padrão e o exemplo seção para obter uma ilustração abrangente de seu uso.

Especificador de Formato

Nome

Descrição

Exemplos

"C" ou "c"

Moeda

Resultado: Um valor de moeda.

Suporte: Todos os tipos numéricos.

Especificador de precisão: Número de dígitos decimais.

Especificador de precisão padrão: Definido pelo System.Globalization.NumberFormatInfo.

Mais informações: O especificador de formato de moeda ("C").

123.456 ("C" en-US) - > US $123.46

123.456 ("C" fr-FR) - > 123,46 €

123.456 ("C", ja-JP) - > ¥ 123

-123.456 ("C3", en-US) - > (US $123.456)

-123.456 ("C3", fr-FR) - > -123,456 €

-123.456 ("C3", ja-JP) - > -¥ 123.456

"D" ou "d"

Decimal

Resultado: Dígitos de inteiro com sinal de negativo opcional.

Suporte: Somente tipos integrais.

Especificador de precisão: Número mínimo de dígitos.

Especificador de precisão padrão: Número mínimo de dígitos necessários.

Mais informações: O especificador de formato de Decimal("D").

1234 ("D") - > 1234

-1234 ("D6") - > -001234

"E" ou "e"

Exponencial (científica)

Resultado: Notação exponencial.

Suporte: Todos os tipos numéricos.

Especificador de precisão: Número de dígitos decimais.

Especificador de precisão padrão: 6.

Mais informações: O especificador de formato exponencial ("E").

1052.0329112756 ("E" en-US) - > 1.052033E + 003.

1052.0329112756 ("e", fr-FR) - > 1, 052033e + 003

-1052.0329112756 ("e2", en-US) - > -1.05e + 003.

-1052.0329112756 ("E2", fr_FR) - > -1, 05E + 003

"F" ou "f"

Ponto fixo

Resultado: Dígitos integrais e decimais com sinal de negativo opcional.

Suporte: Todos os tipos numéricos.

Especificador de precisão: Número de dígitos decimais.

Especificador de precisão padrão: Definido pelo System.Globalization.NumberFormatInfo.

Mais informações: O especificador de formato ponto fixo ("F").

1234.567 ("F" en-US)-> 1234,57

1234.567 ("F" de-DE)-> 1234,57

1234 ("f1" en-US)-> 1234.0

1234 ("f1" de-DE)-> 1234,0

-1234.56 ("F4", en-US) - > -1234.5600

-1234.56 ("F4", de-DE) - > -1234,5600

"G" ou "g"

Geral

Resultado: Mais compacto de notação de ponto fixo ou científica.

Suporte: Todos os tipos numéricos.

Especificador de precisão: Número de dígitos significativos.

Especificador de precisão padrão: Depende do tipo numérico.

Mais informações: O especificador de formato geral ("G").

-123.456 ("G", en-US) - > -123.456

123.456 ("G", SE a VA) - > -123,456

123.4546 ("g4" en-US)-> 123.5

123.4546 ("g4" sv-SE)-> 123,5

-1.234567890e - 25 ("G", en-US) - > -1.23456789E-25

-1.234567890e - 25 ("G", SE a VA) - > -1, 23456789E-25.

"N" ou "n"

Número

Resultado: Dígitos decimais e de integrais, separadores de grupo e um separador decimal com sinal de negativo opcional.

Suporte: Todos os tipos numéricos.

Especificador de precisão: Número desejado de casas decimais.

Especificador de precisão padrão: Definido pelo System.Globalization.NumberFormatInfo.

Mais informações: O especificador de formato numérico ("N").

1234.567 ("N" en-US) - > 1.234,57

1234.567 ("N", ru-RU) - > 1 234,57

1234 ("N" en-US) - > 1,234.0

1234 ("N", ru-RU) - > 1 234,0

-1234.56 ("N" en-US) - > -1,234.560

-1234.56 ("N", ru-RU) - > -234,560 1

"P" ou "p"

Porcentagem

Resultado: Número multiplicado por 100 e exibido com um símbolo de porcentagem.

Suporte: Todos os tipos numéricos.

Especificador de precisão: Número desejado de casas decimais.

Especificador de precisão padrão: Definido pelo System.Globalization.NumberFormatInfo.

Mais informações: O especificador de formato de porcentagem ("P").

1 ("P" en-US)-> 100,00 %

1 ("P" fr-FR)-> 100,00%

-0.39678 ("P1", en-US) - > -39.7 %

-0.39678 ("P1", fr-FR) - > -39,7%

"R" ou "r"

Processamento

Resultado: Uma seqüência de caracteres pode viagem para um número idêntico.

Suporte: Single, Double, and BigInteger.

Especificador de precisão: Ignorado.

Mais informações: O especificador de formato de viagem ("R").

123456789.12345678 ("R") - > 123456789.12345678

-1234567890.12345678 ("R") - > -1234567890.1234567

"X" ou "x"

Hexadecimal

Resultado: Uma string hexadecimal.

Suporte: Somente tipos integrais.

Especificador de precisão: Número de dígitos na seqüência de resultado.

Mais informações: O HexaDecimal ("X") especificador de formato.

255 ("X") - > TT

-1 ("x") - > TT

255 ("x 4")-> 00FF

-1 ("X 4")-> 00FF

Qualquer outro caractere único

Especificador desconhecido

Resultado: Lança um FormatException em tempo de execução.

Usando cadeias de caracteres de formato numérico padrão

Uma seqüência de caracteres de formato numérico padrão pode ser usada para definir a formatação de um valor numérico em uma das duas maneiras:

  • Ele pode ser passado para uma sobrecarga de ToString método que possui um format parâmetro. O exemplo a seguir formata um valor numérico como uma seqüência de moeda na cultura atual (no caso, o en-US).

    Dim value As Decimal = 123.456d
Console.WriteLine(value.ToString("C2"))         
' Displays $123.46

    decimal value = 123.456m;
Console.WriteLine(value.ToString("C2"));
// Displays $123.46

  • Pode ser fornecido como o formatString parâmetro em um item do formato usado com esses métodos como String.Format, Console.WriteLine, e StringBuilder.AppendFormat. Para obter mais informações, consulte Formatação Composta. O exemplo a seguir usa um item de formato para inserir um valor de moeda em uma seqüência de caracteres.

    Dim value As Decimal = 123.456d
Console.WriteLine("Your account balance is {0:C2}.", value)
' Displays "Your account balance is $123.46."

    decimal value = 123.456m;
Console.WriteLine("Your account balance is {0:C2}.", value);
// Displays "Your account balance is $123.46."

As seções a seguintes fornecem informações detalhadas sobre cada uma das seqüências de caracteres de formato numérico padrão.

O especificador de formato de moeda ("C")

O "C" (ou moeda) especificador de formato converte um número como uma seqüência que representa o valor da moeda. O especificador precisão indica o número de casas decimais na seqüência de resultado desejado. Se o especificador precisão for omitido, a precisão padrão é definida pelo NumberFormatInfo.CurrencyDecimalDigits propriedade.

Se o valor a ser formatado tem mais do que o especificado ou o número padrão de casas decimais, o valor fracionário é arredondado na seqüência de resultado. Se o valor à direita do número de casas decimais especificado for 5 ou superior, o último dígito na seqüência de resultado é arredondado longe do zero.

A seqüência de caracteres de resultado é afetada por informações de formatação do atual NumberFormatInfo objeto. A tabela a seguir listas os NumberFormatInfo Propriedades que controlam a formatação da seqüência de caracteres retornada.

Propriedade NumberFormatInfo

Descrição

CurrencyPositivePattern

Define o posicionamento do símbolo da moeda para valores positivos.

CurrencyNegativePattern

Define o posicionamento do símbolo da moeda para valores negativos e especifica se o sinal negativo é representado pelos parênteses ou o NegativeSign propriedade.

NegativeSign

Define o sinal negativo usado se CurrencyNegativePattern indica que os parênteses não são usadas.

CurrencySymbol

Define o símbolo de moeda.

CurrencyDecimalDigits

Define o número de dígitos decimais padrão em um valor monetário. Esse valor pode ser substituído usando o especificador de precisão.

CurrencyDecimalSeparator

Define a seqüência de caracteres que separa os dígitos integrais e decimais.

CurrencyGroupSeparator

Define a seqüência de caracteres que separa grupos de números integrais.

CurrencyGroupSizes

Define o número de dígitos de inteiro que aparecem em um grupo.

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

Dim value As Double = 12345.6789
Console.WriteLine(value.ToString("C", CultureInfo.CurrentCulture))

Console.WriteLine(value.ToString("C3", CultureInfo.CurrentCulture))

Console.WriteLine(value.ToString("C3", _
                  CultureInfo.CreateSpecificCulture("da-DK")))
' The example displays the following output on a system whose
' current culture is English (United States):
'       $12,345.68
'       $12,345.679
'       kr 12.345,679

double value = 12345.6789;
Console.WriteLine(value.ToString("C", CultureInfo.CurrentCulture));

Console.WriteLine(value.ToString("C3", CultureInfo.CurrentCulture));

Console.WriteLine(value.ToString("C3", 
                  CultureInfo.CreateSpecificCulture("da-DK")));
// The example displays the following output on a system whose
// current culture is English (United States):
//       $12,345.68
//       $12,345.679
//       kr 12.345,679

Volta à tabela

O especificador de formato Decimal ("D")

O "D" (ou decimal) especificador de formato converte um número como uma seqüência de dígitos decimais (0-9), prefixado por um sinal de subtração se o número for negativo. Esse formato é suportado apenas para tipos inteiros.

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. Se nenhum especificador precisão for especificada, o padrão é o valor mínimo necessário para representar o número inteiro sem zeros à esquerda.

A seqüência de caracteres de resultado é afetada por informações de formatação do atual NumberFormatInfo objeto. Como mostra a tabela a seguir, uma única propriedade afeta a formatação da seqüência de caracteres de resultado.

Propriedade NumberFormatInfo

Descrição

NegativeSign

Define a seqüência de caracteres que indica que é um número negativo.

Os formatos de exemplo a seguir um Int32 valor com o especificador de formato decimal.

Dim value As Integer 

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

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

Volta à tabela

O especificador de formato exponencial ("E")

O especificador de formato exponencial ("E") converte um número em uma seqüência de caracteres do formulário "-d.ddd…E + ddd" ou "-d.ddd…e+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. Exatamente um dígito sempre precede o 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.

No caso do especificador de formato indica se o expoente com "E" de prefixo ou "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.

A seqüência de caracteres de resultado é afetada por informações de formatação do atual NumberFormatInfo objeto. A tabela a seguir listas os NumberFormatInfo Propriedades que controlam a formatação da seqüência de caracteres retornada.

Propriedade NumberFormatInfo

Descrição

NegativeSign

Define a seqüência de caracteres que indica que é um número negativo para o coeficiente e um expoente.

NumberDecimalSeparator

Define a seqüência de caracteres que separa o dígito integral de dígitos decimais o coeficiente.

PositiveSign

Define a seqüência de caracteres que indica que um expoente é positivo.

Os formatos de exemplo a seguir um Double valor com o especificador de formato exponencial.

Dim value As Double = 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

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

Volta à tabela

O especificador de formato ponto fixo ("F")

O especificador de formato ponto fixo ("F) converte um número em uma seqüê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 precisão for omitido, o atual NumberFormatInfo.NumberDecimalDigits propriedade fornece precisão numérica.

A seqüência de caracteres de resultado é afetada por informações de formatação do atual NumberFormatInfo objeto. A tabela a seguir lista as propriedades da NumberFormatInfo objeto que controlam a formatação da seqüência de resultado.

Propriedade NumberFormatInfo

Descrição

NegativeSign

Define a seqüência de caracteres que indica que é um número negativo.

NumberDecimalSeparator

Define a seqüência de caracteres que separa os dígitos integrais de dígitos decimais.

NumberDecimalDigits

Define o número padrão de dígitos decimais. Esse valor pode ser substituído usando o especificador de precisão.

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

Dim integerNumber As Integer
integerNumber = 17843
Console.WriteLine(integerNumber.ToString("F", CultureInfo.InvariantCulture))
' Displays 17843.00

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

Dim doubleNumber As Double
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                        

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

Volta à tabela

O especificador de formato geral ("G")

O especificador de formato geral ("G") converte um número em notação de ponto fixo ou científica, dependendo do tipo do número e se houver um especificador de precisão mais compacta. O especificador precisão define o número máximo de dígitos significativos que podem aparecer na seqüência de resultado. Se o especificador precisão for omitido ou zero, o tipo do número determina a precisão padrão, conforme indicado na tabela a seguir.

Tipo numérico

Precisão padrão

ByteouSByte

3 dígitos

Int16ouUInt16

5 dígitos

Int32ouUInt32

10 dígitos

Int64

19 dígitos

UInt64

20 dígitos

BigInteger

29 dígitos

Single

7 dígitos

Double

15 dígitos

Decimal

29 dígitos

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. O resultado contém um ponto decimal, se necessário, e os zeros à direita após o ponto decimal são omitidos. Se o especificador precisão está presente e a precisão especificada excede o número de dígitos significativos o resultado, os dígitos à direita em excesso são removidos, arredondando.

No entanto, se o número é um Decimal e o especificador precisão for omitido, notação de ponto fixo é sempre usada e zeros à direita são preservados.

Se for usada a notação científica, expoente no resultado é prefixado com "E" Se o especificador de formato é "G" ou "e" Se o especificador de formato é "g". O expoente contém um mínimo de dois dígitos. Isso difere do formato de notação científica que é produzido pelo especificador de formato exponencial, o que inclui um mínimo de três dígitos no expoente.

A seqüência de caracteres de resultado é afetada por informações de formatação do atual NumberFormatInfo objeto. A tabela a seguir listas os NumberFormatInfo Propriedades que controlam a formatação da seqüência de resultado.

Propriedade NumberFormatInfo

Descrição

NegativeSign

Define a seqüência de caracteres que indica que é um número negativo.

NumberDecimalSeparator

Define a seqüência de caracteres que separa os dígitos integrais de dígitos decimais.

NumberDecimalDigits

Define o número padrão de dígitos decimais. Esse valor pode ser substituído usando o especificador de precisão.

PositiveSign

Define a seqüência de caracteres que indica que um expoente é positivo.

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

Dim number As Double

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    

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

Volta à tabela

O especificador de formato numérico ("N")

O especificador de formato numérico ("N") converte um número em uma seqüê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 grupo, e "." indica um símbolo de ponto decimal. O especificador de precisão indica o número desejado de dígitos após o ponto decimal. Se o especificador precisão for omitido, o número de casas decimais é definido pelo atual NumberFormatInfo.NumberDecimalDigits propriedade.

A seqüência de caracteres de resultado é afetada por informações de formatação do atual NumberFormatInfo objeto. A tabela a seguir listas os NumberFormatInfo Propriedades que controlam a formatação da seqüência de resultado.

Propriedade NumberFormatInfo

Descrição

NegativeSign

Define a seqüência de caracteres que indica que é um número negativo.

NumberNegativePattern

Define o formato de valores negativos e especifica se o sinal negativo é representado pelos parênteses ou o NegativeSign propriedade.

NumberGroupSizes

Define o número de dígitos integrais que aparecem entre os separadores de grupo.

NumberGroupSeparator

Define a seqüência de caracteres que separa grupos de números integrais.

NumberDecimalSeparator

Define a seqüência de caracteres que separa os dígitos integrais e decimais.

NumberDecimalDigits

Define o número padrão de dígitos decimais. Esse valor pode ser substituído por meio de um especificador de precisão.

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

Dim dblValue As Double = -12445.6789
Console.WriteLine(dblValue.ToString("N", CultureInfo.InvariantCulture))
' Displays -12,445.68
Console.WriteLine(dblValue.ToString("N1", _
                  CultureInfo.CreateSpecificCulture("sv-SE")))
' Displays -12 445,7

Dim intValue As Integer = 123456789
Console.WriteLine(intValue.ToString("N1", CultureInfo.InvariantCulture))
' Displays 123,456,789.0 

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 -12 445,7

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

Volta à tabela

O especificador de formato de porcentagem ("P")

O especificador de formato porcentagem ("P") multiplica um número por 100 e o converte em uma seqüência de caracteres que representa um percentual. O especificador de precisão indica o número de casas decimais desejadas. Se o especificador precisão for omitido, a precisão numérica padrão fornecido pelo atual PercentDecimalDigits propriedade é usada.

A tabela a seguir listas os NumberFormatInfo Propriedades que controlam a formatação da seqüência de caracteres retornada.

Propriedade NumberFormatInfo

Descrição

PercentPositivePattern

Define o posicionamento do símbolo de porcentagem para valores positivos.

PercentNegativePattern

Define o posicionamento do símbolo de porcentagem e o símbolo de negativo para valores negativos.

NegativeSign

Define a seqüência de caracteres que indica que é um número negativo.

PercentSymbol

Define o símbolo de porcentagem.

PercentDecimalDigits

Define o número de dígitos decimais padrão em um valor de porcentagem. Esse valor pode ser substituído usando o especificador de precisão.

PercentDecimalSeparator

Define a seqüência de caracteres que separa os dígitos integrais e decimais.

PercentGroupSeparator

Define a seqüência de caracteres que separa grupos de números integrais.

PercentGroupSizes

Define o número de dígitos de inteiro que aparecem em um grupo.

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

Dim number As Double = .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 %

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 %

Volta à tabela

O especificador de formato de viagem ("R")

O especificador de formato de ida e volta ("R") garante que um valor numérico que é convertido em uma seqüência de caracteres será analisado volta para o mesmo valor numérico. Este formato é suportado somente para o Single, Double, e BigInteger tipos.

Quando um BigInteger valor é formatado usando este especificador, sua representação de seqüência de caracteres contém todos os dígitos significativos na BigInteger valor. Quando um Single ou Double valor é formatado usando este especificador, ela é testada pela primeira vez usando o formato geral, com 15 dígitos de precisão para um Double e 7 dígitos 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. Se o valor não é analisado com êxito para o mesmo valor numérico, ele é formatado usando 17 dígitos de precisão para um Double e 9 dígitos de precisão para um Single.

Embora você possa incluir um especificador de precisão, ela será ignorada. O processamento recebe precedência sobre a precisão ao usar esse especificador.

A seqüência de caracteres de resultado é afetada por informações de formatação do atual NumberFormatInfo objeto. A tabela a seguir listas os NumberFormatInfo Propriedades que controlam a formatação da seqüência de resultado.

Propriedade NumberFormatInfo

Descrição

NegativeSign

Define a seqüência de caracteres que indica que é um número negativo.

NumberDecimalSeparator

Define a seqüência de caracteres que separa os dígitos integrais de dígitos decimais.

PositiveSign

Define a seqüência de caracteres que indica que um expoente é positivo.

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

Dim value As Double

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

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

Volta à tabela

O Hexadecimal ("X") especificador de formato

O hexadecimal ("X") especificador de formato converte um número como uma seqüência de dígitos hexadecimais. No caso do especificador de formato indica se deve usar caracteres maiúsculos ou minúsculos para dígitos hexadecimais que são maiores do que 9. Por exemplo, usar o "X" para produzir "abcdef" e "x" para produzir "abcdef". Esse formato é suportado apenas para tipos inteiros.

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.

A seqüência de caracteres de resultado não é afetada por informações de formatação do atual NumberFormatInfo objeto.

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

Dim value As Integer 

value = &h2045e
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

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

Volta à tabela

Anotações

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 NumberFormatInfo objeto associado com a cultura do thread atual, que fornece os valores usados para controlar a formatação. Computadores que usam diferentes configurações geram cadeias de caracteres de resultado diferente.

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 CultureInfo.CultureInfo(String, Boolean) construtor para criar um CultureInfo objeto que não reflete as personalizações de. um sistema

Propriedades de NumberFormatInfo

Formatação é influenciada pelas propriedades do atual NumberFormatInfo o objeto, que é fornecido implicitamente pela cultura do thread atual ou explicitamente pela IFormatProvider parâmetro 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. The integral numeric types are Byte, SByte, Int16, Int32, Int64, UInt16, UInt32, UInt64, and BigInteger. Os tipos numéricos de ponto flutuante são Decimal, Single e Double.

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

Independentemente da seqüência de caracteres de formato, se o valor de um Single ou Double tipo de ponto flutuante é infinito positivo, infinito negativo ou não um número (NaN), a seqüência de caracteres formatada é o valor do respectivo PositiveInfinitySymbol, NegativeInfinitySymbol, ou NaNSymbol propriedade que é especificada pelo aplicável no momento NumberFormatInfo objeto.

Exemplo

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

Option Strict On

Imports System.Globalization
Imports System.Threading

Module NumericFormats
   Public Sub Main()
      ' Display string representations of numbers for en-us culture
      Dim ci As New CultureInfo("en-us")

      ' Output floating point values
      Dim floating As Double = 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
      Dim integral As Integer = 8395
      Console.WriteLine("C: {0}", _
              integral.ToString("C", ci))           ' Displays "C: $8,395.00"
      Console.WriteLine("D: {0}", _
              integral.ToString("D6"))              ' 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()
   End Sub
End Module

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.0).ToString("P02", ci)); // Displays "P: 83.95 %"
      Console.WriteLine("X: 0x{0}", 
              integral.ToString("X", ci));           // Displays "X: 0x20CB"
      Console.WriteLine();
   }
}

Consulte também

Tarefas

Como: Acrescentar um número com zeros

Referência

NumberFormatInfo

Conceitos

Sequências de Caracteres de Formato Numérico Personalizado

Tipos de Formatação

Histórico de alterações

Date

History

Motivo

Março de 2011

Adicionado um link para o utilitário de formato.

Aprimoramento de informações.

Julho de 2010

Observe que o arredondamento afastando de zero é usado com o "C" seqüência de caracteres de formato padrão.

Comentários do cliente.