Bei der Anzeige der Wert eines Dezimal derzeit mit .ToString()
, es ist genau wie 15 Dezimalstellen, und da ich es verwenden, um Dollar und Cent zu vertreten, ich will nur die Ausgabe auf 2 Dezimalstellen sein.
Kann ich dafür eine Variante von "ToString()" verwenden?
decimalVar.ToString ("#.##"); // returns "" when decimalVar == 0
oder
decimalVar.ToString ("0.##"); // returns "0" when decimalVar == 0
Ich weiß, dass dies eine alte Frage ist, aber ich war überrascht zu sehen, dass niemand eine Antwort darauf zu geben schien;
Hatn't den Wert als Dezimalzahl beibehalten.
Dies würde ich verwenden:
decimal.Round(yourValue, 2, MidpointRounding.AwayFromZero);
decimalVar.ToString("F");
Dies wird:
Ideal für Währungen und die Anzeige von Geldbeträgen.
Für die Dokumentation zu ToString("F"): http://msdn.microsoft.com/en-us/library/dwhawy9k%28v=vs.110%29.aspx#FFormatString (mit Dank an Jon Schneider)
Wenn Sie dies nur zur Anzeige benötigen, verwenden Sie string.Format
String.Format("{0:0.00}", 123.4567m); // "123.46"
http://www.csharp-examples.net/string-format-double/
Das "m" ist ein Dezimalsuffix. Über das Dezimalsuffix:
Gegeben dezimal d=12.345; die Ausdrücke d.ToString("C") oder String.Format("{0:C}", d) ergeben $12.35 - beachten Sie, dass die aktuellen Währungseinstellungen der Kultur's einschließlich des Symbols verwendet werden.
Beachten Sie, dass "C" die Anzahl der Ziffern aus der aktuellen Kultur verwendet.
Sie können die Vorgabe jederzeit außer Kraft setzen, um die erforderliche Präzision mit C{Präzisionsangabe}
wie String.Format("{0:C2}", 5.123d)
zu erzwingen.
Wenn Sie es sowohl mit Kommas als auch mit einem Dezimalpunkt (aber ohne Währungssymbol) formatiert haben möchten, wie z.B. 3.456.789,12...
decimalVar.ToString("n2");
Es gibt's bereits zwei Antworten mit hoher Punktzahl, die sich auf Decimal.Round(...) beziehen, aber ich denke, es bedarf etwas mehr Erklärung - weil es's eine unerwartete wichtige Eigenschaft von Decimal gibt, die't offensichtlich ist.
Eine Dezimale 'weiß' wie viele Dezimalstellen es hat, je nachdem, wo es herkommt.
Zum Beispiel kann das 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"
Wenn Sie die gleichen Operationen mit Double
durchführen, erhalten Sie keine Dezimalstellen ("25"
) für jede der obigen Operationen.
Wenn Sie eine Nachkommastelle mit 2 Nachkommastellen wünschen, besteht eine Wahrscheinlichkeit von 95%, dass es's ist, weil es's Währung ist, in welchem Fall dies wahrscheinlich für 95% der Zeit in Ordnung ist:
Decimal.Parse("25.0").ToString("c") => "$25.00"
Oder Sie verwenden in XAML einfach `{Binding Price, StringFormat=c}``
Ein Fall, in dem ich einen Dezimal-AS brauchte, war beim Senden von XML an den Webservice von Amazon's.
Der Dienst beschwerte sich, weil ein Dezimalwert (ursprünglich von SQL Server) als 25.1200
gesendet und abgelehnt wurde (25.12
war das erwartete Format).
Alles, was ich tun musste, war Decimal.Round(...)
mit 2 Dezimalstellen, um 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
, also konnte ich'nicht einfach ToString("N2")
machen und musste es runden und als Decimal
beibehalten.
Hier ist ein kleines Linqpad-Programm zur Anzeige verschiedener 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("===================");
}
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
===================
Sehr selten würden Sie eine leere Zeichenfolge wünschen, 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 verschwendet's Zeit.
Keiner von ihnen tat genau das, was ich brauchte, um 2 d.p. zu erzwingen und auf 0,005 ->. aufzurunden; 0.01
2 d.p. erzwingen erfordert eine Erhöhung der Genauigkeit um 2 d.p. um sicherzustellen, dass wir mindestens 2 d.p. haben.
dann eine Rundung, um sicherzustellen, dass wir 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"
Die am besten bewertete Antwort beschreibt eine Methode zur Formatierung der Zeichenkettendarstellung des Dezimalwerts, und sie funktioniert.
Wenn Sie jedoch tatsächlich die gespeicherte Genauigkeit auf den tatsächlichen Wert ändern wollen, müssen Sie etwas wie das 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 für einen 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.
Zum Beispiel:
system.globalization.cultureinfo ci = new system.globalization.cultureinfo("en-ca");
Wenn Sie ein dezimales d = 1,2300000
haben und es auf 2 Dezimalstellen abschneiden müssen, kann es wie folgt gedruckt werden: d.Tostring("F2",ci);
wobei F2 die Zeichenkettenformatierung auf 2 Dezimalstellen und ci das Gebietsschema oder die Kulturinfo ist.
Weitere Informationen finden Sie unter diesem Link http://msdn.microsoft.com/en-us/library/dwhawy9k.aspx
Mike M.'s Antwort war für mich auf .NET perfekt, aber .NET Core hat zum Zeitpunkt des Schreibens keine `dezimale.Runde'-Methode.
In .NET Core musste ich diese Methode verwenden:
decimal roundedValue = Math.Round(rawNumber, 2, MidpointRounding.AwayFromZero);
Eine hackige Methode, einschließlich der Konvertierung in Strings, 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 mit Ihrem 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 wünschen, können Sie es einfacher machen, indem Sie "C2" eingeben; anstelle von "F2" eingeben;
Double Amount = 0;
string amount;
amount=string.Format("{0:F2}", Decimal.Parse(Amount.ToString()));