Wie runde ich einen Dezimalwert auf 2 Dezimalstellen (für die Ausgabe auf einer Seite)
https://stackoverflow.com/questions/164926
italiano
english
français
española
中国
日本の
العربية
Deutsch
한국어
Português
RussianFrage
Wenn Sie den Wert einer Dezimalstelle angezeigt werden derzeit mit .ToString(), es genau ist 15 Dezimalstellen zu mögen, und da ich es bin mit Dollar und Cent repräsentieren, ich will nur die Ausgabe 2 Dezimalstellen sein.
verwende ich eine Variation von .ToString() für das?
Lösung
decimalVar.ToString ("#.##"); // returns "" when decimalVar == 0
oder
decimalVar.ToString ("0.##"); // returns "0" when decimalVar == 0
Andere Tipps
Ich weiß, dass dies eine alte Frage, aber ich war überrascht, dass niemand eine Antwort zu schreiben schien;
- Haben Sie nicht Banker verwenden Rundung
- Haben Sie den Wert als Dezimalzahl nicht halten.
Das ist, was ich verwende:
decimal.Round(yourValue, 2, MidpointRounding.AwayFromZero);
decimalVar.ToString("F");
Dies wird:
- Abrunden auf 2 Dezimalstellen zB. 23,456 => 23,46
- Stellen Sie sicher, dass es sind immer zwei Dezimalstellen z. 23 => 23.00, 12.5 => 12,50
Ideal für Währung und Anzeige von Geldbeträgen.
Für die Dokumentation auf ToString ( "F"): http://msdn.microsoft.com/en-us/library/dwhawy9k%28v=vs.110%29.aspx#FFormatString (mit dank an Jon Schneider)
Wenn Sie gerade benötigen diese für die Anzeige verwenden string.Format
String.Format("{0:0.00}", 123.4567m); // "123.46"
http://www.csharp-examples.net/string-format-double /
Der "m" ist eine Dezimalzahl Suffix. Über das Dezimalsystem Suffix:
Bei Dezimal d = 12.345; die Ausdrücke d.ToString ( "C") oder String.Format ( "{0: C}", d ) Ertrag 12,35 $ -. beachten Sie, dass die Währungseinstellungen der aktuellen Kultur des Symbol darunter verwendet werden
Beachten Sie, dass "C" verwendet Anzahl der Stellen von aktueller Kultur. Sie können jederzeit außer Kraft setzen Standard notwendige Präzision mit C{Precision specifier} wie String.Format("{0:C2}", 5.123d) zu erzwingen.
Wenn Sie es mit Komma sowie ein Komma (, aber kein Währungssymbol) formatiert mögen, wie 3,456,789.12 ...
decimalVar.ToString("n2");
Es gibt bereits zwei Wertungs Antworten, die auf Decimal.Round beziehen (...), aber ich denke, ein wenig mehr Erklärung benötigt wird - weil es eine unerwartete wichtige Eigenschaft von Dezimal, die nicht offensichtlich ist
.Ein Dezimalwert ‚weiß‘, wie viele Dezimalstellen hat, basierend auf, wo es herkam.
Zum Beispiel kann folgende unerwartet sein:
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"
die gleichen Operationen mit Double Dadurch wird für jeden der oben keine Nachkommastellen ("25") geben.
Wenn Sie eine Dezimalzahl auf 2 Dezimalstellen Theres über eine 95% ige Chance wollen ist es, weil es Währung ist in diesem Fall ist dies wahrscheinlich für 95% der Zeit in Ordnung ist:
Decimal.Parse("25.0").ToString("c") => "$25.00"
oder in XAML verwenden Sie einfach {Binding Price, StringFormat=c}
Ein Fall, den ich lief in dem ich eine Dezimalzahl benötigt als Dezimalzahl war, als XML Amazon Webservice zu senden. Der Service beschwert, weil ein Dezimalwert (ursprünglich von SQL Server) als 25.1200 gesendet werden und abgelehnt (25.12 war das erwartete Format).
Alles, was ich gebraucht wurde mit 2 Dezimalstellen zu tun Decimal.Round(...) das Problem zu beheben.
// This is an XML message - with generated code by XSD.exe
StandardPrice = new OverrideCurrencyAmount()
{
TypedValue = Decimal.Round(product.StandardPrice, 2),
currency = "USD"
}
TypedValue ist vom Typ Decimal so konnte ich nicht nur ToString("N2") tun und brauchte es abzurunden und es als decimal zu halten.
Hier ist ein kleines LINQPad Programm in verschiedenen Formaten anzeigen:
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("===================");
}
Hier sind die Ergebnisse:
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
===================
Keiner von ihnen genau das tat, was ich brauchte, zu zwingen 2 D. P. und aufrunden als 0.005 -> 0.01
Erzwingen 2 d.p. erfordert die Genauigkeit durch Erhöhen 2 d.p. um sicherzustellen, dass wir mindestens 2 d.p. haben
dann, um sicherzustellen, Rundung uns nicht mehr als 2 D. P haben.
Math.Round(exactResult * 1.00m, 2, MidpointRounding.AwayFromZero)
6.665m.ToString() -> "6.67"
6.6m.ToString() -> "6.60"
Sehr selten würden Sie eine leere Zeichenfolge wollen, wenn der Wert 0 ist.
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"
Die am besten bewertete Antwort ist falsch und hat 10 Minuten von den (meisten) Menschen Zeit verschwendet.
Die top-rated Antwort beschreibt ein Verfahren zur Formatierung der String-Darstellung des Dezimalwerts, und es funktioniert.
Wenn Sie jedoch tatsächlich die Genauigkeit auf den aktuellen Wert gespeichert ändern möchten, müssen Sie so etwas wie die folgende schreiben:
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;
}
}
Ein Beispiel Unit-Test:
[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"));
}
Sie können System.Globalization verwenden, um eine Zahl in jedem gewünschten Format zu formatieren.
Beispiel:
system.globalization.cultureinfo ci = new system.globalization.cultureinfo("en-ca");
Wenn Sie eine decimal d = 1.2300000 und Sie müssen es trimmen auf 2 Dezimalstellen dann kann es wie dieses d.Tostring("F2",ci); aufzudrucken, in dem F2-String Formatierung auf 2 Dezimalstellen und ci ist das Gebietsschema oder Culture.
Für weitere Informationen lesen Sie in diesem Link
http://msdn.microsoft.com/en-us/library/dwhawy9k.aspx
Mike M. Antwort war perfekt für mich auf .NET, aber .NET Kern kein decimal.Round Verfahren haben zum Zeitpunkt des Schreibens.
In .NET-Core, musste ich verwenden:
decimal roundedValue = Math.Round(rawNumber, 2, MidpointRounding.AwayFromZero);
A hacky Verfahren, einschließlich der Umwandlung zu bespannen ist:
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
Dieser Link erklärt im Detail, wie Sie Ihr Problem umgehen können und was Sie tun können, wenn Sie mehr erfahren möchten. Der Einfachheit halber, was Sie tun möchten, ist
double whateverYouWantToChange = whateverYouWantToChange.ToString("F2");
Wenn Sie dies für eine Währung möchten, können Sie es einfacher machen, indem „C2“ anstelle von „F2“
eingeben