.NET String.Format () para adicionar vírgulas em milhares de lugares para um número

Quero adicionar uma vírgula na casa dos milhares para um número.

String.Format()?

String.Format("{0:n}", 1234);  // Output: 1,234.00
String.Format("{0:n0}", 9876); // No digits after the decimal point. Output: 9,876

Eu achei que essa era a maneira mais simples:

myInteger.ToString("N0")

int number = 1000000000;
string whatYouWant = number.ToString("#,##0");
//You get: 1,000,000,000

Se você deseja uma cultura específica, tente:

(19950000.0).ToString("N",new CultureInfo("en-US")) = 19.950.000,00

(19950000.0).ToString("N",new CultureInfo("is-IS")) = 19.950.000,00

Nota: Algumas culturas ,costumam significar decimal, em vez de .ter cuidado.

Formatos padrão, com suas saídas relacionadas,

Console.WriteLine("Standard Numeric Format Specifiers");
String s = String.Format("(C) Currency: . . . . . . . . {0:C}\n" +
                    "(D) Decimal:. . . . . . . . . {0:D}\n" +
                    "(E) Scientific: . . . . . . . {1:E}\n" +
                    "(F) Fixed point:. . . . . . . {1:F}\n" +
                    "(G) General:. . . . . . . . . {0:G}\n" +
                    "    (default):. . . . . . . . {0} (default = 'G')\n" +
                    "(N) Number: . . . . . . . . . {0:N}\n" +
                    "(P) Percent:. . . . . . . . . {1:P}\n" +
                    "(R) Round-trip: . . . . . . . {1:R}\n" +
                    "(X) Hexadecimal:. . . . . . . {0:X}\n",
                    - 1234, -1234.565F);
Console.WriteLine(s);

Exemplo de saída (cultura en-us):

(C) Currency: . . . . . . . . ($1,234.00)
(D) Decimal:. . . . . . . . . -1234
(E) Scientific: . . . . . . . -1.234565E+003
(F) Fixed point:. . . . . . . -1234.57
(G) General:. . . . . . . . . -1234
    (default):. . . . . . . . -1234 (default = 'G')
(N) Number: . . . . . . . . . -1,234.00
(P) Percent:. . . . . . . . . -123,456.50 %
(R) Round-trip: . . . . . . . -1234.565
(X) Hexadecimal:. . . . . . . FFFFFB2E

Este é o melhor formato. Funciona em todos os casos:

String.Format( "{0:#,##0.##}", 0 ); // 0
String.Format( "{0:#,##0.##}", 0.5 ); // 0.5 - some of the formats above fail here. 
String.Format( "{0:#,##0.##}", 12314 ); // 12,314
String.Format( "{0:#,##0.##}", 12314.23123 ); // 12,314.23
String.Format( "{0:#,##0.##}", 12314.2 ); // 12,314.2
String.Format( "{0:#,##0.##}", 1231412314.2 ); // 1,231,412,314.2

String.Format("{0:#,###,###.##}", MyNumber)

Isso lhe dará vírgulas nos pontos relevantes.

A resposta mais votada foi ótima e é útil há cerca de 7 anos. Com a introdução do C # 6.0 e, especificamente, a Interpolação de cadeias, existe uma maneira mais limpa e, mais segura da IMO, de fazer o que foi solicitado to add commas in thousands place for a number:

var i = 5222000;
var s = $"{i:n} is the number"; // results to > 5,222,000.00 is the number
s = $"{i:n0} has no decimal"; // results to > 5,222,000 has no decimal

Onde a variável i é colocada no lugar do espaço reservado (ou seja {0}). Portanto, não há necessidade de lembrar qual objeto vai para qual posição. A formatação (ou seja :n) não mudou. Para um recurso completo das novidades, você pode acessar esta página .

Simples assim:

float num = 23658; // for example 
num = num.ToString("N0"); // Returns 23,658

mais informações estão aqui

Se você deseja forçar um separador "," independentemente da cultura (por exemplo, em uma mensagem de rastreamento ou log), o código a seguir funcionará e terá o benefício adicional de informar ao próximo cara que o encontra exatamente o que está fazendo.

int integerValue = 19400320; 
string formatted = string.Format(CultureInfo.InvariantCulture, "{0:N0}", integerValue);

conjuntos formatados para "19.400.320"

O exemplo a seguir exibe vários valores formatados usando seqüências de caracteres personalizadas que incluem zero espaços reservados.

String.Format("{0:N1}", 29255.0);

Ou

29255.0.ToString("N1")

resultado "29.255,0"

String.Format("{0:N2}", 29255.0);

Ou

29255.0.ToString("N2")

resultado "29.255,00"

int num = 98765432;
Console.WriteLine(string.Format("{0:#,#}", num));

Mais simples, usando interpolação de string em vez de String.Format

 $"{12456:n0}"; // 12,456
 $"{12456:n2}"; // 12,456.00

ou usando yourVariable

 double yourVariable = 12456.0;
 $"{yourVariable:n0}"; 
 $"{yourVariable:n2}"; 

Por exemplo String.Format("{0:0,0}", 1); retorna 01, para mim não é válido

Isso funciona para mim

19950000.ToString("#,#", CultureInfo.InvariantCulture));

produção 19.950.000

Observe que o valor que você está formatando deve ser numérico. Não parece que será necessária uma representação em seqüência de um número e o formato é com vírgulas.

String.Format("0,###.###"); also works with decimal places

O C # 7.1 (talvez mais cedo?) Torna isso o mais fácil e bonito possível, com interpolação de string:

var jackpot = 1000000;
var niceNumberString = $"Jackpot is {jackpot:n}";
var niceMoneyString = $"Jackpot is {jackpot:C}";

Você pode usar uma função como esta para formatar números e, opcionalmente, passar nas casas decimais desejadas. Se as casas decimais não forem especificadas, serão usadas duas casas decimais.

    public static string formatNumber(decimal valueIn=0, int decimalPlaces=2)
    {
        return string.Format("{0:n" + decimalPlaces.ToString() + "}", valueIn);
    }

Eu uso decimal, mas você pode alterar o tipo para qualquer outro ou usar um objeto anônimo. Você também pode adicionar uma verificação de erro para valores negativos de casas decimais.

O método que eu costumava não me preocupar mais com culturas e possíveis problemas de formatação é que eu o formatei como moeda e depois retirei o símbolo da moeda.

if (decimal.TryParse(tblCell, out result))

{
  formattedValue = result.ToString("C").Substring(1);
}

Abaixo está uma boa solução em Java!

NumberFormat fmt = NumberFormat.getCurrencyInstance();
System.out.println(fmt.format(n));

ou, de uma maneira mais robusta, convém obter o código de idioma de um local específico e use como abaixo:

int n=9999999;
Locale locale = new Locale("en", "US");
NumberFormat fmt = NumberFormat.getCurrencyInstance(locale);
System.out.println(fmt.format(n));

NOSLocalidade SAÍDA: US $ 9.999.999,00

Saída local alemã

Locale locale = new Locale("de", "DE");

SAÍDA: 9.999.999,00 €

Saída local indiana

Locale locale = new Locale("de", "DE");

SAÍDA: R $ 999.999,00

Saída local da Estônia

Locale locale = new Locale("et", "EE");

SAÍDA: 9 999 999 €

Como você pode ver em diferentes saídas, não precisa se preocupar com o separador como vírgula ou ponto ou mesmo espaço. Você pode obter o número formatado de acordo com os padrões i18n

Se você deseja mostrá-lo no DataGridview, você deve alterar seu tipo, porque o padrão é String e, como você o altera para decimal, considera como Número com ponto flutuante

Dim dt As DataTable = New DataTable
dt.Columns.Add("col1", GetType(Decimal))
dt.Rows.Add(1)
dt.Rows.Add(10)
dt.Rows.Add(2)

DataGridView1.DataSource = dt