소수점 이하 두 자리로 반올림하는 방법 (페이지 출력용)

소수점 이하 두 자리로 반올림하는 방법 (페이지 출력용)

---

현재를 사용하여 소수점 값을 표시 할 때 소수점 이하 .ToString()15 자리를 선호하는 것이 정확하며, 달러와 센트를 나타내는 데 사용하고 있으므로 출력이 소수점 이하 2 자리 만 표시되기를 원합니다.

.ToString()이것 에 대한 변형을 사용 합니까?

---

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

또는

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

---

나는 이것이 오래된 질문이라는 것을 알고 있지만 아무도 그에 대한 답변을 게시하지 않는 것을보고 놀랐습니다.

1. 은행원 반올림을 사용하지 않았습니다.
2. 값을 소수로 유지하지 않았습니다.

이것이 내가 사용할 것입니다.

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

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

---

decimalVar.ToString("F");

이것은 :

• 소수점 이하 2 자리로 반올림합니다. 23.456 => 23.46
• 항상 소수점 2 자리가 있는지 확인하십시오. 23 => 23.00, 12.5 => 12.50

통화 및 금액 표시에 이상적입니다.

ToString ( "F")에 대한 문서 : http://msdn.microsoft.com/en-us/library/dwhawy9k%28v=vs.110%29.aspx#FFormatString(Jon Schneider 덕분에)

---

디스플레이를 위해 이것이 필요한 경우 string.Format을 사용하십시오.

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

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

"m"은 십진 접미사입니다. 소수 접미사 정보 :

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

---

주어진 십진수 d = 12.345; d.ToString ( "C") 또는 String.Format ( "{0 : C}", d) 표현식 은 $ 12.35를 산출 합니다. 기호를 포함한 현재 문화권의 통화 설정이 사용됩니다.

참고 "C" 현재 문화권에서 숫자의 사용 번호. 항상 기본값을 재정 의하여 C{Precision specifier}like를 사용 하여 필요한 정밀도를 강제 할 수 있습니다 String.Format("{0:C2}", 5.123d).

---

3,456,789.12 ...와 같이 쉼표와 소수점 (통화 기호 없음)으로 형식을 지정하려는 경우 ...

decimalVar.ToString("n2");

---

Decimal.Round (...)를 참조하는 두 개의 높은 점수 답변이 이미 있지만 조금 더 설명이 필요하다고 생각합니다. Decimal의 예상치 못한 중요한 속성이 분명하지 않기 때문입니다.

소수점은 그것이 어디에서 왔는지에 따라 소수점 이하 자릿수를 '알고'있습니다.

예를 들어, 다음은 예상치 못한 일입니다.

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"

으로 동일한 작업을 수행하면 위의 각 항목에 Double소수점 이하 자릿수 ( "25") 가 제공되지 않습니다 .

소수점 이하 둘째 자리까지 원하는 경우 약 95 %의 확률은 통화이기 때문입니다.이 경우 95 %는 괜찮습니다.

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

또는 XAML에서 {Binding Price, StringFormat=c}

내가 십진수 AS가 필요한 곳을 만난 한 가지 사례는 XML을 Amazon의 웹 서비스로 보낼 때였습니다. Decimal 값 (원래 SQL Server에서)이 전송 25.1200되고 거부 되었기 때문에 서비스가 불만 25.12을 표시했습니다 (예상 형식 임).

내가해야 할 일은 Decimal.Round(...)문제를 해결하기 위해 소수점 이하 두 자리 만 사용 하는 것이 었 습니다.

 // This is an XML message - with generated code by XSD.exe
 StandardPrice = new OverrideCurrencyAmount()
 {
       TypedValue = Decimal.Round(product.StandardPrice, 2),
       currency = "USD"
 }

TypedValue유형 Decimal이므로 할 수 없으며 ToString("N2")반올림하고 decimal.

---

다음은 다양한 형식을 보여주는 작은 Linqpad 프로그램입니다.

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

결과는 다음과 같습니다.

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

---

Math.Round 메서드 (Decimal, Int32)

---

값이 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.

---

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"

---

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

---

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

---

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

---

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"

---

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

참고URL : https://stackoverflow.com/questions/164926/how-do-i-round-a-decimal-value-to-2-decimal-places-for-output-on-a-page