Cadeias de caracteres de formato numérico padrãoStandard Numeric Format Strings

As cadeias de caracteres de formato numérico padrão são usadas para formatar tipos numéricos comuns.Standard numeric format strings are used to format common numeric types. Uma cadeia de caracteres de formato numérico padrão assume o formato Axx, em que:A standard numeric format string takes the form Axx, where:

  • A é um caractere alfabético único chamado especificador de formato.A is a single alphabetic character called the format specifier. 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.Any numeric format string that contains more than one alphabetic character, including white space, is interpreted as a custom numeric format string. Para obter mais informações, consulte Cadeias de caracteres de formato numérico personalizado.For more information, see Custom Numeric Format Strings.

  • xx é um inteiro opcional chamado especificador de precisão.xx is an optional integer called the precision specifier. O especificador de precisão varia de 0 a 99 e afeta o número de dígitos no resultado.The precision specifier ranges from 0 to 99 and affects the number of digits in the result. Observe que o especificador de precisão controla o número de dígitos na representação da cadeia de caracteres de um número.Note that the precision specifier controls the number of digits in the string representation of a number. Ele não arredonda o número em si.It does not round the number itself. Para executar uma operação de arredondamento, use o método Math.Ceiling, Math.Floor ou Math.Round.To perform a rounding operation, use the Math.Ceiling, Math.Floor, or Math.Round method.

    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.When precision specifier controls the number of fractional digits in the result string, the result string reflects a number that is rounded to a representable result nearest to the infinitely precise result. Se houver dois resultados representáveis igualmente próximos:If there are two equally near representable results:

    • No .NET Framework e .NET Core até o .NET Core 2.0, o tempo de execução selecionará o resultado com o dígito menos significativo maior (ou seja, usando MidpointRounding.AwayFromZero).On the .NET Framework and .NET Core up to .NET Core 2.0, the runtime selects the result with the greater least significant digit (that is, using MidpointRounding.AwayFromZero).
    • No .NET Core 2.1 e versões posteriores, o tempo de execução selecionará o resultado com um dígito até menos significativo (ou seja, usando MidpointRounding.ToEven).On .NET Core 2.1 and later, the runtime selects the result with an even least significant digit (that is, using MidpointRounding.ToEven).

    Observação

    O especificador de precisão determina o número de dígitos na cadeia de caracteres de resultado.The precision specifier determines the number of digits in the result string. 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.To pad a result string with leading or trailing spaces, use the composite formatting feature and define an alignment component in the format item.

As cadeias de caractere de formato numérico padrão têm suporte de:Standard numeric format strings are supported by:

Dica

É possível baixar o Utilitário de Formatação, um aplicativo 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.You can download the Formatting Utility, an application that enables you to apply format strings to either numeric or date and time values and displays the result string.

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.The following table describes the standard numeric format specifiers and displays sample output produced by each format specifier. Consulte a seção Notas para obter informações adicionais sobre como usar cadeias de caracteres de formato numérico padrão e a seção Exemplo para obter uma ilustração abrangente de seu uso.See the Notes section for additional information about using standard numeric format strings, and the Example section for a comprehensive illustration of their use.

Especificador de formatoFormat specifier NomeName DescriçãoDescription ExemplosExamples
"C" ou "c""C" or "c" MoedaCurrency Resultado: Um valor de moeda.Result: A currency value.

Compatível com: Todos os tipos numéricos.Supported by: All numeric types.

Especificador de precisão: Número de dígitos decimais.Precision specifier: Number of decimal digits.

Especificador de precisão padrão: Definido por NumberFormatInfo.CurrencyDecimalDigits.Default precision specifier: Defined by NumberFormatInfo.CurrencyDecimalDigits.

Para saber mais: O especificador de formato de moeda ("C").More information: The Currency ("C") Format Specifier.
123.456 ("C", en-US) -> $123.46123.456 ("C", en-US) -> $123.46

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

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

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

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

-123.456 ("C3", ja-JP) -> -¥123.456-123.456 ("C3", ja-JP) -> -¥123.456
"D" ou "d""D" or "d" DecimalDecimal Resultado: Dígitos inteiros com sinal negativo opcional.Result: Integer digits with optional negative sign.

Compatível com: Somente tipos integrais.Supported by: Integral types only.

Especificador de precisão: Número mínimo de dígitos.Precision specifier: Minimum number of digits.

Especificador de precisão padrão: Número mínimo de dígitos necessários.Default precision specifier: Minimum number of digits required.

Para saber mais: O especificador de formato decimal ("D").More information: The Decimal("D") Format Specifier.
1234 ("D") -> 12341234 ("D") -> 1234

-1234 ("D6") -> -001234-1234 ("D6") -> -001234
"E" ou "e""E" or "e" Exponencial (científica)Exponential (scientific) Resultado: Notação exponencial.Result: Exponential notation.

Compatível com: Todos os tipos numéricos.Supported by: All numeric types.

Especificador de precisão: Número de dígitos decimais.Precision specifier: Number of decimal digits.

Especificador de precisão padrão: 6.Default precision specifier: 6.

Para saber mais: O especificador de formato exponencial ("E").More information: The Exponential ("E") Format Specifier.
1052.0329112756 ("E", en-US) -> 1.052033E+0031052.0329112756 ("E", en-US) -> 1.052033E+003

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

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

-1052.0329112756 ("E2", fr-FR) -> -1,05E+003-1052.0329112756 ("E2", fr-FR) -> -1,05E+003
"F" ou "f""F" or "f" Ponto fixoFixed-point Resultado: Dígitos integrais e decimais com sinal negativo opcional.Result: Integral and decimal digits with optional negative sign.

Compatível com: Todos os tipos numéricos.Supported by: All numeric types.

Especificador de precisão: Número de dígitos decimais.Precision specifier: Number of decimal digits.

Especificador de precisão padrão: Definido por NumberFormatInfo.NumberDecimalDigits.Default precision specifier: Defined by NumberFormatInfo.NumberDecimalDigits.

Para saber mais: O especificador de formato de ponto fixo ("F").More information: The Fixed-Point ("F") Format Specifier.
1234.567 ("F", en-US) -> 1234.571234.567 ("F", en-US) -> 1234.57

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

1234 ("F1", en-US) -> 1234.01234 ("F1", en-US) -> 1234.0

1234 ("F1", de-DE) -> 1234,01234 ("F1", de-DE) -> 1234,0

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

-1234.56 ("F4", de-DE) -> -1234,5600-1234.56 ("F4", de-DE) -> -1234,5600
"G" ou "g""G" or "g" GeralGeneral Resultado: A mais compacta entre notação de ponto fixo ou científica.Result: The more compact of either fixed-point or scientific notation.

Compatível com: Todos os tipos numéricos.Supported by: All numeric types.

Especificador de precisão: Número de dígitos significativos.Precision specifier: Number of significant digits.

Especificador de precisão padrão: Depende do tipo numérico.Default precision specifier: Depends on numeric type.

Para saber mais: O especificador de formato geral ("G").More information: The General ("G") Format Specifier.
-123.456 ("G", en-US) -> -123.456-123.456 ("G", en-US) -> -123.456

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

123.4546 ("G4", en-US) -> 123.5123.4546 ("G4", en-US) -> 123.5

123.4546 ("G4", sv-SE) -> 123,5123.4546 ("G4", sv-SE) -> 123,5

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

-1.234567890e-25 ("G", sv-SE) -> -1,23456789E-25-1.234567890e-25 ("G", sv-SE) -> -1,23456789E-25
"N" ou "n""N" or "n" NúmeroNumber Resultado: Dígitos integrais e decimais, separadores de grupo e um separador decimal com sinal negativo opcional.Result: Integral and decimal digits, group separators, and a decimal separator with optional negative sign.

Compatível com: Todos os tipos numéricos.Supported by: All numeric types.

Especificador de precisão: Número desejado de casas decimais.Precision specifier: Desired number of decimal places.

Especificador de precisão padrão: Definido por NumberFormatInfo.NumberDecimalDigits.Default precision specifier: Defined by NumberFormatInfo.NumberDecimalDigits.

Para saber mais: O especificador de formato numérico ("N").More information: The Numeric ("N") Format Specifier.
1234.567 ("N", en-US) -> 1,234.571234.567 ("N", en-US) -> 1,234.57

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

1234 ("N1", en-US) -> 1,234.01234 ("N1", en-US) -> 1,234.0

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

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

-1234.56 ("N3", ru-RU) -> -1 234,560-1234.56 ("N3", ru-RU) -> -1 234,560
"P" ou "p""P" or "p" PorcentagemPercent Resultado: Número multiplicado por 100 e exibido com um sinal de porcentagem.Result: Number multiplied by 100 and displayed with a percent symbol.

Compatível com: Todos os tipos numéricos.Supported by: All numeric types.

Especificador de precisão: Número desejado de casas decimais.Precision specifier: Desired number of decimal places.

Especificador de precisão padrão: Definido por NumberFormatInfo.PercentDecimalDigits.Default precision specifier: Defined by NumberFormatInfo.PercentDecimalDigits.

Para saber mais: O especificador de formato de porcentagem ("P").More information: The Percent ("P") Format Specifier.
1 ("P", en-US) -> 100.00 %1 ("P", en-US) -> 100.00 %

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

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

-0.39678 ("P1", fr-FR) -> -39,7 %-0.39678 ("P1", fr-FR) -> -39,7 %
"R" ou "r""R" or "r" Ida e voltaRound-trip Resultado: Uma cadeia de caracteres que pode ir e voltar para um número idêntico.Result: A string that can round-trip to an identical number.

Compatível com: Single, Double e BigInteger.Supported by: Single, Double, and BigInteger.

Observação: Recomendado apenas para o tipo BigInteger.Note: Recommended for the BigInteger type only. Para os tipos Double, use "G17"; para os tipos Single, use "G9".For Double types, use "G17"; for Single types, use "G9".
Especificador de precisão: Ignorado.Precision specifier: Ignored.

Para saber mais: O especificador de formato de viagem de ida e volta ("R").More information: The Round-trip ("R") Format Specifier.
123456789.12345678 ("R") -> 123456789.12345678123456789.12345678 ("R") -> 123456789.12345678

-1234567890.12345678 ("R") -> -1234567890.1234567-1234567890.12345678 ("R") -> -1234567890.1234567
"X" ou "x""X" or "x" HexadecimalHexadecimal Resultado: Uma cadeia de caracteres hexadecimal.Result: A hexadecimal string.

Compatível com: Somente tipos integrais.Supported by: Integral types only.

Especificador de precisão: Número de dígitos na cadeia de caracteres de resultado.Precision specifier: Number of digits in the result string.

Para saber mais: O especificador de formato hexadecimal ("X").More information: The HexaDecimal ("X") Format Specifier.
255 ("X") -> FF255 ("X") -> FF

-1 ("x") -> ff-1 ("x") -> ff

255 ("x4") -> 00ff255 ("x4") -> 00ff

-1 ("X4") -> 00FF-1 ("X4") -> 00FF
Qualquer outro caractere únicoAny other single character Especificador desconhecidoUnknown specifier Resultado: Gera uma FormatException em tempo de execução.Result: Throws a FormatException at run time.

Usando Cadeias de Caracteres de Formato Numérico PadrãoUsing Standard Numeric Format Strings

Observação

Os exemplos de C# neste artigo são executados no executador de código embutido Try.NET e no playground.The C# examples in this article run in the Try.NET inline code runner and playground. Clique no botão Executar para executar um exemplo em uma janela interativa.Select the Run button to run an example in an interactive window. Ao executar o código, é possível modificá-lo e executar o código modificado clicando em Executar novamente.Once you execute the code, you can modify it and run the modified code by selecting Run again. 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#.The modified code either runs in the interactive window or, if compilation fails, the interactive window displays all C# compiler error messages.

Uma cadeia de caracteres de formato numérico padrão pode ser usada para definir a formatação de um valor numérico em uma de duas formas:A standard numeric format string can be used to define the formatting of a numeric value in one of two ways:

  • Ela pode ser passada para uma sobrecarga do método ToString que tem um parâmetro format.It can be passed to an overload of the ToString method that has a format parameter. 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).The following example formats a numeric value as a currency string in the current culture (in this case, the en-US culture).

    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.It can be supplied as the formatString argument in a format item used with such methods as String.Format, Console.WriteLine, and StringBuilder.AppendFormat. Para obter mais informações, veja Formatação de composição.For more information, see Composite Formatting. O exemplo a seguir usa um item de formato para inserir um valor de moeda em uma cadeia de caracteres.The following example uses a format item to insert a currency value in a string.

    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.Optionally, you can supply an alignment argument to specify the width of the numeric field and whether its value is right- or left-aligned. 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.The following example left-aligns a currency value in a 28-character field, and it right-aligns a currency value in a 14-character field.

    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.It can be supplied as the formatString argument in an interpolated expression item of an interpolated string. Para obter mais informações, consulte o tópico Interpolação de cadeia de caracteres na referência do C# ou o tópico Cadeias de caracteres interpoladas na referência do Visual Basic.For more information, see the String interpolation topic in the C# reference or the Interpolated strings topic in the Visual Basic reference.

As seções a seguir fornecem informações detalhadas sobre cada uma das cadeias de caracteres de formato numérico padrão.The following sections provide detailed information about each of the standard numeric format strings.

O Especificador de Formato da Moeda ("C")The Currency ("C") Format Specifier

O especificador de formato "C" (ou moeda) converte um número em uma cadeia de caracteres que representa um valor de moeda.The "C" (or currency) format specifier converts a number to a string that represents a currency amount. O especificador de precisão indica o número desejado de casas decimais na cadeia de caracteres resultante.The precision specifier indicates the desired number of decimal places in the result string. Se o especificador de precisão for omitido, a precisão padrão será definida pela propriedade NumberFormatInfo.CurrencyDecimalDigits.If the precision specifier is omitted, the default precision is defined by the NumberFormatInfo.CurrencyDecimalDigits property.

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.If the value to be formatted has more than the specified or default number of decimal places, the fractional value is rounded in the result string. 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.If the value to the right of the number of specified decimal places is 5 or greater, the last digit in the result string is rounded away from zero.

A cadeia de caracteres de resultado é afetada pelas informações de formatação do objeto NumberFormatInfo atual.The result string is affected by the formatting information of the current NumberFormatInfo object. A tabela a seguir lista as propriedades NumberFormatInfo que controlam a formatação da cadeia de caracteres retornada.The following table lists the NumberFormatInfo properties that control the formatting of the returned string.

Propriedade NumberFormatInfoNumberFormatInfo property DescriçãoDescription
CurrencyPositivePattern Define o posicionamento do símbolo de moeda para valores positivos.Defines the placement of the currency symbol for positive values.
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.Defines the placement of the currency symbol for negative values, and specifies whether the negative sign is represented by parentheses or the NegativeSign property.
NegativeSign Define o sinal de negativo usado se CurrencyNegativePattern indicar que parênteses não são usados.Defines the negative sign used if CurrencyNegativePattern indicates that parentheses are not used.
CurrencySymbol Define o símbolo de moeda.Defines the currency symbol.
CurrencyDecimalDigits Define o número padrão de dígitos decimais em um valor de moeda.Defines the default number of decimal digits in a currency value. Esse valor pode ser substituído usando-se o especificador de precisão.This value can be overridden by using the precision specifier.
CurrencyDecimalSeparator Define a cadeia de caracteres que separa dígitos decimais e integrais.Defines the string that separates integral and decimal digits.
CurrencyGroupSeparator Define a cadeia de caracteres que separa grupos de números integrais.Defines the string that separates groups of integral numbers.
CurrencyGroupSizes Define o número de dígitos inteiros que aparecem em um grupo.Defines the number of integer digits that appear in a group.

O exemplo a seguir formata um valor Double com o especificador de formato de moeda.The following example formats a Double value with the currency format specifier.

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

Voltar à tabelaBack to table

O Especificador de Formato Decimal ("D")The Decimal ("D") Format Specifier

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.The "D" (or decimal) format specifier converts a number to a string of decimal digits (0-9), prefixed by a minus sign if the number is negative. Esse formato é compatível apenas com tipos integrais.This format is supported only for integral types.

O especificador de precisão indica o número mínimo de dígitos desejados na cadeia de caracteres resultante.The precision specifier indicates the minimum number of digits desired in the resulting string. Se necessário, o número é preenchido com zeros à esquerda para produzir o número de dígitos fornecido pelo especificador de precisão.If required, the number is padded with zeros to its left to produce the number of digits given by the precision specifier. Quando nenhum especificador de precisão é especificado, o padrão é o valor mínimo necessário para representar o inteiro sem zeros à esquerda.If no precision specifier is specified, the default is the minimum value required to represent the integer without leading zeros.

A cadeia de caracteres de resultado é afetada pelas informações de formatação do objeto NumberFormatInfo atual.The result string is affected by the formatting information of the current NumberFormatInfo object. Conforme mostrado na tabela a seguir, uma única propriedade afeta a formatação da cadeia de caracteres de resultado.As the following table shows, a single property affects the formatting of the result string.

Propriedade NumberFormatInfoNumberFormatInfo property DescriçãoDescription
NegativeSign Define a cadeia de caracteres que indica que um número é negativo.Defines the string that indicates that a number is negative.

O exemplo a seguir formata um valor Int32 com o especificador de formato decimal.The following example formats an Int32 value with the decimal format specifier.

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

Voltar à tabelaBack to table

O Especificador de Formato Exponencial ("E")The Exponential ("E") Format Specifier

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).The exponential ("E") format specifier converts a number to a string of the form "-d.ddd…E+ddd" or "-d.ddd…e+ddd", where each "d" indicates a digit (0-9). A cadeia de caracteres é iniciada com um sinal de negativo se o número é negativo.The string starts with a minus sign if the number is negative. Exatamente um dígito sempre precede o ponto decimal.Exactly one digit always precedes the decimal point.

O especificador de precisão indica o número desejado de dígitos após o ponto decimal.The precision specifier indicates the desired number of digits after the decimal point. Quando o especificador de precisão é omitido, um padrão de seis dígitos após o ponto decimal é usado.If the precision specifier is omitted, a default of six digits after the decimal point is used.

A caixa do especificador de formato indica se o expoente é prefixado com um "E" ou um "e".The case of the format specifier indicates whether to prefix the exponent with an "E" or an "e". O expoente sempre consistem em um sinal de positivo ou negativo e um mínimo de três dígitos.The exponent always consists of a plus or minus sign and a minimum of three digits. O expoente é preenchido com zeros para atender a esse mínimo, se necessário.The exponent is padded with zeros to meet this minimum, if required.

A cadeia de caracteres de resultado é afetada pelas informações de formatação do objeto NumberFormatInfo atual.The result string is affected by the formatting information of the current NumberFormatInfo object. A tabela a seguir lista as propriedades NumberFormatInfo que controlam a formatação da cadeia de caracteres retornada.The following table lists the NumberFormatInfo properties that control the formatting of the returned string.

Propriedade NumberFormatInfoNumberFormatInfo property DescriçãoDescription
NegativeSign Define a cadeia de caracteres que indica que o número é negativo para o coeficiente e o expoente.Defines the string that indicates that a number is negative for both the coefficient and exponent.
NumberDecimalSeparator Define a cadeia de caracteres que separa o dígito integral dos dígitos decimais no coeficiente.Defines the string that separates the integral digit from decimal digits in the coefficient.
PositiveSign Define a cadeia de caracteres que indica que um expoente é positivo.Defines the string that indicates that an exponent is positive.

O exemplo a seguir formata um valor Double com o especificador de formato exponencial.The following example formats a Double value with the exponential format specifier.

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

Voltar à tabelaBack to table

O Especificador de Formato de Ponto Fixo ("F")The Fixed-Point ("F") Format Specifier

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).The fixed-point ("F") format specifier converts a number to a string of the form "-ddd.ddd…" where each "d" indicates a digit (0-9). A cadeia de caracteres é iniciada com um sinal de negativo se o número é negativo.The string starts with a minus sign if the number is negative.

O especificador de precisão indica o número de casas decimais desejadas.The precision specifier indicates the desired number of decimal places. Quando o especificador de precisão é omitido, a propriedade NumberFormatInfo.NumberDecimalDigits atual fornece a precisão numérica.If the precision specifier is omitted, the current NumberFormatInfo.NumberDecimalDigits property supplies the numeric precision.

A cadeia de caracteres de resultado é afetada pelas informações de formatação do objeto NumberFormatInfo atual.The result string is affected by the formatting information of the current NumberFormatInfo object. A tabela a seguir lista as propriedades do objeto NumberFormatInfo que controlam a formatação da cadeia de caracteres de resultado.The following table lists the properties of the NumberFormatInfo object that control the formatting of the result string.

Propriedade NumberFormatInfoNumberFormatInfo property DescriçãoDescription
NegativeSign Define a cadeia de caracteres que indica que um número é negativo.Defines the string that indicates that a number is negative.
NumberDecimalSeparator Define a cadeia de caracteres que separa dígitos integrais de dígitos decimais.Defines the string that separates integral digits from decimal digits.
NumberDecimalDigits Define o número padrão de dígitos decimais.Defines the default number of decimal digits. Esse valor pode ser substituído usando-se o especificador de precisão.This value can be overridden by using the precision specifier.

O exemplo a seguir formata um valor Double e um valor Int32 com o especificador de formato de ponto fixo.The following example formats a Double and an Int32 value with the fixed-point format specifier.

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                        

Voltar à tabelaBack to table

O Especificador de Formato Geral ("G")The General ("G") Format Specifier

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.The general ("G") format specifier converts a number to the more compact of either fixed-point or scientific notation, depending on the type of the number and whether a precision specifier is present. O especificador de precisão define o número máximo de dígitos significativos que podem aparecer na cadeia de caracteres de resultado.The precision specifier defines the maximum number of significant digits that can appear in the result string. 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.If the precision specifier is omitted or zero, the type of the number determines the default precision, as indicated in the following table.

Tipo numéricoNumeric type Precisão padrãoDefault precision
Byte ou SByteByte or SByte 3 dígitos3 digits
Int16 ou UInt16Int16 or UInt16 5 dígitos5 digits
Int32 ou UInt32Int32 or UInt32 10 dígitos10 digits
Int64 19 dígitos19 digits
UInt64 20 dígitos20 digits
BigInteger Ilimitado (igual a "R")Unlimited (same as "R")
Single 7 dígitos7 digits
Double 15 dígitos15 digits
Decimal 29 dígitos29 digits

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.Fixed-point notation is used if the exponent that would result from expressing the number in scientific notation is greater than -5 and less than the precision specifier; otherwise, scientific notation is used. Se necessário, o resultado contém um ponto decimal, e os zeros à direita após o ponto decimal são omitidos.The result contains a decimal point if required, and trailing zeros after the decimal point are omitted. 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.If the precision specifier is present and the number of significant digits in the result exceeds the specified precision, the excess trailing digits are removed by rounding.

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.However, if the number is a Decimal and the precision specifier is omitted, fixed-point notation is always used and trailing zeros are preserved.

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".If scientific notation is used, the exponent in the result is prefixed with "E" if the format specifier is "G", or "e" if the format specifier is "g". O expoente contém um mínimo de dois dígitos.The exponent contains a minimum of two digits. 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.This differs from the format for scientific notation that is produced by the exponential format specifier, which includes a minimum of three digits in the exponent.

Observe que, quando é usado com um valor Double, o especificador de formato "G17" garante que o valor de Double original faça a viagem de ida e volta com êxito.Note that, when used with a Double value, the "G17" format specifier ensures that the original Double value successfully round-trips. Isso ocorre porque Double é um número de ponto flutuante de precisão dupla compatível com IEEE 754 2008 (binary64) que oferece até 17 dígitos significativos de precisão.This is because Double is an IEEE 754-2008-compliant double-precision (binary64) floating point number that gives up to 17 significant digits of precision. Recomendamos seu uso em vez do especificador de formato "R", pois em alguns casos "R" não realiza a viagem de ida e volta dos valores de ponto flutuante de precisão dupla.We recommend its use instead of the "R" format specifier, since in some cases "R" fails to successfully round-trip double-precision floating point values. O exemplo a seguir ilustra esse caso.The following example illustrates one such case.

using System;

public class Example
{
   public static void Main()
   {
      // <SnippetGeneralFormatSpecifier>
      double original = 0.84551240822557006;
      var rSpecifier = original.ToString("R");
      var g17Specifier = original.ToString("G17");
      
      var rValue = Double.Parse(rSpecifier);
      var g17Value = Double.Parse(g17Specifier);
      
      Console.WriteLine($"{original:G17} = {rSpecifier} (R): {original.Equals(rValue)}");
      Console.WriteLine($"{original:G17} = {g17Specifier} (G17): {original.Equals(g17Value)}");
      // The example displays the following output:
      //     0.84551240822557006 = 0.84551240822557: False
      //     0.84551240822557006 = 0.84551240822557006: True
      // </SnippetGeneralFormatSpecifier>
   }
}
// The example displays the following output:
//     0.84551240822557006 = 0.84551240822557: False
//     0.84551240822557006 = 0.84551240822557006: True
Module Example
   Public Sub Main()
      Dim original As Double = 0.84551240822557006
      Dim rSpecifier = original.ToString("R")
      Dim g17Specifier = original.ToString("G17")
      
      Dim rValue = Double.Parse(rSpecifier)
      Dim g17Value = Double.Parse(g17Specifier)
      
      Console.WriteLine($"{original:G17} = {rSpecifier} (R): {original.Equals(rValue)}")
      Console.WriteLine($"{original:G17} = {g17Specifier} (G17): {original.Equals(g17Value)}")
   End Sub
End Module
' The example displays the following output:
'     0.84551240822557006 = 0.84551240822557 (R): False
'     0.84551240822557006 = 0.84551240822557006 (G17): True
  

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.When used with a Single value, the "G9" format specifier ensures that the original Single value successfully round-trips. Isso ocorre porque Single é um número de ponto flutuante com precisão única compatível com IEEE 754-2008 (binary32) que fornece até nove dígitos significativos de precisão.This is because Single is an IEEE 754-2008-compliant single-precision (binary32) floating point number that gives up to nine significant digits of precision. Por motivos de desempenho, recomendamos seu uso em vez do especificador de formato "R".For performance reasons, we recommend its use instead of the "R" format specifier.

A cadeia de caracteres de resultado é afetada pelas informações de formatação do objeto NumberFormatInfo atual.The result string is affected by the formatting information of the current NumberFormatInfo object. A tabela a seguir lista as propriedades NumberFormatInfo que controlam a formatação da cadeia de caracteres de resultado.The following table lists the NumberFormatInfo properties that control the formatting of the result string.

Propriedade NumberFormatInfoNumberFormatInfo property DescriçãoDescription
NegativeSign Define a cadeia de caracteres que indica que um número é negativo.Defines the string that indicates that a number is negative.
NumberDecimalSeparator Define a cadeia de caracteres que separa dígitos integrais de dígitos decimais.Defines the string that separates integral digits from decimal digits.
PositiveSign Define a cadeia de caracteres que indica que um expoente é positivo.Defines the string that indicates that an exponent is positive.

O exemplo a seguir formata valores de ponto flutuante variados com o especificador de formato geral.The following example formats assorted floating-point values with the general format specifier.

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    

Voltar à tabelaBack to table

O Especificador de Formato Numérico ("N")The Numeric ("N") Format Specifier

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.The numeric ("N") format specifier converts a number to a string of the form "-d,ddd,ddd.ddd…", where "-" indicates a negative number symbol if required, "d" indicates a digit (0-9), "," indicates a group separator, and "." indicates a decimal point symbol. O especificador de precisão indica o número desejado de dígitos após o ponto decimal.The precision specifier indicates the desired number of digits after the decimal point. Se o especificador de precisão for omitido, o número de casas decimais será definido pela propriedade NumberFormatInfo.NumberDecimalDigits atual.If the precision specifier is omitted, the number of decimal places is defined by the current NumberFormatInfo.NumberDecimalDigits property.

A cadeia de caracteres de resultado é afetada pelas informações de formatação do objeto NumberFormatInfo atual.The result string is affected by the formatting information of the current NumberFormatInfo object. A tabela a seguir lista as propriedades NumberFormatInfo que controlam a formatação da cadeia de caracteres de resultado.The following table lists the NumberFormatInfo properties that control the formatting of the result string.

Propriedade NumberFormatInfoNumberFormatInfo property DescriçãoDescription
NegativeSign Define a cadeia de caracteres que indica que um número é negativo.Defines the string that indicates that a number is negative.
NumberNegativePattern Define o formato dos valores negativos e especifica se o sinal de negativo é representado por parênteses ou a propriedade NegativeSign.Defines the format of negative values, and specifies whether the negative sign is represented by parentheses or the NegativeSign property.
NumberGroupSizes Define o número total de dígitos integrais que aparecem entre os separadores de grupo.Defines the number of integral digits that appear between group separators.
NumberGroupSeparator Define a cadeia de caracteres que separa grupos de números integrais.Defines the string that separates groups of integral numbers.
NumberDecimalSeparator Define a cadeia de caracteres que separa dígitos decimais e integrais.Defines the string that separates integral and decimal digits.
NumberDecimalDigits Define o número padrão de dígitos decimais.Defines the default number of decimal digits. Esse valor pode ser substituído usando um especificador de precisão.This value can be overridden by using a precision specifier.

O exemplo a seguir formata valores de ponto flutuante variados com o especificador de formato numérico.The following example formats assorted floating-point values with the number format specifier.

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 

Voltar à tabelaBack to table

O Especificador de Formato de Porcentagem ("P")The Percent ("P") Format Specifier

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.The percent ("P") format specifier multiplies a number by 100 and converts it to a string that represents a percentage. O especificador de precisão indica o número de casas decimais desejadas.The precision specifier indicates the desired number of decimal places. Se o especificador de precisão for omitido, a precisão numérica padrão fornecida pela propriedade PercentDecimalDigits atual será usada.If the precision specifier is omitted, the default numeric precision supplied by the current PercentDecimalDigits property is used.

A tabela a seguir lista as propriedades NumberFormatInfo que controlam a formatação da cadeia de caracteres retornada.The following table lists the NumberFormatInfo properties that control the formatting of the returned string.

Propriedade NumberFormatInfoNumberFormatInfo property DescriçãoDescription
PercentPositivePattern Define o posicionamento do símbolo de porcentagem para valores positivos.Defines the placement of the percent symbol for positive values.
PercentNegativePattern Define o posicionamento do símbolo de porcentagem e o símbolo negativo para valores negativos.Defines the placement of the percent symbol and the negative symbol for negative values.
NegativeSign Define a cadeia de caracteres que indica que um número é negativo.Defines the string that indicates that a number is negative.
PercentSymbol Define o símbolo de porcentagem.Defines the percent symbol.
PercentDecimalDigits Define o número padrão de dígitos decimais em um valor percentual.Defines the default number of decimal digits in a percentage value. Esse valor pode ser substituído usando-se o especificador de precisão.This value can be overridden by using the precision specifier.
PercentDecimalSeparator Define a cadeia de caracteres que separa dígitos decimais e integrais.Defines the string that separates integral and decimal digits.
PercentGroupSeparator Define a cadeia de caracteres que separa grupos de números integrais.Defines the string that separates groups of integral numbers.
PercentGroupSizes Define o número de dígitos inteiros que aparecem em um grupo.Defines the number of integer digits that appear in a group.

O exemplo a seguir formata valores de ponto flutuante variados com o especificador de formato de porcentagem.The following example formats floating-point values with the percent format specifier.

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 %

Voltar à tabelaBack to table

O Especificador de Formato da Viagem de Ida e Volta ("R")The Round-trip ("R") Format Specifier

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.The round-trip ("R") format specifier attempts to ensure that a numeric value that is converted to a string is parsed back into the same numeric value. Esse formato é compatível apenas com os tipos Single, Double e BigInteger.This format is supported only for the Single, Double, and BigInteger types.

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.For Double values, the "R" format specifier in some cases fails to successfully round-trip the original value. Para os valores Double e Single, ele também oferece desempenho relativamente baixo.For both Double and Single values, it also offers relatively poor performance. 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.Instead, we recommend that you use the "G17" format specifier for Double values and the "G9" format specifier to successfully round-trip Single values.

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.When a BigInteger value is formatted using this specifier, its string representation contains all the significant digits in the BigInteger value.

Embora você possa incluir um especificador de precisão, ele será ignorado.Although you can include a precision specifier, it is ignored. Idas e voltas têm precedência sobre a precisão quando esse especificador é usado.Round trips are given precedence over precision when using this specifier.
A cadeia de caracteres de resultado é afetada pelas informações de formatação do objeto NumberFormatInfo atual.The result string is affected by the formatting information of the current NumberFormatInfo object. A tabela a seguir lista as propriedades NumberFormatInfo que controlam a formatação da cadeia de caracteres de resultado.The following table lists the NumberFormatInfo properties that control the formatting of the result string.

Propriedade NumberFormatInfoNumberFormatInfo property DescriçãoDescription
NegativeSign Define a cadeia de caracteres que indica que um número é negativo.Defines the string that indicates that a number is negative.
NumberDecimalSeparator Define a cadeia de caracteres que separa dígitos integrais de dígitos decimais.Defines the string that separates integral digits from decimal digits.
PositiveSign Define a cadeia de caracteres que indica que um expoente é positivo.Defines the string that indicates that an exponent is positive.

O exemplo a seguir formata um valor BigInteger com o especificador de formato de ida e volta.The following example formats a BigInteger value with the round-trip format specifier.

#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.In some cases, Double values formatted with the "R" standard numeric format string do not successfully round-trip if compiled using the /platform:x64 or /platform:anycpu switches and run on 64-bit systems. Para saber mais, consulte o seguinte parágrafo.See the following paragraph for more information.

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".To work around the problem of Double values formatted with the "R" standard numeric format string not successfully round-tripping if compiled using the /platform:x64 or /platform:anycpu switches and run on 64-bit systems., you can format Double values by using the "G17" standard numeric format string. O exemplo a seguir usa a cadeia de caracteres de formato "R" com um valor Double que não realiza a viagem de ida e volta, e também usa a cadeia de caracteres de formato "G17" para realizar a viagem de ida e volta do valor original.The following example uses the "R" format string with a Double value that does not round-trip successfully, and also uses the "G17" format string to successfully round-trip the original value.

using System;
using System.Globalization;

public class Example
{
   static void Main(string[] args)
   {
      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

Voltar à tabelaBack to table

O Especificador de Formato Hexadecimal ("X")The Hexadecimal ("X") Format Specifier

O especificador de formato hexadecimal ("X") converte um número em uma cadeia de caracteres de dígitos hexadecimais.The hexadecimal ("X") format specifier converts a number to a string of hexadecimal digits. 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.The case of the format specifier indicates whether to use uppercase or lowercase characters for hexadecimal digits that are greater than 9. Por exemplo, use "X" para produzir "ABCDEF" e "x" para produzir "abcdef".For example, use "X" to produce "ABCDEF", and "x" to produce "abcdef". Esse formato é compatível apenas com tipos integrais.This format is supported only for integral types.

O especificador de precisão indica o número mínimo de dígitos desejados na cadeia de caracteres resultante.The precision specifier indicates the minimum number of digits desired in the resulting string. Se necessário, o número é preenchido com zeros à esquerda para produzir o número de dígitos fornecido pelo especificador de precisão.If required, the number is padded with zeros to its left to produce the number of digits given by the precision specifier.

A cadeia de caracteres do resultado não é afetada pelas informações de formatação do objeto NumberFormatInfo atual.The result string is not affected by the formatting information of the current NumberFormatInfo object.

O exemplo a seguir formata valores Int32 com o especificador de formato hexadecimal.The following example formats Int32 values with the hexadecimal format specifier.

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

Voltar à tabelaBack to table

ObservaçõesNotes

Configurações do Painel de ControleControl Panel Settings

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.The settings in the Regional and Language Options item in Control Panel influence the result string produced by a formatting operation. 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.Those settings are used to initialize the NumberFormatInfo object associated with the current thread culture, which provides values used to govern formatting. Computadores que usam configurações diferentes geram cadeias de caracteres de resultado diferentes.Computers that use different settings generate different result strings.

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.In addition, if the CultureInfo.CultureInfo(String) constructor is used to instantiate a new CultureInfo object that represents the same culture as the current system culture, any customizations established by the Regional and Language Options item in Control Panel will be applied to the new CultureInfo object. Você pode usar o construtor CultureInfo.CultureInfo(String, Boolean) para criar um objeto CultureInfo que não reflita as personalizações de um sistema.You can use the CultureInfo.CultureInfo(String, Boolean) constructor to create a CultureInfo object that does not reflect a system's customizations.

Propriedades de NumberFormatInfoNumberFormatInfo Properties

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.Formatting is influenced by the properties of the current NumberFormatInfo object, which is provided implicitly by the current thread culture or explicitly by the IFormatProvider parameter of the method that invokes formatting. Especifique um objeto NumberFormatInfo ou CultureInfo para esse parâmetro.Specify a NumberFormatInfo or CultureInfo object for that parameter.

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.For information about customizing the patterns or strings used in formatting numeric values, see the NumberFormatInfo class topic.

Tipos numéricos integrais e de ponto flutuanteIntegral and Floating-Point Numeric Types

Algumas descrições de especificadores de formato numérico padrão referem-se a tipos inteiros ou de ponto flutuante.Some descriptions of standard numeric format specifiers refer to integral or floating-point numeric types. Os tipos numéricos integrais são Byte, SByte, Int16, Int32, Int64, UInt16, UInt32, UInt64 e BigInteger.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.The floating-point numeric types are Decimal, Single, and Double.

Infinitos de ponto flutuante e NaNFloating-Point Infinities and NaN

Independentemente da cadeia de caracteres de formato, se o valor de um tipo de ponto flutuante Single ou Double é infinito positivo, infinito negativo ou um não é um número (NaN), a cadeia de caracteres formatada é o valor das respectivas propriedades PositiveInfinitySymbol, NegativeInfinitySymbol ou NaNSymbol especificadas pelo objeto NumberFormatInfo aplicável no momento.Regardless of the format string, if the value of a Single or Double floating-point type is positive infinity, negative infinity, or not a number (NaN), the formatted string is the value of the respective PositiveInfinitySymbol, NegativeInfinitySymbol, or NaNSymbol property that is specified by the currently applicable NumberFormatInfo object.

ExemploExample

Observação

Alguns dos exemplos de C# neste artigo são executados no executador de código embutido Try.NET e no playground.Some of the C# examples in this article run in the Try.NET inline code runner and playground. Clique no botão Executar para executar um exemplo em uma janela interativa.Select the Run button to run an example in an interactive window. Ao executar o código, é possível modificá-lo e executar o código modificado clicando em Executar novamente.Once you execute the code, you can modify it and run the modified code by selecting Run again. 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#.The modified code either runs in the interactive window or, if compilation fails, the interactive window displays all C# compiler error messages.

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.The following example formats an integral and a floating-point numeric value using the en-US culture and all the standard numeric format specifiers. Este exemplo usa dois tipos numéricos específicos, (Double e Int32), mas poderia produzir resultados semelhantes para qualquer um dos tipos base numéricos (Byte, SByte, Int16, Int32, Int64, UInt16, UInt32, UInt64, BigInteger, Decimal e Single).This example uses two particular numeric types (Double and Int32), but would yield similar results for any of the other numeric base types (Byte, SByte, Int16, Int32, Int64, UInt16, UInt32, UInt64, BigInteger, Decimal, and Single).

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();
   }
}
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émSee also