अतिरिक्त निम्नलिखित 0 को हटाने के लिए मैं सी # दशमलव कैसे प्रारूपित करूं?

Question

मैं एक स्ट्रिंग को दशमलव के रूप में स्वरूपित करना चाहता हूं, लेकिन दशमलव में दशमलव के बाद कुछ निम्न शून्य हैं। मैं इसे कैसे प्रारूपित करूं कि उन अर्थहीन 0 गायब हो गए हैं?

string.Format("{0}", 1100M); 
string.Format("{0}", 1100.1M); 
string.Format("{0}", 1100.100M); 
string.Format("{0}", 1100.1000M); 

प्रदर्शित करता है:

1100 
1100.1 
1100.100 
1100.1000 

लेकिन मैं इसे होना चाहते हैं:

1100 
1100.1 
1100.1 
1100.1 

संदर्भ के लिए, अन्य प्रश्न है कि अनिवार्य रूप से इस के डुप्लिकेट कर रहे हैं, कि मैं धन्यवाद मिल गया है यहां दिए गए उत्तरों के लिए:

• Parse decimal and filter extra 0 on the right?
• Best way to display decimal without trailing zeroes
• How can I strip zeros and decimal points off of decimal strings?

Answer 1

आप वांछित परिणाम प्राप्त करने General ("G") Format Specifier साथ ToString() उपयोग कर सकते हैं । इस प्रारूप स्ट्रिंग का उपयोग करते समय एक सटीक निर्दिष्ट के साथ ट्रेलिंग शून्य को छोटा कर दिया जाता है। किसी भी परिस्थिति में गोल करने से रोकने के लिए, आपको परिशुद्धता को अधिकतम दशमलव (2 9) के लिए अधिकतम सेट करने की आवश्यकता होगी।

जो आप चाहते हैं उसे उत्पन्न करने के लिए कोड की रेखा number.ToString("G29") है, जहां number आपका मूल दशमलव है।

ध्यान रखें कि 0.0001 से छोटे किसी भी संख्या को वैज्ञानिक नोटेशन में परिवर्तित कर दिया जाएगा। इस फ़ॉर्मेटर कार्यों को कैसे ऊपर दिए गए संदर्भ लिंक पर पाया जा सकता है इसके बारे में अधिक जानकारी।

Answer 2

आप format string इस तरह निर्दिष्ट कर सकते हैं:

String.Format("{0:0.000}", x); 

Answer 3

String.Format("{0:0.##}", 123.0); // "123" 

Answer 4

वे आवश्यक रूप से व्यर्थ नहीं हैं - ये गणना के दौरान सटीक संकेत मिलता है। दशमलव सामान्य होने के बजाय, उनके सटीक स्तर को बनाए रखते हैं।

मेरे पास this answer में कुछ कोड है जो सामान्यीकृत मान लौटाएगा - आप इसका उपयोग कर सकते हैं, और फिर परिणाम स्वरूपित कर सकते हैं। उदाहरण के लिए:

using System; 
using System.Numerics; 

class Test 
{ 
    static void Display(decimal d) 
    { 
     d = d.Normalize(); // Using extension method from other post 
     Console.WriteLine(d); 
    } 

    static void Main(string[] args) 
    { 
     Display(123.4567890000m); // Prints 123.456789 
     Display(123.100m);  // Prints 123.1 
     Display(123.000m);  // Prints 123 
     Display(123.4567891234m); // Prints 123.4567891234 
    } 
} 

मैं संदिग्ध कि प्रारूप स्ट्रिंग दृष्टिकोण के सबसे असफल हो जायेगी। मुझे लगता है कि "0." की प्रारूप स्ट्रिंग पहले से ही

var s = String.Format("{0:#####.###}"); 

Answer 5

मेरा मानना ​​है कि आप क्या करना चाहते। मैं अक्सर इस नकल पुस्तिकाओं का संदर्भ लें: http://blog.stevex.net/string-formatting-in-csharp/

Answer 6

काफी कुछ उत्तर: और उसके बाद 28 # वर्ण काम करेगा, लेकिन यह बहुत बदसूरत होगा ...

Answer 7

कुछ हद तक hackish, लेकिन यह काम करना चाहिए:

decimal a = 100.00M; 
string strNumber = string.Format("{0}", a); 
Console.WriteLine(strNumber.Contains('.') ? strNumber.TrimEnd('0').TrimEnd('.') : strNumber); 

Answer 8

कैसे के बारे में:

string FormatDecimal(decimal d) 
{ 
    const char point = System.Globalization.NumberFormatInfo.CurrentInfo.NumberDecimalSeparator[0]; 
    string s = d.ToString(); 
    // if there's no decimal point, there's nothing to trim 
    if (!s.Contains(point) == -1) 
     return s; 
    // trim any trailing 0s, followed by the decimal point if necessary 
    return s.TrimEnd('0').TrimEnd(point); 
} 

Answer 9

string s = d.ToString("0.#############################"); 

Answer 10

double a = 1100.00 
double b =1100.1 
double c = 1100.100 
double d =1100.1000 

Remove last zero after point 


string stra = a.toString("0.00").TrimEnd('0').TrimEnd('.'); 
string strb = b.toString("0.00").TrimEnd('0').TrimEnd('.'); 
string strc = c.toString("0.00").TrimEnd('0').TrimEnd('.'); 
string strd = d.toString("0.00").TrimEnd('0').TrimEnd('.'); 

Output 

1100 
1100.1 
1100.1 
1100.1 

Answer 11

क्या हर कोई एक G फॉर्मेट स्पेसिफायर उपयोग करने के लिए मैं, जबकि अतिरिक्त अनुगामी शून्य को दूर करने के लिए दोनों हजार विभाजक और दशमलव बिंदु संरक्षित करने के लिए निम्नलिखित सुझाव है कि सुझाव है कि विपरीत:

{0:#,#.##} 

इसी का परिणाम अधिकांश मामलों में जी से प्रारूप बहुत बेहतर है:

String.Format("{0:#,#.##}",25/2.4); 
10.42 

String.Format("{0:#,#.##}",1000000); 
1,000,000 

String.Format("{0:#,#.##}",1000000.3600000); 
1,000,000.36 

एन डी G विनिर्देशक वास्तव में सभी संभावित संयोजनों को संभाल नहीं सकता है:

String.Format("{0:G29}",25/2.4); 
10.416666666666668 

String.Format("{0:G2}",25/2.4); 
10 

String.Format("{0:G29}",1000000.3600000); 
1000000.36 

String.Format("{0:G2}",1000000.3600000); 
1E+06