.NET String.Format () pour ajouter des virgules en milliers pour un nombre

Je veux ajouter une virgule à la place des milliers pour un nombre.

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

J'ai trouvé que c'était le moyen le plus simple:

myInteger.ToString("N0")

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

Si vous voulez une culture spécifique, vous pouvez essayer ceci:

(19950000.0).ToString("N",new CultureInfo("en-US")) = 19 950 000,00

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

Remarque: Certaines cultures ,signifient décimales plutôt que d' .être prudent.

Formats standard, avec leurs sorties associées,

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

Exemple de sortie (culture 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

C'est le meilleur format. Fonctionne dans tous ces cas:

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)

Cela vous donnera des virgules aux points pertinents.

La réponse la plus votée était excellente et utile depuis environ 7 ans. Avec l'introduction de C # 6.0 et plus précisément de l'interpolation de chaînes, il existe un moyen plus net et, plus sûr, de faire ce qui a été demandé 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

Où la variable i est mise en place de l'espace réservé (ie {0}). Il n'est donc pas nécessaire de se rappeler quel objet va dans quelle position. Le formatage (ie :n) n'a pas changé. Pour une fonctionnalité complète des nouveautés, vous pouvez aller sur cette page .

aussi simple que cela:

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

plus d'informations sont ici

Si vous souhaitez forcer un séparateur "," quelle que soit la culture (par exemple dans un message de trace ou de journal), le code suivant fonctionnera et aura l'avantage supplémentaire de dire au gars suivant qui tombe dessus exactement ce que vous faites.

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

ensembles formatés à "19 400 320"

L'exemple suivant affiche plusieurs valeurs mises en forme à l'aide de chaînes de format personnalisé qui incluent zéro espace réservé.

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

Ou

29255.0.ToString("N1")

résultat "29 255,0"

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

Ou

29255.0.ToString("N2")

résultat "29 255,00"

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

Plus simple, en utilisant l'interpolation de chaînes au lieu de String.Format

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

ou en utilisant votreVariable

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

Par exemple, String.Format("{0:0,0}", 1);renvoie 01, pour moi n'est pas valide

Ça marche pour moi

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

sortie 19,950,000

Notez que la valeur que vous formatez doit être numérique. Il ne semble pas qu'il faudra une représentation sous forme de chaîne d'un nombre et le format est avec des virgules.

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

C # 7.1 (peut-être plus tôt?) Rend cela aussi simple et agréable qu'il devrait l'être, avec une interpolation de chaîne:

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

Vous pouvez utiliser une fonction comme celle-ci pour formater les nombres et éventuellement passer les décimales souhaitées. Si aucune décimale n'est spécifiée, elle utilise deux décimales.

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

J'utilise décimal mais vous pouvez changer le type en n'importe quel autre ou utiliser un objet anonyme. Vous pouvez également ajouter une vérification d'erreur pour les valeurs de décimales négatives.

La méthode que j'ai utilisée pour ne plus me soucier des cultures et des problèmes de formatage potentiels est que je l'ai formatée en devise et j'ai ensuite retiré le symbole monétaire.

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

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

Voici une bonne solution en Java!

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

ou pour un moyen plus robuste, vous pouvez obtenir les paramètres régionaux d'un lieu particulier, puis utilisez comme ci-dessous:

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

US Locale OUTPUT: 9 999 999,00 $

Sortie locale allemande

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

SORTIE: 9.999.999,00 €

Sortie locale indienne

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

SORTIE: Rs.9,999,999.00

Sortie en langue locale estonienne

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

SORTIE: 9999 999 €

Comme vous pouvez le voir dans différentes sorties, vous n'avez pas à vous soucier du séparateur qui est une virgule ou un point ou même un espace, vous pouvez obtenir le nombre formaté selon les normes i18n

Si vous souhaitez l'afficher dans DataGridview, vous devez modifier son type, car la valeur par défaut est String et puisque vous le modifiez en décimal, il le considère comme un nombre avec virgule flottante.

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