c# - मैं दशमलव मान को 2 दशमलव स्थानों पर कैसे चला सकता हूं(किसी पृष्ठ पर आउटपुट के लिए)




.net decimal (10)

आप किसी भी आवश्यक प्रारूप में किसी संख्या को प्रारूपित करने के लिए system.globalization का उपयोग कर सकते हैं।

उदाहरण के लिए:

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

यदि आपके पास decimal d = 1.2300000 और आपको इसे 2 दशमलव स्थानों पर ट्रिम करने की आवश्यकता है तो इसे इस d.Tostring("F2",ci); जैसे मुद्रित किया जा सकता है d.Tostring("F2",ci); जहां F2 स्ट्रिंग को दो दशमलव स्थानों पर बना रहा है और सीआई लोकेल या संस्कृतिइन्फो है।

अधिक जानकारी के लिए इस लिंक की जांच करें
http://msdn.microsoft.com/en-us/library/dwhawy9k.aspx

वर्तमान में .ToString() साथ दशमलव के मान को प्रदर्शित करते समय, यह 15 दशमलव स्थानों की तरह सटीक है, और चूंकि मैं इसका उपयोग डॉलर और सेंट का प्रतिनिधित्व करने के लिए कर रहा हूं, मैं केवल आउटपुट को 2 दशमलव स्थान बनाना चाहता हूं।

क्या मैं इसके लिए .ToString() की विविधता का उपयोग करता हूं?


इनमें से कोई भी वास्तव में मुझे आवश्यक नहीं था, 2 डीपी को मजबूर करने और 0.005 -> 0.01 रूप में गोल करने के लिए

2 डीपी को मजबूर करने के लिए 2 डीपी द्वारा परिशुद्धता में वृद्धि की आवश्यकता है ताकि यह सुनिश्चित किया जा सके कि हमारे पास कम से कम 2 डीपी है

फिर यह सुनिश्चित करने के लिए गोल करना कि हमारे पास 2 डीपी से अधिक नहीं है

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

6.665m.ToString() -> "6.67"

6.6m.ToString() -> "6.60"

पहले से ही दो उच्च स्कोरिंग उत्तर हैं जो दशमलव को संदर्भित करते हैं। राउंड (...) लेकिन मुझे लगता है कि थोड़ा और स्पष्टीकरण की आवश्यकता है - क्योंकि दशमलव की एक अप्रत्याशित महत्वपूर्ण संपत्ति स्पष्ट नहीं है।

एक दशमलव 'जानता है' यह कहां से आया है कि यह कितने दशमलव स्थान पर है।

उदाहरण के लिए निम्नलिखित अप्रत्याशित हो सकते हैं:

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" ) नहीं होगा।

जब आप दशमलव को 2 दशमलव स्थानों के बारे में 95% मौका चाहते हैं, तो ऐसा इसलिए होता है क्योंकि यह मुद्रा उस स्थिति में 95% समय के लिए शायद ठीक है:

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

या {Binding Price, StringFormat=c} में आप बस {Binding Price, StringFormat=c}

एक मामला मैं भाग गया जहां मुझे एक दशमलव के रूप में एक दशमलव की आवश्यकता थी जब अमेज़ॅन के webservice में एक्सएमएल भेज रहा था। सेवा शिकायत कर रही थी क्योंकि एक दशमलव मूल्य (मूल रूप से SQL सर्वर से) को 25.1200 रूप में भेजा जा रहा था और अस्वीकार कर दिया गया था, ( 25.12 अपेक्षित प्रारूप था)।

मुझे बस इतना करना था कि समस्या को ठीक करने के लिए 2 दशमलव स्थानों के साथ 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 रूप में रखने की आवश्यकता थी।


मुझे पता है कि यह एक पुराना सवाल है, लेकिन मुझे आश्चर्य हुआ कि कोई भी जवाब पोस्ट नहीं कर रहा था;

  1. बैंकरों का घूर्णन नहीं किया
  2. मान को दशमलव के रूप में नहीं रखा था।

मैं यही उपयोग करूंगा:

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

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



यदि मूल्य 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"

शीर्ष रेटेड उत्तर गलत है और 10 मिनट (अधिकांश) लोगों के समय बर्बाद कर दिया है।


शीर्ष-रेटेड उत्तर दशमलव मान के स्ट्रिंग प्रस्तुति को स्वरूपित करने के लिए एक विधि का वर्णन करता है, और यह काम करता है।

हालांकि, यदि आप वास्तव में वास्तविक मूल्य में सहेजी गई परिशुद्धता को बदलना चाहते हैं, तो आपको निम्न की तरह कुछ लिखना होगा:

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

एक उदाहरण इकाई परीक्षण:

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


share .NET पर मेरे लिए बिल्कुल सही था, लेकिन .NET कोर में decimal.Round नहीं है। लेखन के समय decimal.Round विधि।

.NET कोर में, मुझे इसका उपयोग करना पड़ा:

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

स्ट्रिंग में रूपांतरण सहित एक हैकी विधि है:

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

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

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

या

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




rounding