Cadeias de caracteres de formato numérico padrão

As cadeias de caracteres de formato numérico padrão são usadas para formatar tipos numéricos comuns. Uma cadeia de caracteres de formato numérico padrão assume a forma [format specifier][precision specifier] , em que:

  • O especificador de formato é um caractere alfabético único que especifica o tipo de formato de número, por exemplo, moeda ou porcentagem. Qualquer cadeia de caracteres de formato numérico que contém mais de um caractere alfabético, incluindo espaços em branco, é interpretada como uma cadeia de caracteres de formato numérico personalizado. Para obter mais informações, consulte cadeias de caracteres de formato numérico personalizado.

  • O especificador de precisão é um inteiro opcional que afeta o número de dígitos na cadeia de caracteres resultante. No .NET 6 e versões posteriores, o valor máximo de precisão é Int32.MaxValue . Nas versões anteriores do .NET, a precisão pode variar de 0 a 99. O especificador de precisão controla o número de dígitos na representação de cadeia de caracteres de um número. Ele não arredonda o número em si. Para executar uma operação de arredondamento, use o método Math.Ceiling, Math.Floor ou Math.Round.

    Quando o especificador de precisão controla o número de dígitos fracionários na cadeia de caracteres de resultado, ela reflete um número que será arredondado para um resultado representável mais próximo do resultado infinitamente preciso. Se houver dois resultados representáveis igualmente próximos:

    • No .NET Framework e no .NET Core até o .net core 2,0, o tempo de execução seleciona o resultado com um dígito maior, menos significativo (ou seja, usando MidpointRounding.AwayFromZero ).
    • No .NET Core 2.1 e versões posteriores, o runtime selecionará o resultado com um dígito até menos significativo (ou seja, usando MidpointRounding.ToEven).

    Observação

    O especificador de precisão determina o número de dígitos na cadeia de caracteres de resultado. Para acrescentar espaços à direita ou à esquerda em uma cadeia de caracteres de resultado, use o recurso formatação de composição e defina um componente de alinhamento no item de formato.

As cadeias de caractere de formato numérico padrão têm suporte de:

Dica

Baixe o Utilitário de Formatação, um aplicativo do Windows Forms do .NET Core que permite aplicar cadeias de caracteres de formato a valores numéricos ou de data e hora e exibir a cadeia de caracteres de resultado. O código-fonte está disponível para o C# e o Visual Basic.

Especificadores de formato padrão

A tabela a seguir descreve os especificadores de formato numérico padrão e exibe exemplos de saídas produzidas por cada especificador de formato. Consulte a seção observações para obter informações adicionais sobre como usar cadeias de caracteres de formato numérico padrão e a seção de exemplo de código para uma ilustração abrangente de seu uso.

O resultado de uma cadeia de caracteres formatada para uma cultura específica pode ser diferente dos exemplos a seguir. As configurações do sistema operacional, as configurações do usuário, as variáveis de ambiente e a versão do .NET que você está usando podem afetar o formato. Por exemplo, a partir do .NET 5, o .NET tenta unificar formatos culturais entre plataformas. Para obter mais informações, consulte .net Globalization and ICU.

Especificador de formato Name Descrição Exemplos
"C" ou "c" Moeda Resultado: um valor de moeda.

Compatível com: todos os tipos numéricos.

Especificador de precisão: número de casas decimais.

Especificador de precisão padrão: definido por NumberFormatInfo.CurrencyDecimalDigits.

Para saber mais: especificador de formato de moeda ("C").
123,456 ("C", en-US)
-> \$123.46

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

123,456 ("C", ja-JP)
-> $123

-123,456 ("C3", en-US)
-> ( \ $123.456)

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

-123,456 ("C3", ja-JP)
->-$123.456
"D" ou "d" Decimal Resultado: dígitos inteiros com sinal negativo opcional.

Compatível com: 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.

Para saber mais: especificador de formato decimal ("D").
1234 ("D")
-> 1234

-1234 ("D6")
->-001234
"E" ou "e" Exponencial (científica) Resultado: notação Exponencial.

Compatível com: todos os tipos numéricos.

Especificador de precisão: número de casas decimais.

Especificador de precisão padrão: 6.

Para saber mais: especificador de formato exponencial ("E").
1052, 329112756 ("E", en-US)
-> 1.052033 E + 003

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

-1052, 329112756 ("E2", en-US)
->-1,05 e + 003

-1052, 329112756 ("E2", fr-FR)
->-1, 05E + 003
"F" ou "f" Ponto fixo Resultado: dígitos integrais e decimais com sinal negativo opcional.

Compatível com: todos os tipos numéricos.

Especificador de precisão: número de casas decimais.

Especificador de precisão padrão: definido por NumberFormatInfo.NumberDecimalDigits.

Para saber mais: especificador de formato de 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: a mais compacta entre notação de ponto fixo ou científica.

Compatível com: 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.

Para saber mais: especificador de formato geral ("G").
-123,456 ("G", en-US)
->-123,456

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

123,4546 ("G4", en-US)
-> 123,5

123,4546 ("G4", SV-SE)
-> 123, 5

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

-1.234567890 e-25 ("G", VA-SE)
->-1, 23456789E-25
"N" ou "n" Número Resultado: dígitos integrais e decimais, separadores de grupo e um separador decimal com sinal negativo opcional.

Compatível com: todos os tipos numéricos.

Especificador de precisão: número de casas decimais desejadas.

Especificador de precisão padrão: definido por NumberFormatInfo.NumberDecimalDigits.

Para saber mais: especificador de formato numérico ("N").
1234,567 ("N", en-US)
-> 1234,57

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

1234 ("N1", en-US)
-> 1234,0

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

-1234,56 ("N3", en-US)
->-1234,560

-1234,56 ("N3", ru-RU)
->-1 234.560
"P" ou "p" Porcentagem Resultado: número multiplicado por 100 e exibido com um sinal de porcentagem.

Compatível com: todos os tipos numéricos.

Especificador de precisão: número de casas decimais desejadas.

especificador de precisão padrão: definido por NumberFormatInfo.PercentDecimalDigits.

Para saber mais: especificador de formato de porcentagem ("P").
1 ("P", en-US)
-> 100, 0%

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

-0,39678 ("P1", en-US)
->-39,7%

-0,39678 ("P1", fr-FR)
->-39, 7%
"R" ou "r" Ida e volta Resultado: uma cadeia de caracteres que pode ir e voltar para um número idêntico.

Compatível com: Single, Double e BigInteger.

Observação: recomendado apenas para o tipo BigInteger. Para os tipos Double, use "G17"; para os tipos Single, use "G9".
Especificador de precisão: ignorado.

Para saber mais: especificador de formato de ida e volta ("R").
123456789,12345678 ("R")
-> 123456789,12345678

-1234567890,12345678 ("R")
->-1234567890,1234567
"X" ou "x" Hexadecimal Resultado: uma cadeia de caracteres hexadecimal.

Compatível com: somente tipos integrais.

Especificador de precisão: número de dígitos na cadeia de caracteres de resultado.

Para saber mais: especificador de formato hexadecimal ("X").
255 ("X")
-> FF

-1 ("x")
-> FF

255 ("x4")
-> 00ff

-1 ("x4")
-> 00FF
Qualquer outro caractere único Especificador desconhecido Resultado: gera uma FormatException em tempo de execução.

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

Observação

Os exemplos de C# neste artigo são executados no executador de código embutido Try.NET e no playground. Clique no botão Executar para executar um exemplo em uma janela interativa. Ao executar o código, é possível modificá-lo e executar o código modificado clicando em Executar novamente. O código modificado será executado na janela interativa ou, se a compilação falhar, a janela interativa exibirá todos as mensagens de erro do compilador C#.

Uma cadeia de caracteres de formato numérico padrão pode ser usada para definir a formatação de um valor numérico de uma das seguintes maneiras:

  • Ele pode ser passado para o TryFormat método ou uma sobrecarga do ToString método que tem um format parâmetro. O exemplo a seguir formata um valor numérico como uma cadeia de caracteres de moeda na cultura atual (nesse caso, a cultura en-US).

    Decimal value = static_cast<Decimal>(123.456);
    Console::WriteLine(value.ToString("C2"));
    // Displays $123.46
    
    decimal value = 123.456m;
    Console.WriteLine(value.ToString("C2"));
    // Displays $123.46
    
    Dim value As Decimal = 123.456d
    Console.WriteLine(value.ToString("C2"))
    ' Displays $123.46
    
  • Ele pode ser fornecido como o argumento formatString em um item de formato usado com métodos como String.Format, Console.WriteLine e StringBuilder.AppendFormat. Para obter mais informações, veja Formatação de composição. O exemplo a seguir usa um item de formato para inserir um valor de moeda em uma cadeia de caracteres.

    Decimal value = static_cast<Decimal>(123.456);
    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."
    
    Dim value As Decimal = 123.456d
    Console.WriteLine("Your account balance is {0:C2}.", value)
    ' Displays "Your account balance is $123.46."
    

    Opcionalmente, você pode fornecer um argumento alignment para especificar a largura do campo numérico e se o valor é alinhado à direita ou à esquerda. O exemplo a seguir alinha à esquerda um valor de moeda em um campo de 28 caracteres e alinha à direita um valor de moeda em um campo de 14 caracteres.

    array<Decimal>^ amounts = { static_cast<Decimal>(16305.32), 
                                static_cast<Decimal>(18794.16) };
    Console::WriteLine("   Beginning Balance           Ending Balance");
    Console::WriteLine("   {0,-28:C2}{1,14:C2}", amounts[0], amounts[1]);
    // Displays:
    //        Beginning Balance           Ending Balance
    //        $16,305.32                      $18,794.16      
    
    decimal[] amounts = { 16305.32m, 18794.16m };
    Console.WriteLine("   Beginning Balance           Ending Balance");
    Console.WriteLine("   {0,-28:C2}{1,14:C2}", amounts[0], amounts[1]);
    // Displays:
    //        Beginning Balance           Ending Balance
    //        $16,305.32                      $18,794.16
    
    Dim amounts() As Decimal = {16305.32d, 18794.16d}
    Console.WriteLine("   Beginning Balance           Ending Balance")
    Console.WriteLine("   {0,-28:C2}{1,14:C2}", amounts(0), amounts(1))
    ' Displays:
    '        Beginning Balance           Ending Balance
    '        $16,305.32                      $18,794.16      
    
  • Ele pode ser fornecido como o argumento formatString em um item de expressão interpolada de uma cadeia de caracteres interpolada. Para obter mais informações, consulte o artigo interpolação de cadeia de caracteres na referência de C# ou no artigo de cadeias interpoladas na referência de Visual Basic.

As seções a seguir fornecem informações detalhadas sobre cada uma das cadeias de caracteres de formato numérico padrão.

Especificador de formato de moeda (C)

O especificador de formato "C" (ou moeda) converte um número em uma cadeia de caracteres que representa um valor de moeda. O especificador de precisão indica o número desejado de casas decimais na cadeia de caracteres resultante. Se o especificador de precisão for omitido, a precisão padrão será definida pela propriedade NumberFormatInfo.CurrencyDecimalDigits.

Se o valor a ser formatado tem mais do que o número especificado ou padrão de casas decimais, o valor fracionário é arredondado na cadeia de caracteres de resultado. Se o valor à direita do número de casas decimais especificadas for 5 ou mais, o último dígito da cadeia de caracteres do resultado será arredondado para cima.

A cadeia de caracteres de resultado é afetada pelas informações de formatação do objeto NumberFormatInfo atual. A tabela a seguir lista as propriedades NumberFormatInfo que controlam a formatação da cadeia de caracteres retornada.

Propriedade NumberFormatInfo Descrição
CurrencyPositivePattern Define o posicionamento do símbolo de moeda para valores positivos.
CurrencyNegativePattern Define o posicionamento do símbolo da moeda para valores negativos e especifica se o sinal de negativo é representado por parênteses ou pela propriedade NegativeSign.
NegativeSign Define o sinal de negativo usado se CurrencyNegativePattern indicar que parênteses não são usados.
CurrencySymbol Define o símbolo de moeda.
CurrencyDecimalDigits Define o número padrão de dígitos decimais em um valor de moeda. Esse valor pode ser substituído usando-se o especificador de precisão.
CurrencyDecimalSeparator Define a cadeia de caracteres que separa dígitos decimais e integrais.
CurrencyGroupSeparator Define a cadeia de caracteres que separa grupos de números integrais.
CurrencyGroupSizes Define o número de dígitos inteiros que aparecem em um grupo.

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

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
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
//       12.345,679 kr
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

Especificador de formato decimal (D)

O especificador de formato “D” (ou decimal) converte um número em uma cadeia de caracteres de dígitos decimais (0-9), prefixados por um sinal de negativo se o número for negativo. Esse formato é compatível apenas com tipos integrais.

O especificador de precisão indica o número mínimo de dígitos desejados na cadeia de caracteres 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. Quando nenhum especificador de precisão é especificado, o padrão é o valor mínimo necessário para representar o inteiro sem zeros à esquerda.

A cadeia de caracteres de resultado é afetada pelas informações de formatação do objeto NumberFormatInfo atual. Conforme mostrado na tabela a seguir, uma única propriedade afeta a formatação da cadeia de caracteres de resultado.

Propriedade NumberFormatInfo Descrição
NegativeSign Define a cadeia de caracteres que indica que um número é negativo.

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
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
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

Especificador de formato exponencial (E)

O especificador do formato do exponencial ("E") converte um número em uma cadeia de caracteres no formato "-d.ddd…E+ddd" ou "-d.ddd…e+ddd", em que cada 'd' indica um dígito (0-9). A cadeia de caracteres é iniciada com um sinal de negativo se o número é 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. Quando o especificador de precisão é omitido, um padrão de seis dígitos após o ponto decimal é usado.

A caixa do especificador de formato indica se o expoente é prefixado com um "E" ou um "e". O expoente sempre consistem em um sinal de positivo ou negativo e um mínimo de três dígitos. O expoente é preenchido com zeros para atender a esse mínimo, se necessário.

A cadeia de caracteres de resultado é afetada pelas informações de formatação do objeto NumberFormatInfo atual. A tabela a seguir lista as propriedades NumberFormatInfo que controlam a formatação da cadeia de caracteres retornada.

Propriedade NumberFormatInfo Descrição
NegativeSign Define a cadeia de caracteres que indica que o número é negativo para o coeficiente e o expoente.
NumberDecimalSeparator Define a cadeia de caracteres que separa o dígito integral dos dígitos decimais no coeficiente.
PositiveSign Define a cadeia de caracteres que indica que um expoente é positivo.

O exemplo a seguir formata um Double valor com o especificador de formato exponencial:

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
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
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

Especificador de formato de ponto fixo (F)

O especificador de formato de ponto fixo ("F") converte um número em uma cadeia de caracteres no formato "-ddd.ddd…", em que cada "d" indica um dígito (0-9). A cadeia de caracteres é iniciada com um sinal de negativo se o número é negativo.

O especificador de precisão indica o número de casas decimais desejadas. Quando o especificador de precisão é omitido, a propriedade NumberFormatInfo.NumberDecimalDigits atual fornece a precisão numérica.

A cadeia de caracteres de resultado é afetada pelas informações de formatação do objeto NumberFormatInfo atual. A tabela a seguir lista as propriedades do objeto NumberFormatInfo que controlam a formatação da cadeia de caracteres de resultado.

Propriedade NumberFormatInfo Descrição
NegativeSign Define a cadeia de caracteres que indica que um número é negativo.
NumberDecimalSeparator Define a cadeia de caracteres que separa 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-se o especificador de precisão.

O exemplo a seguir formata um Double e um Int32 valor 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                        
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
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                        

Especificador de formato geral (G)

O especificador de formato geral ("G") converte um número para a notação mais compacta entre ponto fixo ou científica, dependendo do tipo do número e se um especificador de precisão está presente. O especificador de precisão define o número máximo de dígitos significativos que podem aparecer na cadeia de caracteres de resultado. Quando o especificador de precisão é 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
Byte ou SByte 3 dígitos
Int16 ou UInt16 5 dígitos
Int32 ou UInt32 10 dígitos
Int64 19 dígitos
UInt64 20 dígitos
BigInteger Ilimitado (igual a "R")
Half 3 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. Se necessário, o resultado contém um ponto decimal, e os zeros à direita após o ponto decimal são omitidos. Se o especificador de precisão estiver presente e o número de dígitos significativos no resultado exceder a precisão especificada, o excesso de dígitos à direita será removido por arredondamento.

No entanto, se o número for Decimal e o especificador de precisão for omitido, a notação de ponto fixo será usada sempre e os zeros à direita serão preservados.

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

Quando usado com um Double valor, o especificador de formato "G17" garante que o Double valor original tenha ciclos de ida e volta com êxito. Isso ocorre porque o Double é um número de ponto flutuante de precisão dupla () compatível com IEEE 754-2008 binary64 que fornece até 17 dígitos significativos de precisão. Em .NET Framework, recomendamos seu uso em vez do especificador de formato "r", já que, em alguns casos, "r" falha ao arredondar com êxito os valores de ponto flutuante de precisão dupla.

Quando usado com um valor Single, o especificador de formato "G9" garante que o valor Single original faça a viagem de ida e volta com êxito. Isso ocorre porque o Single é um número de ponto flutuante de precisão única () compatível com IEEE 754-2008 binary32 que fornece até nove dígitos significativos de precisão. Por motivos de desempenho, recomendamos seu uso em vez do especificador de formato "R".

A cadeia de caracteres de resultado é afetada pelas informações de formatação do objeto NumberFormatInfo atual. A tabela a seguir lista as propriedades NumberFormatInfo que controlam a formatação da cadeia de caracteres de resultado.

Propriedade NumberFormatInfo Descrição
NegativeSign Define a cadeia de caracteres que indica que um número é negativo.
NumberDecimalSeparator Define a cadeia de caracteres que separa dígitos integrais de dígitos decimais.
PositiveSign Define a cadeia de caracteres que indica que um expoente é positivo.

O exemplo a seguir formata valores de ponto flutuante asvariados 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    
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
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    

Especificador de formato numérico (N)

O especificador de formato numérico ("N") converte um número em uma cadeia de caracteres no formato "-d,ddd,ddd.ddd…", em que "-" indica um símbolo de número negativo, se necessário, "d" indica um dígito (0-9), "," indica um separador de grupos de número 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 de precisão for omitido, o número de casas decimais será definido pela propriedade NumberFormatInfo.NumberDecimalDigits atual.

A cadeia de caracteres de resultado é afetada pelas informações de formatação do objeto NumberFormatInfo atual. A tabela a seguir lista as propriedades NumberFormatInfo que controlam a formatação da cadeia de caracteres de resultado.

Propriedade NumberFormatInfo Descrição
NegativeSign Define a cadeia de caracteres que indica que um número é negativo.
NumberNegativePattern Define o formato dos valores negativos e especifica se o sinal de negativo é representado por parênteses ou a propriedade NegativeSign.
NumberGroupSizes Define o número total de dígitos integrais que aparecem entre os separadores de grupo.
NumberGroupSeparator Define a cadeia de caracteres que separa grupos de números integrais.
NumberDecimalSeparator Define a cadeia de caracteres que separa dígitos decimais e integrais.
NumberDecimalDigits Define o número padrão de dígitos decimais. Esse valor pode ser substituído usando um especificador de precisão.

O exemplo a seguir formata valores de ponto flutuante classificados com o especificador de formato de número:

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 
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
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 

Especificador de formato de porcentagem (P)

O especificador de formato de porcentagem (“P”) multiplica um número por 100 e o converte em uma cadeia de caracteres que representa uma porcentagem. 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 fornecida pela propriedade PercentDecimalDigits atual será usada.

A tabela a seguir lista as propriedades NumberFormatInfo que controlam a formatação da cadeia 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 negativo para valores negativos.
NegativeSign Define a cadeia de caracteres que indica que um número é negativo.
PercentSymbol Define o símbolo de porcentagem.
PercentDecimalDigits Define o número padrão de dígitos decimais em um valor percentual. Esse valor pode ser substituído usando-se o especificador de precisão.
PercentDecimalSeparator Define a cadeia de caracteres que separa dígitos decimais e integrais.
PercentGroupSeparator Define a cadeia de caracteres que separa grupos de números integrais.
PercentGroupSizes Define o número de dígitos inteiros que aparecem em um grupo.

O exemplo a seguir formata valores de ponto flutuante com o especificador de formato de porcentagem:

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 %
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 %
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 %

Especificador de formato de ida e volta (R)

O especificador de formato de ida e volta ("R") tenta garantir que um valor numérico convertido em uma cadeia de caracteres seja analisado com o mesmo valor numérico. Esse formato tem suporte apenas para os Half tipos,, Single Double e BigInteger .

Para valores Double, o especificador de formato "R" em alguns casos falha em realizar a viagem de ida e volta com êxito do valor original. Para os valores Double e Single, ele também oferece desempenho relativamente baixo. Em vez disso, recomendamos que você use o especificador de formato "G17" para os valores Double e o especificador de formato "G9" para realizar a viagem de ida e volta dos valores Single.

Quando um valor BigInteger é formatado usando esse especificador, sua representação de cadeia de caracteres contém todos os dígitos significativos no valor de BigInteger.

Embora você possa incluir um especificador de precisão, ele será ignorado. Idas e voltas têm precedência sobre a precisão quando esse especificador é usado. A cadeia de caracteres de resultado é afetada pelas informações de formatação do objeto NumberFormatInfo atual. A tabela a seguir lista as propriedades NumberFormatInfo que controlam a formatação da cadeia de caracteres de resultado.

Propriedade NumberFormatInfo Descrição
NegativeSign Define a cadeia de caracteres que indica que um número é negativo.
NumberDecimalSeparator Define a cadeia de caracteres que separa dígitos integrais de dígitos decimais.
PositiveSign Define a cadeia de caracteres que indica que um expoente é positivo.

O exemplo a seguir formata um valor BigInteger com o especificador de formato de ida e volta.

#using <System.Numerics.dll>

using namespace System;
using namespace System::Numerics;

void main()
{ 
   BigInteger value = BigInteger::Pow(Int64::MaxValue, 2);
   Console::WriteLine(value.ToString("R"));
}
// The example displays the following output:
//      85070591730234615847396907784232501249  


using System;
using System.Numerics;

public class Example
{
   public static void Main()
   {
      var value = BigInteger.Pow(Int64.MaxValue, 2);
      Console.WriteLine(value.ToString("R"));
   }
}
// The example displays the following output:
//      85070591730234615847396907784232501249
Imports System.Numerics

Module Example
    Public Sub Main()
        Dim value = BigInteger.Pow(Int64.MaxValue, 2)
        Console.WriteLine(value.ToString("R"))
    End Sub
End Module
' The example displays the following output:
'      85070591730234615847396907784232501249  

Importante

Em alguns casos, os valores Double formatados com a cadeia de caracteres de formato numérico padrão "R" não realizam a viagem de ida e volta se forem compilados usando as opções /platform:x64 ou /platform:anycpu e executados em sistemas de 64 bits. Para saber mais, consulte o seguinte parágrafo.

Para solucionar o problema de valores Double formatados com a cadeia de caracteres no formato numérico padrão "R" que não conseguem realizar a viagem de ida e volta se forem compilados usando as opções /platform:x64 ou /platform:anycpu e executados em sistemas de 64 bits, formate os valores Double usando a cadeia de caracteres de formato numérico padrão "G17". O exemplo a seguir usa a cadeia de caracteres de formato "R" com um Double valor que não faz a viagem de ida e volta com êxito e também usa a cadeia de caracteres de formato "G17" para fazer uma viagem de ida e volta com êxito ao valor original:

Console.WriteLine("Attempting to round-trip a Double with 'R':");
double initialValue = 0.6822871999174;
string valueString = initialValue.ToString("R",
                                           CultureInfo.InvariantCulture);
double roundTripped = double.Parse(valueString,
                                   CultureInfo.InvariantCulture);
Console.WriteLine("{0:R} = {1:R}: {2}\n",
                  initialValue, roundTripped, initialValue.Equals(roundTripped));

Console.WriteLine("Attempting to round-trip a Double with 'G17':");
string valueString17 = initialValue.ToString("G17",
                                             CultureInfo.InvariantCulture);
double roundTripped17 = double.Parse(valueString17,
                                     CultureInfo.InvariantCulture);
Console.WriteLine("{0:R} = {1:R}: {2}\n",
                  initialValue, roundTripped17, initialValue.Equals(roundTripped17));
// If compiled to an application that targets anycpu or x64 and run on an x64 system,
// the example displays the following output:
//       Attempting to round-trip a Double with 'R':
//       0.6822871999174 = 0.68228719991740006: False
//
//       Attempting to round-trip a Double with 'G17':
//       0.6822871999174 = 0.6822871999174: True
Imports System.Globalization

Module Example
    Public Sub Main()
        Console.WriteLine("Attempting to round-trip a Double with 'R':")
        Dim initialValue As Double = 0.6822871999174
        Dim valueString As String = initialValue.ToString("R",
                                                 CultureInfo.InvariantCulture)
        Dim roundTripped As Double = Double.Parse(valueString,
                                                  CultureInfo.InvariantCulture)
        Console.WriteLine("{0:R} = {1:R}: {2}",
                          initialValue, roundTripped, initialValue.Equals(roundTripped))
        Console.WriteLine()

        Console.WriteLine("Attempting to round-trip a Double with 'G17':")
        Dim valueString17 As String = initialValue.ToString("G17",
                                                   CultureInfo.InvariantCulture)
        Dim roundTripped17 As Double = double.Parse(valueString17,
                                              CultureInfo.InvariantCulture)
        Console.WriteLine("{0:R} = {1:R}: {2}",
                          initialValue, roundTripped17, initialValue.Equals(roundTripped17))
    End Sub
End Module
' If compiled to an application that targets anycpu or x64 and run on an x64 system,
' the example displays the following output:
'       Attempting to round-trip a Double with 'R':
'       0.6822871999174 = 0.68228719991740006: False
'
'       Attempting to round-trip a Double with 'G17':
'       0.6822871999174 = 0.6822871999174: True

Especificador de formato hexadecimal (X)

O especificador de formato hexadecimal ("X") converte um número em uma cadeia de caracteres de dígitos hexadecimais. A caixa do especificador de formato indica se caracteres maiúsculos ou minúsculos devem ser usados para os dígitos hexadecimais maiores que 9. Por exemplo, use "X" para produzir "ABCDEF" e "x" para produzir "abcdef". Esse formato é compatível apenas com tipos integrais.

O especificador de precisão indica o número mínimo de dígitos desejados na cadeia de caracteres 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 cadeia de caracteres do resultado não é afetada pelas informações de formatação do objeto NumberFormatInfo atual.

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
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
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

Anotações

Esta seção contém informações adicionais sobre como usar cadeias de caracteres de formato numérico padrão.

Configurações do Painel de Controle

As configurações no item Opções Regionais e de Idioma do Painel de Controle influenciam a cadeia de caracteres de resultado produzida por uma operação de formatação. Essas configurações são usadas para inicializar o objeto NumberFormatInfo associado à cultura do thread atual, a qual fornece os valores usados para determinar a formatação. Computadores que usam configurações diferentes geram cadeias de caracteres de resultado diferentes.

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

Propriedades de NumberFormatInfo

A formatação é influenciada pelas propriedades do objeto NumberFormatInfo atual, o qual é fornecido implicitamente pela cultura do thread 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.

Observação

Para obter informações sobre como personalizar os padrões ou cadeias de caracteres usados na formatação de valores numéricos, consulte o tópico de classe NumberFormatInfo.

Tipos numéricos integrais e de ponto flutuante

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

Infinitos de ponto flutuante e NaN

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

Exemplo de código

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 ( Double e Int32 ), mas produziria resultados semelhantes para qualquer um dos outros tipos base numéricos (,,,,,,,,,, Byte SByte Int16 Int32 Int64 UInt16 UInt32 UInt64 BigInteger Decimal Half e Single ).

// 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();
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

Consulte também