Cadeias de formato numérico padrão
As cadeias de formato numérico padrão são utilizadas para formatar tipos numéricos comuns. Uma cadeia de formato numérico padrão assume o formulário [format specifier][precision specifier], em que:
O especificador de formato é um único caráter alfabético que especifica o tipo de formato de número, por exemplo, moeda ou percentagem. Qualquer cadeia de formato numérico que contenha mais do que um caráter alfabético, incluindo espaço em branco, é interpretada como uma cadeia de formato numérico personalizado. Para obter mais informações, veja Cadeias de formato numérico personalizado.
O especificador de precisão é um número inteiro opcional que afeta o número de dígitos na cadeia resultante. No .NET 7 e versões posteriores, o valor máximo de precisão é 999.999.999. No .NET 6, o valor máximo de precisão é Int32.MaxValue. Nas versões anteriores do .NET, a precisão pode variar entre 0 e 99. O especificador de precisão controla o número de dígitos na representação da cadeia de carateres de um número. Não arredonda o número propriamente dito. Para executar uma operação de arredondamento, utilize o Math.Ceilingmétodo , Math.Floorou Math.Round .
Quando o especificador de precisão controla o número de dígitos fracionários na cadeia de resultado, a cadeia de resultado reflete um número arredondado para um resultado representável mais próximo do resultado infinitamente preciso. Se existirem dois resultados igualmente quase representáveis:
- No .NET Framework e .NET Core até .NET Core 2.0, o runtime seleciona o resultado com o dígito menos significativo (ou seja, com MidpointRounding.AwayFromZero).
- No .NET Core 2.1 e posterior, o runtime seleciona o resultado com um dígito ainda menos significativo (ou seja, com MidpointRounding.ToEven).
Nota
O especificador de precisão determina o número de dígitos na cadeia de resultados. Para colocar uma cadeia de resultados com espaços à esquerda ou à direita, utilize a funcionalidade de formatação composta e defina um componente de alinhamento no item de formato.
As cadeias de formato numérico padrão são suportadas por:
Algumas sobrecargas do
ToStringmétodo de todos os tipos numéricos. Por exemplo, pode fornecer uma cadeia de formato numérico aos Int32.ToString(String) métodos e Int32.ToString(String, IFormatProvider) .O
TryFormatmétodo de todos os tipos numéricos, por exemplo, Int32.TryFormat(Span<Char>, Int32, ReadOnlySpan<Char>, IFormatProvider) e Single.TryFormat(Span<Char>, Int32, ReadOnlySpan<Char>, IFormatProvider).A funcionalidade de formatação composta .NET, que é utilizada por alguns
WriteeWriteLinemétodos das Console classes e StreamWriter , o String.Format método e o StringBuilder.AppendFormat método. A funcionalidade de formato composto permite-lhe incluir a representação de cadeia de carateres de vários itens de dados numa única cadeia, especificar a largura do campo e alinhar números num campo. Para obter mais informações, veja Formatação Composta.Cadeias interpoladas em C# e Visual Basic, que fornecem uma sintaxe simplificada quando comparadas com cadeias de formato composto.
Dica
Pode transferir o Utilitário de Formatação, uma aplicação de Windows Forms .NET Core que lhe permite aplicar cadeias de formatação a valores numéricos ou de data e hora e apresenta a cadeia de resultados. O código fonte está disponível para C# e Visual Basic.
Especificadores de formato padrão
A tabela seguinte descreve os especificadores de formato numérico padrão e apresenta o resultado de exemplo produzido por cada especificador de formato. Veja a secção Notas para obter informações adicionais sobre a utilização de cadeias de formato numérico padrão e a secção De exemplo código para obter uma ilustração abrangente da respetiva utilização.
O resultado de uma cadeia formatada para uma cultura específica pode ser diferente dos seguintes exemplos. As definições do sistema operativo, as definições do utilizador, as variáveis de ambiente e a versão .NET que está a utilizar podem afetar o formato. Por exemplo, a partir do .NET 5, o .NET tenta unificar formatos culturais entre plataformas. Para obter mais informações, veja Globalização e UCI do .NET.
| Especificador de formato | Nome | Descrição | Exemplos |
|---|---|---|---|
| "B" ou "b" | Binário | Resultado: uma cadeia binária. Suportado por: Apenas tipos integrais (.NET 8+). Especificador de precisão: número de dígitos na cadeia de resultados. Mais informações: O Especificador de Formato Binário ("B"). |
42 ("B") -> 101010 255 ("b16") -> 0000000011111111 |
| "C" ou "c" | Moeda | Resultado: um valor de moeda. Suportado por: Todos os tipos numéricos. Especificador de precisão: número de dígitos decimais. Especificador de precisão predefinido: definido por NumberFormatInfo.CurrencyDecimalDigits. Mais informações: O Especificador de Formato 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. Suportado por: Apenas tipos integrais. Especificador de precisão: número mínimo de dígitos. Especificador de precisão predefinido: número mínimo de dígitos necessário. Mais informações: O Especificador de Formato Decimal("D"). |
1234 ("D") -> 1234 -1234 ("D6") -> -001234 |
| "E" ou "e" | Exponencial (científico) | Resultado: Notação exponencial. Suportado por: Todos os tipos numéricos. Especificador de precisão: número de dígitos decimais. Especificador de precisão predefinido: 6. Mais informações: O Especificador de Formato Exponencial ("E"). |
1052.0329112756 ("E", en-US) -> 1.052033E+003 1052.0329112756 ("e", fr-FR) -> 1,052033e+003 -1052.0329112756 ("e2", en-US) -> -1,05e+003 -1052.0329112756 ("E2", fr-FR) -> -1,05E+003 |
| "F" ou "f" | Ponto fixo | Resultado: Dígitos integrais e decimais com sinal negativo opcional. Suportado por: Todos os tipos numéricos. Especificador de precisão: número de dígitos decimais. Especificador de precisão predefinido: definido por NumberFormatInfo.NumberDecimalDigits. Mais informações: O Especificador de Formato Fixed-Point ("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: o mais compacto de notação de ponto fixo ou científico. Suportado por: Todos os tipos numéricos. Especificador de precisão: número de dígitos significativos. Especificador de precisão predefinido: depende do tipo numérico. Mais informações: O Especificador de Formato Geral ("G"). |
-123.456 ("G", en-US) -> -123.456 -123.456 ("G", sv-SE) -> -123.456 123.4546 ("G4", en-US) -> 123.5 123.4546 ("G4", sv-SE) -> 123,5 -1.234567890e-25 ("G", en-US) -> -1.23456789E-25 -1.234567890e-25 ("G", sv-SE) -> -1,23456789E-25 |
| "N" ou "n" | Número | Resultado: Dígitos integrais e decimais, separadores de grupo e separador decimal com sinal negativo opcional. Suportado por: Todos os tipos numéricos. Especificador de precisão: número pretendido de casas decimais. Especificador de precisão predefinido: definido por NumberFormatInfo.NumberDecimalDigits. Mais informações: O Especificador de Formato Numérico ("N"). |
1234.567 ("N", en-US) -> 1,234,57 1234.567 ("N", ru-RU) -> 1 234,57 1234 ("N1", en-US) -> 1,234.0 1234 ("N1", ru-RU) -> 1 234,0 -1234.56 ("N3", en-US) -> -1,234.560 -1234.56 ("N3", ru-RU) -> -1 234.560 |
| "P" ou "p" | Percentagem | Resultado: Número multiplicado por 100 e apresentado com um símbolo de percentagem. Suportado por: Todos os tipos numéricos. Especificador de precisão: número pretendido de casas decimais. Especificador de precisão predefinido: definido por NumberFormatInfo.PercentDecimalDigits. Mais informações: o Especificador de Formato Percentagem ("P"). |
1 ("P", en-US) -> 100,00 % 1 ("P", fr-FR) -> 100,00 % -0,39678 ("P1", en-US) -> -39,7 % -0,39678 ("P1", fr-FR) -> -39,7 % |
| "R" ou "r" | Ida e volta | Resultado: uma cadeia que pode fazer um percurso de ida e volta para um número idêntico. Suportado por: Single, Doublee BigInteger. Nota: recomendado apenas para o BigInteger tipo. Para Double tipos, utilize "G17"; para Single tipos, utilize "G9". Especificador de precisão: ignorado. Mais informações: O 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 hexadecimal. Suportado por: Apenas tipos integrais. Especificador de precisão: número de dígitos na cadeia de resultados. Mais informações: O Especificador de Formato Hexadecimal ("X"). |
255 ("X") -> FF -1 ("x") -> ff 255 ("x4") -> 00ff -1 ("X4") -> 00FF |
| Qualquer outro caráter único | Especificador desconhecido | Resultado: lança um FormatException no tempo de execução. |
Utilizar cadeias de formato numérico padrão
Nota
Os exemplos de C# neste artigo são executados no Try.NET linha de código inline e playground. Selecione o botão Executar para executar um exemplo numa janela interativa. Depois de executar o código, pode modificá-lo e executar o código modificado ao selecionar Executar novamente. O código modificado é executado na janela interativa ou, se a compilação falhar, a janela interativa apresenta todas as mensagens de erro do compilador C#.
Uma cadeia de formato numérico padrão pode ser utilizada para definir a formatação de um valor numérico de uma das seguintes formas:
Pode ser transmitido para o
TryFormatmétodo ou uma sobrecarga doToStringmétodo que tem umformatparâmetro. O exemplo seguinte formata um valor numérico como uma cadeia de moeda na cultura atual (neste caso, a cultura en-US).Decimal value = static_cast<Decimal>(123.456); Console::WriteLine(value.ToString("C2")); // Displays $123.46decimal value = 123.456m; Console.WriteLine(value.ToString("C2")); // Displays $123.46Dim value As Decimal = 123.456d Console.WriteLine(value.ToString("C2")) ' Displays $123.46Pode ser fornecido como o
formatStringargumento num item de formato utilizado com métodos como String.Format, Console.WriteLinee StringBuilder.AppendFormat. Para obter mais informações, veja Formatação Composta. O exemplo seguinte utiliza um item de formato para inserir um valor de moeda numa cadeia.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, pode fornecer um
alignmentargumento para especificar a largura do campo numérico e se o respetivo valor está alinhado à direita ou à esquerda. O exemplo seguinte alinha à esquerda um valor de moeda num campo de 28 carateres e alinha à direita um valor de moeda num campo de 14 carateres.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.16decimal[] 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.16Dim 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.16Pode ser fornecido como argumento
formatStringnum item de expressão interpolada de uma cadeia interpolada. Para obter mais informações, veja o artigo Interpolação de cadeias na referência C# ou no artigo Cadeias interpoladas na referência do Visual Basic.
As secções seguintes fornecem informações detalhadas sobre cada uma das cadeias de formato numérico padrão.
Especificador de formato binário (B)
O especificador de formato binário ("B") converte um número numa cadeia de dígitos binários. Este formato é suportado apenas para tipos integrais e apenas em .NET 8+.
O especificador de precisão indica o número mínimo de dígitos pretendidos na cadeia resultante. Se necessário, o número é acolchoado com zeros à esquerda para produzir o número de dígitos fornecido pelo especificador de precisão.
A cadeia de resultado não é afetada pelas informações de formatação do objeto atual NumberFormatInfo .
Especificador de formato de moeda (C)
O especificador de formato "C" (ou moeda) converte um número numa cadeia que representa um valor monetário. O especificador de precisão indica o número pretendido de casas decimais na cadeia de resultado. Se o especificador de precisão for omitido, a precisão predefinida é definida pela NumberFormatInfo.CurrencyDecimalDigits propriedade .
Se o valor a formatar tiver mais do que o número de casas decimais especificado ou predefinido, o valor fracionário é arredondado na cadeia de resultado. Se o valor à direita do número de casas decimais especificadas for 5 ou superior, o último dígito na cadeia de resultado é arredondado para longe de zero.
A cadeia de resultado é afetada pelas informações de formatação do objeto atual NumberFormatInfo . A tabela seguinte lista as NumberFormatInfo propriedades que controlam a formatação da cadeia devolvida.
| Propriedade NumberFormatInfo | Descrição |
|---|---|
| CurrencyPositivePattern | Define o posicionamento do símbolo de moeda para valores positivos. |
| CurrencyNegativePattern | Define o posicionamento do símbolo de moeda para valores negativos e especifica se o sinal negativo é representado por parênteses ou pela NegativeSign propriedade . |
| NegativeSign | Define o sinal negativo utilizado se CurrencyNegativePattern indicar que os parênteses não são utilizados. |
| CurrencySymbol | Define o símbolo de moeda. |
| CurrencyDecimalDigits | Define o número predefinido de dígitos decimais num valor monetário. Este valor pode ser substituído com o especificador de precisão. |
| CurrencyDecimalSeparator | Define a cadeia que separa os dígitos integrais e decimais. |
| CurrencyGroupSeparator | Define a cadeia que separa grupos de números integrais. |
| CurrencyGroupSizes | Define o número de dígitos inteiros que aparecem num grupo. |
O exemplo seguinte 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 numa cadeia de dígitos decimais (0-9), com o prefixo de um sinal de subtração se o número for negativo. Este formato é suportado apenas para tipos integrais.
O especificador de precisão indica o número mínimo de dígitos pretendidos na cadeia resultante. Se necessário, o número é acolchoado com zeros à esquerda para produzir o número de dígitos fornecido pelo especificador de precisão. Se não for especificado nenhum especificador de precisão, a predefinição é o valor mínimo necessário para representar o número inteiro sem zeros à esquerda.
A cadeia de resultado é afetada pelas informações de formatação do objeto atual NumberFormatInfo . Como mostra a tabela seguinte, uma única propriedade afeta a formatação da cadeia de resultado.
| Propriedade NumberFormatInfo | Descrição |
|---|---|
| NegativeSign | Define a cadeia que indica que um número é negativo. |
O exemplo seguinte formata um Int32 valor 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 de formato exponencial ("E") converte um número numa cadeia do formulário "-d.ddd... E+ddd" ou "-d.ddd... e+ddd", em que cada "d" indica um dígito (0-9). A cadeia começa com um sinal de subtração se o número for negativo. Exatamente um dígito precede sempre a vírgula decimal.
O especificador de precisão indica o número pretendido de dígitos após a vírgula decimal. Se o especificador de precisão for omitido, é predefinida seis dígitos após a utilização da vírgula decimal.
As maiúsculas/minúsculas do especificador de formato indicam se o prefixo do expoente é "E" ou "e". O expoente é sempre composto por um sinal de adição ou subtração e um mínimo de três dígitos. O expoente é acolchoado com zeros para cumprir este mínimo, se necessário.
A cadeia de resultado é afetada pelas informações de formatação do objeto atual NumberFormatInfo . A tabela seguinte lista as NumberFormatInfo propriedades que controlam a formatação da cadeia devolvida.
| Propriedade NumberFormatInfo | Descrição |
|---|---|
| NegativeSign | Define a cadeia que indica que um número é negativo tanto para o coeficiente como para o expoente. |
| NumberDecimalSeparator | Define a cadeia que separa o dígito integral dos dígitos decimais no coeficiente. |
| PositiveSign | Define a cadeia que indica que um expoente é positivo. |
O exemplo seguinte 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 numa cadeia do formulário "-ddd.ddd..." em que cada "d" indica um dígito (0-9). A cadeia começa com um sinal de subtração se o número for negativo.
O especificador de precisão indica o número pretendido de casas decimais. Se o especificador de precisão for omitido, a propriedade atual NumberFormatInfo.NumberDecimalDigits fornece a precisão numérica.
A cadeia de resultado é afetada pelas informações de formatação do objeto atual NumberFormatInfo . A tabela seguinte lista as propriedades do NumberFormatInfo objeto que controlam a formatação da cadeia de resultado.
| Propriedade NumberFormatInfo | Descrição |
|---|---|
| NegativeSign | Define a cadeia que indica que um número é negativo. |
| NumberDecimalSeparator | Define a cadeia que separa os dígitos integrais dos dígitos decimais. |
| NumberDecimalDigits | Define o número predefinido de dígitos decimais. Este valor pode ser substituído com o especificador de precisão. |
O exemplo seguinte formata um Double valor e com Int32 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 o mais compacto de notação de ponto fixo ou científico, consoante o 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 resultado. Se o especificador de precisão for omitido ou zero, o tipo do número determina a precisão predefinida, conforme indicado na tabela seguinte.
| Tipo numérico | Precisão predefinida |
|---|---|
| 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 | Menor número de dígitos arredondados para representar o número |
| Single | Menor número de dígitos arredondados para representar o número (em .NET Framework, G7 é a predefinição) |
| Double | Menor número de dígitos arredondados para representar o número (em .NET Framework, G15 é a predefinição) |
| Decimal | Menor número de dígitos arredondados para representar o número |
A notação de ponto fixo é utilizada se o expoente que resultaria da expressão do número na notação científica for superior a -5 e inferior ao especificador de precisão; caso contrário, a notação científica é utilizada. O resultado contém um ponto decimal, se necessário, e zeros à direita após a omissão da vírgula decimal. 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 é removido por arredondamento.
No entanto, se o número for um Decimal e o especificador de precisão for omitido, a notação de ponto fixo é sempre utilizada e os zeros à direita são preservados.
Se for utilizada notação científica, o expoente no resultado é prefixo 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. Isto difere do formato de notação científica produzido pelo especificador de formato exponencial, que inclui um mínimo de três dígitos no expoente.
Quando utilizado com um Double valor, o especificador de formato "G17" garante que o valor original Double é de ida e volta com êxito. Isto deve-se Double ao facto de ser um número de vírgula flutuante compatível com IEEE 754-2008 (binary64) que dá até 17 dígitos significativos de precisão. No .NET Framework, recomendamos a sua utilização em vez do especificador de formato "R", uma vez que, em alguns casos, "R" não consegue fazer a ida e volta com êxito de valores de vírgula flutuante de dupla precisão.
Quando utilizado com um Single valor, o especificador de formato "G9" garante que o valor original Single é de ida e volta com êxito. Isto deve-se Single ao facto de ser um número de vírgula flutuante compatível com IEEE 754-2008 (binary32) que dá até nove dígitos significativos de precisão. Por motivos de desempenho, recomendamos a sua utilização em vez do especificador de formato "R".
A cadeia de resultados é afetada pelas informações de formatação do objeto atual NumberFormatInfo . A tabela seguinte lista as NumberFormatInfo propriedades que controlam a formatação da cadeia de resultados.
| Propriedade NumberFormatInfo | Descrição |
|---|---|
| NegativeSign | Define a cadeia que indica que um número é negativo. |
| NumberDecimalSeparator | Define a cadeia que separa os dígitos integrais dos dígitos decimais. |
| PositiveSign | Define a cadeia que indica que um expoente é positivo. |
O exemplo seguinte formata vários valores de vírgula flutuante 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 numa cadeia do formulário "-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 grupo e "" indica um símbolo de ponto decimal. O especificador de precisão indica o número pretendido de dígitos após a vírgula decimal. Se o especificador de precisão for omitido, o número de casas decimais é definido pela propriedade atual NumberFormatInfo.NumberDecimalDigits .
A cadeia de resultados é afetada pelas informações de formatação do objeto atual NumberFormatInfo . A tabela seguinte lista as NumberFormatInfo propriedades que controlam a formatação da cadeia de resultados.
| Propriedade NumberFormatInfo | Descrição |
|---|---|
| NegativeSign | Define a cadeia que indica que um número é negativo. |
| NumberNegativePattern | Define o formato dos valores negativos e especifica se o sinal negativo é representado por parênteses ou pela NegativeSign propriedade. |
| NumberGroupSizes | Define o número de dígitos integrais que aparecem entre separadores de grupo. |
| NumberGroupSeparator | Define a cadeia que separa grupos de números integrais. |
| NumberDecimalSeparator | Define a cadeia que separa os dígitos integrais e decimais. |
| NumberDecimalDigits | Define o número predefinido de dígitos decimais. Este valor pode ser substituído com um especificador de precisão. |
O exemplo seguinte formata vários valores de vírgula flutuante 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 percentagem (P)
O especificador de formato percentagem ("P") multiplica um número por 100 e converte-o numa cadeia que representa uma percentagem. O especificador de precisão indica o número pretendido de casas decimais. Se o especificador de precisão for omitido, é utilizada a precisão numérica predefinida fornecida pela propriedade atual PercentDecimalDigits .
A tabela seguinte lista as NumberFormatInfo propriedades que controlam a formatação da cadeia devolvida.
| Propriedade NumberFormatInfo | Descrição |
|---|---|
| PercentPositivePattern | Define a colocação do símbolo de percentagem para valores positivos. |
| PercentNegativePattern | Define a colocação do símbolo de percentagem e o símbolo negativo para valores negativos. |
| NegativeSign | Define a cadeia que indica que um número é negativo. |
| PercentSymbol | Define o símbolo de percentagem. |
| PercentDecimalDigits | Define o número predefinido de dígitos decimais num valor percentual. Este valor pode ser substituído com o especificador de precisão. |
| PercentDecimalSeparator | Define a cadeia que separa os dígitos integrais e decimais. |
| PercentGroupSeparator | Define a cadeia que separa grupos de números integrais. |
| PercentGroupSizes | Define o número de dígitos inteiros que aparecem num grupo. |
O exemplo seguinte formata valores de vírgula flutuante com o especificador de formato de percentagem:
double number = .2468013;
Console::WriteLine(number.ToString("P", CultureInfo::InvariantCulture));
// Displays 24.68 %
Console::WriteLine(number.ToString("P",
CultureInfo::CreateSpecificCulture("hr-HR")));
// Displays 24,68%
Console::WriteLine(number.ToString("P1", CultureInfo::InvariantCulture));
// Displays 24.7 %
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 numa cadeia é analisado novamente no mesmo valor numérico. Este formato é suportado apenas para os Halftipos , Single, Doublee BigInteger .
No .NET Framework e em versões do .NET Core anteriores à versão 3.0, o especificador de formato "R" não consegue, em alguns casos, obter valores de ida Double e volta com êxito. Para valores e valores DoubleSingle , o especificador de formato "R" oferece um desempenho relativamente fraco. Em vez disso, recomendamos que utilize o especificador de formato "G17" para Double valores e o especificador de formato "G9" para valores de ida Single e volta com êxito.
Quando um BigInteger valor é formatado com este especificador, a representação da cadeia contém todos os dígitos significativos no BigInteger valor.
Embora possa incluir um especificador de precisão, este é ignorado. As viagens de ida e volta têm precedência sobre a precisão ao utilizar este especificador. A cadeia de resultados é afetada pelas informações de formatação do objeto atual NumberFormatInfo . A tabela seguinte lista as NumberFormatInfo propriedades que controlam a formatação da cadeia de resultados.
| Propriedade NumberFormatInfo | Descrição |
|---|---|
| NegativeSign | Define a cadeia que indica que um número é negativo. |
| NumberDecimalSeparator | Define a cadeia que separa os dígitos integrais dos dígitos decimais. |
| PositiveSign | Define a cadeia que indica que um expoente é positivo. |
O exemplo seguinte formata um BigInteger valor 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, Double os valores formatados com a cadeia de formato numérico padrão "R" não são executados com êxito se forem compilados com os /platform:x64 parâmetros ou /platform:anycpu e executados em sistemas de 64 bits. Veja o parágrafo seguinte para obter mais informações.
Para contornar o problema dos Double valores formatados com a cadeia de formato numérico padrão "R" que não é arredondada com êxito se for compilada com os /platform:x64 parâmetros ou /platform:anycpu e executada em sistemas de 64 bits, pode formatar Double valores com a cadeia de formato numérico padrão "G17". O exemplo seguinte utiliza a cadeia de formato "R" com um Double valor que não faz ida e volta com êxito e também utiliza a cadeia de formato "G17" para percorrer com êxito o 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 numa cadeia de dígitos hexadecimais. O caso do especificador de formato indica se deve utilizar carateres em maiúsculas ou minúsculas para dígitos hexadecimais superiores a 9. Por exemplo, utilize "X" para produzir "ABCDEF" e "x" para produzir "abcdef". Este formato é suportado apenas para tipos integrais.
O especificador de precisão indica o número mínimo de dígitos pretendidos na cadeia resultante. Se necessário, o número é acolchoado com zeros à esquerda para produzir o número de dígitos fornecidos pelo especificador de precisão.
A cadeia de resultados não é afetada pelas informações de formatação do objeto atual NumberFormatInfo .
O exemplo seguinte 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
Notas
Esta secção contém informações adicionais sobre a utilização de cadeias de formato numérico padrão.
definições de Painel de Controlo
As definições no item Opções Regionais e de Idioma no Painel de Controlo influenciar a cadeia de resultados produzida por uma operação de formatação. Essas definições são utilizadas para inicializar o NumberFormatInfo objeto associado à cultura atual, que fornece valores utilizados para governar a formatação. Os computadores que utilizam definições diferentes geram cadeias de resultados diferentes.
Além disso, se o CultureInfo(String) construtor for utilizado para instanciar um novo CultureInfo objeto que represente a mesma cultura da cultura do sistema atual, todas as personalizações estabelecidas pelo item Opções Regionais e de Idioma no Painel de Controlo serão aplicadas ao novo CultureInfo objeto. Pode utilizar o CultureInfo(String, Boolean) construtor para criar um CultureInfo objeto que não reflita as personalizações de um sistema.
Propriedades NumberFormatInfo
A formatação é influenciada pelas propriedades do objeto atual NumberFormatInfo , que é fornecido implicitamente pela cultura atual ou explicitamente pelo IFormatProvider parâmetro do método que invoca a formatação. Especifique um NumberFormatInfo objeto ou CultureInfo para esse parâmetro.
Nota
Para obter informações sobre como personalizar os padrões ou cadeias utilizados na formatação de valores numéricos, consulte o tópico de NumberFormatInfo classe.
Tipos numéricos integrais e de vírgula flutuante
Algumas descrições dos especificadores de formato numérico padrão referem-se a tipos numéricos integrais ou de vírgula flutuante. Os tipos numéricos integrais são Byte, SByte, Int16, Int32, Int64, UInt16, UInt32, UInt64e BigInteger. Os tipos numéricos de vírgula flutuante são Decimal, Half, Singlee Double.
Infinitos de vírgula flutuante e NaN
Independentemente da cadeia de formato, se o valor de um Halftipo , Singleou Double vírgula flutuante for infinito positivo, infinito negativo ou não um número (NaN), a cadeia formatada é o valor da respetiva PositiveInfinitySymbolpropriedade , NegativeInfinitySymbolou NaNSymbol especificada pelo objeto atualmente aplicável NumberFormatInfo .
Exemplo de código
O exemplo seguinte formata um valor numérico integral e de vírgula flutuante com a cultura en-US e todos os especificadores de formato numérico padrão. Este exemplo utiliza dois tipos numéricos específicos (Double e ), mas produziria resultados semelhantes para qualquer um dos outros tipos de base numéricas (Byte, SByte, , Int32Int16, Int64, UInt16, UInt32, BigIntegerUInt64, Decimal, Halfe Single).Int32
// 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
Ver também
Comentários
Brevemente: Ao longo de 2024, vamos descontinuar progressivamente o GitHub Issues como mecanismo de feedback para conteúdos e substituí-lo por um novo sistema de feedback. Para obter mais informações, veja: https://aka.ms/ContentUserFeedback.
Submeter e ver comentários