How do I display a decimal value to 2 decimal places?

C# Problem Overview

When displaying the value of a decimal currently with .ToString(), it's accurate to like 15 decimal places, and since I'm using it to represent dollars and cents, I only want the output to be 2 decimal places.

Do I use a variation of .ToString() for this?

C# Solutions

Solution 1 - C#

decimalVar.ToString("#.##"); // returns ".5" when decimalVar == 0.5m

decimalVar.ToString("0.##"); // returns "0.5"  when decimalVar == 0.5m

decimalVar.ToString("0.00"); // returns "0.50"  when decimalVar == 0.5m

Solution 2 - C#

I know this is an old question, but I was surprised to see that no one seemed to post an answer that;

Didn't use bankers rounding
Keeps the value as a decimal.

This is what I would use:

decimal.Round(yourValue, 2, MidpointRounding.AwayFromZero);

http://msdn.microsoft.com/en-us/library/9s0xa85y.aspx

Solution 3 - C#

decimalVar.ToString("F");

This will:

Round off to 2 decimal places eg. 23.456 → 23.46
Ensure that there are always 2 decimal places eg. 23 → 23.00; 12.5 → 12.50

Ideal for displaying currency.

Check out the documentation on ToString("F") (thanks to Jon Schneider).

Solution 4 - C#

If you just need this for display use string.Format

String.Format("{0:0.00}", 123.4567m);      // "123.46"

http://www.csharp-examples.net/string-format-double/

The "m" is a decimal suffix. About the decimal suffix:

http://msdn.microsoft.com/en-us/library/364x0z75.aspx

Solution 5 - C#

Given decimal d=12.345; the expressions d.ToString("C") or String.Format("{0:C}", d) yield $12.35 - note that the current culture's currency settings including the symbol are used.

Note that "C" uses number of digits from current culture. You can always override default to force necessary precision with C{Precision specifier} like String.Format("{0:C2}", 5.123d).

Solution 6 - C#

If you want it formatted with commas as well as a decimal point (but no currency symbol), such as 3,456,789.12...

decimalVar.ToString("n2");

Solution 7 - C#

There's a very important characteristic of Decimal that isn't obvious:

> A Decimal 'knows' how many decimal places it has based upon where it came from

The following may be unexpected :

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"

Doing the same operations with Double will result in zero decimal places ("25") for all of the above examples.

If you want a decimal to 2 decimal places there's a high likelyhood it's because it's currency in which case this is probably fine for 95% of the time:

Decimal.Parse("25.0").ToString("c")     =>   "$25.00"

Or in XAML you would use {Binding Price, StringFormat=c}

One case I ran into where I needed a decimal AS a decimal was when sending XML to Amazon's webservice. The service was complaining because a Decimal value (originally from SQL Server) was being sent as 25.1200 and rejected, (25.12 was the expected format).

All I needed to do was Decimal.Round(...) with 2 decimal places to fix the problem regardless of the source of the value.

 // generated code by XSD.exe
 StandardPrice = new OverrideCurrencyAmount()
 {
       TypedValue = Decimal.Round(product.StandardPrice, 2),
       currency = "USD"
 }

TypedValue is of type Decimal so I couldn't just do ToString("N2") and needed to round it and keep it as a decimal.

Solution 8 - C#

Here is a little Linqpad program to show different formats:

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("===================");
}

Here are the results:

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
===================

Solution 9 - C#

Math.Round Method (Decimal, Int32)

Solution 10 - C#

Mike M.'s answer was perfect for me on .NET, but .NET Core doesn't have a decimal.Round method at the time of writing.

In .NET Core, I had to use:

decimal roundedValue = Math.Round(rawNumber, 2, MidpointRounding.AwayFromZero);

A hacky method, including conversion to string, is:

public string FormatTo2Dp(decimal myNumber)
{
	// Use schoolboy rounding, not bankers.
	myNumber = Math.Round(myNumber, 2, MidpointRounding.AwayFromZero);

	return string.Format("{0:0.00}", myNumber);
}

Solution 11 - C#

Very rarely would you want an empty string if the value is 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"

The top rated answer is incorrect and has wasted 10 minutes of (most) people's time.

Solution 12 - C#

None of these did exactly what I needed, to force 2 d.p. and round up as 0.005 -> 0.01

Forcing 2 d.p. requires increasing the precision by 2 d.p. to ensure we have at least 2 d.p.

then rounding to ensure we do not have more than 2 d.p.

Math.Round(exactResult * 1.00m, 2, MidpointRounding.AwayFromZero)

6.665m.ToString() -> "6.67"

6.6m.ToString() -> "6.60"

Solution 13 - C#

The top-rated answer describes a method for formatting the string representation of the decimal value, and it works.

However, if you actually want to change the precision saved to the actual value, you need to write something like the following:

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

An example 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"));
}

Solution 14 - C#

You can use system.globalization to format a number in any required format.

For example:

system.globalization.cultureinfo ci = new system.globalization.cultureinfo("en-ca");

If you have a decimal d = 1.2300000 and you need to trim it to 2 decimal places then it can be printed like this d.Tostring("F2",ci); where F2 is string formating to 2 decimal places and ci is the locale or cultureinfo.

for more info check this link
http://msdn.microsoft.com/en-us/library/dwhawy9k.aspx

Solution 15 - C#

https://msdn.microsoft.com/en-us/library/dwhawy9k%28v=vs.110%29.aspx

This link explains in detail how you can handle your problem and what you can do if you want to learn more. For simplicity purposes, what you want to do is

double whateverYouWantToChange = whateverYouWantToChange.ToString("F2");

if you want this for a currency, you can make it easier by typing "C2" instead of "F2"

Solution 16 - C#

Double Amount = 0;
string amount;
amount=string.Format("{0:F2}", Decimal.Parse(Amount.ToString()));

Solution 17 - C#

If you need to keep only 2 decimal places (i.e. cut off all the rest of decimal digits):

decimal val = 3.14789m;
decimal result = Math.Floor(val * 100) / 100; // result = 3.14

If you need to keep only 3 decimal places:

decimal val = 3.14789m;
decimal result = Math.Floor(val * 1000) / 1000; // result = 3.147

Solution 18 - C#

        var arr = new List<int>() { -4, 3, -9, 0, 4, 1 };
        decimal result1 = arr.Where(p => p > 0).Count();
        var responseResult1 = result1 / arr.Count();
        decimal result2 = arr.Where(p => p < 0).Count();
        var responseResult2 = result2 / arr.Count();
        decimal result3 = arr.Where(p => p == 0).Count();
        var responseResult3 = result3 / arr.Count();
        Console.WriteLine(String.Format("{0:#,0.000}", responseResult1));
        Console.WriteLine(String.Format("{0:#,0.0000}", responseResult2));
        Console.WriteLine(String.Format("{0:#,0.00000}", responseResult3));

you can put as many 0 as you want.

Content Type	Original Author	Original Content on Stackoverflow
Question	wows	View Question on Stackoverflow
Solution 1 - C#	albertein	View Answer on Stackoverflow
Solution 2 - C#	Mike M.	View Answer on Stackoverflow
Solution 3 - C#	Sofox	View Answer on Stackoverflow
Solution 4 - C#	Jorge Ferreira	View Answer on Stackoverflow
Solution 5 - C#	Hafthor	View Answer on Stackoverflow
Solution 6 - C#	Joel Mueller	View Answer on Stackoverflow
Solution 7 - C#	Simon_Weaver	View Answer on Stackoverflow
Solution 8 - C#	What Would Be Cool	View Answer on Stackoverflow
Solution 9 - C#	John Smith	View Answer on Stackoverflow
Solution 10 - C#	JsAndDotNet	View Answer on Stackoverflow
Solution 11 - C#	goamn	View Answer on Stackoverflow
Solution 12 - C#	Kaido	View Answer on Stackoverflow
Solution 13 - C#	Alex	View Answer on Stackoverflow
Solution 14 - C#	Smitha Poluri	View Answer on Stackoverflow
Solution 15 - C#	Jeff Jose	View Answer on Stackoverflow
Solution 16 - C#	Code	View Answer on Stackoverflow
Solution 17 - C#	Aleksei Mialkin	View Answer on Stackoverflow
Solution 18 - C#	ihsan güç	View Answer on Stackoverflow