Atunci când se afișează valoarea zecimală în prezent cu .ToString()
, l's corecte la 15 zecimale, și de când am'm folosind-o pentru a reprezenta dolari și cenți, vreau doar ieșire să fie de 2 zecimale.
Folosesc o variație de `.ToString () pentru asta?
Știu că este o întrebare veche, dar am fost surprins să văd că nimeni nu părea să posta un răspuns;
Aceasta este ceea ce mi-ar folosi:
decimal.Round(yourValue, 2, MidpointRounding.AwayFromZero);
decimalVar.ToString("F");
Acest lucru va:
Ideal pentru valută și afișarea sume de bani.
Pentru documentare pe ToString("F"): http://msdn.microsoft.com/en-us/library/dwhawy9k%28v=vs.110%29.aspx#FFormatString (cu mulțumiri pentru Jon Schneider)
Dacă aveți nevoie doar pentru uz de afișare șir.Format
String.Format("{0:0.00}", 123.4567m); // "123.46"
http://www.csharp-examples.net/string-format-double/
"m" este o zecimală sufix. Despre sufixul zecimal:
Dat zecimal d=12.345; expresii d.ToString("C") sau String.Format("{0:D}", d) randament $12.35 - notă că actuala cultură's valută setări, inclusiv simbolul sunt folosite.
Rețineți că "C" utilizează numărul de cifre din cultura actuală. Întotdeauna puteți suprascrie implicit pentru a forța necesară de precizie cu C{specificator de Precizie} " ca " Șir de caractere.Format("{0:C2}", 5.123 d)
.
Nu's deja două mari notare răspunsuri care se referă la Zecimale.Rotund (...), dar cred că un pic mai mult explicație este necesară - pentru că nu's o neașteptată proprietate importantă de Zecimale care nu't de evident.
O zecimal 'stie' câte zecimale are la bază de unde a venit.
De exemplu, următoarele pot fi neașteptate :
Decimal.Parse("25").ToString() => "25"
Decimal.Parse("25.").ToString() => "25"
Decimal.Parse("25.0").ToString() => "25.0"
Decimal.Parse("25.0000").ToString() => "25.0000"
25m.ToString() => "25"
25.000m.ToString() => "25.000"
Fac aceleași operații cu "Dublu" va da fără zecimale (`"25") pentru fiecare dintre cele de mai sus.
Atunci când doriți o zecimal la 2 zecimale e aproximativ 95% șanse să-l's, deoarece's valută în cazul în care acest lucru este, probabil, bine pentru 95% din timp:
Decimal.Parse("25.0").ToString("c") => "$25.00"
Sau în XAML utilizați doar {Preț Obligatorii, StringFormat=c}
Un singur caz am fugit în cazul în care am nevoie de un zecimale cu zecimale fost la trimiterea XML pentru Amazon's webservice. Serviciul a fost proteste pentru ca o valoare Zecimală (originar din SQL Server) a fost trimis ca 25.1200
și a respins, (25.12
era de așteptat format).
Tot ce trebuia să fac era `Zecimale.Rotund (...) cu 2 zecimale pentru a rezolva problema.
// This is an XML message - with generated code by XSD.exe
StandardPrice = new OverrideCurrencyAmount()
{
TypedValue = Decimal.Round(product.StandardPrice, 2),
currency = "USD"
}
TypedValue
este de tip Zecimal
, asa ca am putut't doar ToString("N2") și necesare pentru a rundă-l și păstrați-l ca un zecimal`.
Aici este un pic Linqpad program pentru a afișa diferite formate:
void Main()
{
FormatDecimal(2345.94742M);
FormatDecimal(43M);
FormatDecimal(0M);
FormatDecimal(0.007M);
}
public void FormatDecimal(decimal val)
{
Console.WriteLine("ToString: {0}", val);
Console.WriteLine("c: {0:c}", val);
Console.WriteLine("0.00: {0:0.00}", val);
Console.WriteLine("0.##: {0:0.##}", val);
Console.WriteLine("===================");
}
Aici sunt rezultatele:
ToString: 2345.94742
c: $2,345.95
0.00: 2345.95
0.##: 2345.95
===================
ToString: 43
c: $43.00
0.00: 43.00
0.##: 43
===================
ToString: 0
c: $0.00
0.00: 0.00
0.##: 0
===================
ToString: 0.007
c: $0.01
0.00: 0.01
0.##: 0.01
===================
Foarte rar ti-ai dori un șir gol dacă valoarea este 0.
decimal test = 5.00;
test.ToString("0.00"); //"5.00"
decimal? test2 = 5.05;
test2.ToString("0.00"); //"5.05"
decimal? test3 = 0;
test3.ToString("0.00"); //"0.00"
În partea de sus evaluat răspunsul este incorect și-a irosit 10 minute de (cele mai) oamenii's timp.
Nici unul dintre acestea a făcut exact ceea ce am nevoie, pentru a forța 2 d.p. și rotund ca 0.005 -> 0.01
Forțându-2 d.p. necesită creșterea precizie de 2 d.p. pentru a ne asigura că aveți cel puțin 2 d.p.
apoi rotunjire pentru a ne asigura că nu au mai mult de 2 d.p.
Math.Round(exactResult * 1.00m, 2, MidpointRounding.AwayFromZero)
6.665m.ToString() -> "6.67"
6.6m.ToString() -> "6.60"
Top-evaluat răspunsul descrie o metodă pentru formatarea șir de reprezentare de valoarea zecimală, și funcționează.
Cu toate acestea, dacă chiar vrei pentru a schimba precizie a salvat de la valoarea reală, aveți nevoie pentru a scrie ceva de genul următor:
public static class PrecisionHelper
{
public static decimal TwoDecimalPlaces(this decimal value)
{
// These first lines eliminate all digits past two places.
var timesHundred = (int) (value * 100);
var removeZeroes = timesHundred / 100m;
// In this implementation, I don't want to alter the underlying
// value. As such, if it needs greater precision to stay unaltered,
// I return it.
if (removeZeroes != value)
return value;
// Addition and subtraction can reliably change precision.
// For two decimal values A and B, (A + B) will have at least as
// many digits past the decimal point as A or B.
return removeZeroes + 0.01m - 0.01m;
}
}
Un exemplu de test de unitate:
[Test]
public void PrecisionExampleUnitTest()
{
decimal a = 500m;
decimal b = 99.99m;
decimal c = 123.4m;
decimal d = 10101.1000000m;
decimal e = 908.7650m
Assert.That(a.TwoDecimalPlaces().ToString(CultureInfo.InvariantCulture),
Is.EqualTo("500.00"));
Assert.That(b.TwoDecimalPlaces().ToString(CultureInfo.InvariantCulture),
Is.EqualTo("99.99"));
Assert.That(c.TwoDecimalPlaces().ToString(CultureInfo.InvariantCulture),
Is.EqualTo("123.40"));
Assert.That(d.TwoDecimalPlaces().ToString(CultureInfo.InvariantCulture),
Is.EqualTo("10101.10"));
// In this particular implementation, values that can't be expressed in
// two decimal places are unaltered, so this remains as-is.
Assert.That(e.TwoDecimalPlaces().ToString(CultureInfo.InvariantCulture),
Is.EqualTo("908.7650"));
}
Puteți utiliza sistemul.globalizarea a format un număr, în orice format necesar.
De exemplu:
system.globalization.cultureinfo ci = new system.globalization.cultureinfo("en-ca");
Dacă aveți o zecimal d = 1.2300000
și ai nevoie să-l tăiați la 2 zecimale, atunci acesta poate fi imprimat ca acest `d.Tostring("F2",ci); unde F2 este șir ării la 2 zecimale și ci este locale sau cultureinfo.
pentru mai multe informații verificați acest link http://msdn.microsoft.com/en-us/library/dwhawy9k.aspx
Mike M.'s a răspunde a fost perfect pentru mine .NET, dar .NET Core nu't au o zecimală.Runda metoda la momentul de scris.
În .NET Core, am avut de a utiliza:
decimal roundedValue = Math.Round(rawNumber, 2, MidpointRounding.AwayFromZero);
O minge de metodă, inclusiv conversia la string, este:
public string FormatTo2Dp(decimal myNumber)
{
// Use schoolboy rounding, not bankers.
myNumber = Math.Round(myNumber, 2, MidpointRounding.AwayFromZero);
return string.Format("{0:0.00}", myNumber);
}
https://msdn.microsoft.com/en-us/library/dwhawy9k%28v=vs.110%29.aspx
Această legătură explică în detaliu cum puteți ocupa de problema ta și ce puteți face dacă doriți să aflați mai multe. Din motive de simplitate, ce vrei să faci este
double whateverYouWantToChange = whateverYouWantToChange.ToString("F2");
dacă doriți acest lucru pentru o monedă, puteți face mai ușor prin tastarea "C2" în loc de "F2"