मैं एक दशमलव बिंदु के साथ एक स्ट्रिंग को दोगुना कैसे पार्स करता हूं?


231

मैं एक स्ट्रिंग "3.5"को डबल की तरह पार्स करना चाहता हूं । तथापि,

double.Parse("3.5") 

पैदावार 35 और

double.Parse("3.5", System.Globalization.NumberStyles.AllowDecimalPoint) 

फेंकता है a FormatException

अब मेरे कंप्यूटर का लोकेल जर्मन पर सेट है, जिसमें कॉमा को दशमलव विभाजक के रूप में उपयोग किया जाता है। यह उस के साथ कुछ करना और इनपुट के रूप में double.Parse()उम्मीद करना पड़ सकता है "3,5", लेकिन मुझे यकीन नहीं है।

मैं एक दशमलव संख्या वाले स्ट्रिंग को कैसे पार्स कर सकता हूं जो मेरे वर्तमान स्थान में निर्दिष्ट रूप में प्रारूपित या नहीं किया जा सकता है?


दशमलव अल्पविराम निश्चित रूप से आउटपुट को प्रभावित करेगा।
ChrisF

12
यदि यह आपकी स्थिति के लिए उपयुक्त है, तो Double.TryParse () पद्धति के बारे में मत भूलना।
काइल गग्नेट

जवाबों:


414
double.Parse("3.5", CultureInfo.InvariantCulture)

मुझे XmlConvertकक्षा का उपयोग करना पसंद है ... क्या आपके पास कोई विचार है कि क्या यह बेहतर, बदतर, और / या उपयोग करने से अलग है CultureInfo.InvariantCulture?
क्रिस डब्लू

1
खैर, XmlConvertवास्तव में कोड में एक भी दोहरे मूल्य को पार्स करने के लिए उपयोग करने का इरादा नहीं है। मैं उपयोग करना पसंद करता हूं double.Parseया Convert.ToDoubleयह मेरा इरादा स्पष्ट करता है।
मेहरदाद अफश्री

4
इसका मतलब है कि doulble.Parse डिफ़ॉल्ट संस्कृति का उपयोग करता है जिसमें दशमलव बिंदु के रूप में डॉट नहीं हो सकता है ??
अहमद ने

3
अगर 12345678.12345678 को परिवर्तित किया जाए, तो यह 12345678.123457 में परिवर्तित हो जाता है
PUG

4
मेरे लिए काम नहीं किया: अल्पविराम अल्पविराम और रिटर्न के रूप में डबल
fnc12

75

मैं आमतौर पर उपयोगकर्ता इनपुट को पार्स करने के लिए एक बहु-संस्कृति फ़ंक्शन का उपयोग करता हूं, ज्यादातर क्योंकि यदि कोई व्यक्ति numpad के लिए उपयोग किया जाता है और एक संस्कृति का उपयोग कर रहा है जो दशमलव विभाजक के रूप में अल्पविराम का उपयोग करता है, तो वह व्यक्ति अल्पविराम के बजाय numpad के बिंदु का उपयोग करेगा।

public static double GetDouble(string value, double defaultValue)
{
    double result;

    //Try parsing in the current culture
    if (!double.TryParse(value, System.Globalization.NumberStyles.Any, CultureInfo.CurrentCulture, out result) &&
        //Then try in US english
        !double.TryParse(value, System.Globalization.NumberStyles.Any, CultureInfo.GetCultureInfo("en-US"), out result) &&
        //Then in neutral language
        !double.TryParse(value, System.Globalization.NumberStyles.Any, CultureInfo.InvariantCulture, out result))
    {
        result = defaultValue;
    }

    return result;
}

हालांकि खबरदार, @nikie टिप्पणियाँ सच हैं। अपने बचाव के लिए, मैं इस फ़ंक्शन को एक नियंत्रित वातावरण में उपयोग करता हूं जहां मुझे पता है कि संस्कृति या तो एन-यूएस, एन-सीए या एफआर-सीए हो सकती है। मैं इस फ़ंक्शन का उपयोग करता हूं क्योंकि फ्रेंच में, हम कॉमा को एक दशमलव विभाजक के रूप में उपयोग करते हैं, लेकिन जो कोई भी कभी वित्त में काम करता है, वह हमेशा numpad पर दशमलव विभाजक का उपयोग करेगा, लेकिन यह एक बिंदु है, अल्पविराम नहीं। तो यहां तक ​​कि fr-CA संस्कृति में, मुझे संख्या को पार्स करने की आवश्यकता है जो दशमलव विभाजक के रूप में एक बिंदु होगा।


18
मुझे यकीन नहीं है कि यह एक अच्छा विचार है। यदि आप संस्कृति को नहीं जानते हैं, तो आप मज़बूती से एक डबल पार्स नहीं कर सकते: जर्मनी में, दोहरे मान हो सकते हैं '।, लेकिन वे वहाँ हजारों-विभाजक माने जाते हैं। तो लेगेट के मामले में, GetDouble ("3.5") एक जर्मन लोकेल में 35 और एक एन-यूएस वातावरण में 3.5 लौटेगा।
निकी

नहीं, पियरे एलेन सही है, जैसा कि लिखा है। यदि आपकी संस्कृति कहती है "डॉट एक हजार" विभाजक है, तो "3.5" को "35" के रूप में देखा जाता है और यह अच्छा है। हालाँकि यदि आप "डॉट" के लिए कोई नियम नहीं मानते हैं, तो चरित्र को दशमलव बिंदु के रूप में देखा जाता है, और यह काम भी करता है। मैं enUS संस्कृति की कोशिश कर रहा से बचना होगा, लेकिन यह एक व्यक्तिगत पसंद है।
xryl669

यदि आप अल्पविराम के साथ संस्कृति में numpad का उपयोग करते हैं, तो dot कुंजी को अल्पविराम सेट किया जाएगा।
क्रेजीबारन

Numpad दशमलव विभाजक कीबोर्ड लेआउट पर निर्भर करता है (और क्षेत्रीय सेटिंग्स नहीं - कम से कम विंडोज 7 पर) (मैं पाठ लिखने के लिए हंगेरियन का उपयोग करता हूं, ई-मेल ... और en-US कोड लिखने के लिए, इसलिए यह या तो डॉट हो सकता है या अल्पविराम। मैं अनुकूलित क्षेत्रीय सेटिंग्स का भी उपयोग करता हूं, जहां मैंने दशमलव विभाजक को ',' से '।' और 'से', 'से' में 'सूची' में बदल दिया है। आप जानते हैं, कारण csv ... हम सभी को बहु लेखन के लिए शुभकामनाएं। -कल्चर ऐप्स;)
स्टीवन स्पार्क

25

मैं एक टिप्पणी नहीं लिख सकता, इसलिए मैं यहां लिखता हूं:

double.Parse ("3.5", CultureInfo.InvariantCulture) एक अच्छा विचार नहीं है, क्योंकि कनाडा में हम 3.5 के बजाय 3,5 लिखते हैं और यह फ़ंक्शन परिणाम के रूप में हमें 35 देता है।

मैंने अपने कंप्यूटर पर दोनों का परीक्षण किया:

double.Parse("3.5", CultureInfo.InvariantCulture) --> 3.5 OK
double.Parse("3,5", CultureInfo.InvariantCulture) --> 35 not OK

यह एक सही तरीका है जिसका उल्लेख पियरे-एलेन विगेंट ने किया था

public static double GetDouble(string value, double defaultValue)
{
    double result;

    // Try parsing in the current culture
    if (!double.TryParse(value, System.Globalization.NumberStyles.Any, CultureInfo.CurrentCulture, out result) &&
        // Then try in US english
        !double.TryParse(value, System.Globalization.NumberStyles.Any, CultureInfo.GetCultureInfo("en-US"), out result) &&
        // Then in neutral language
        !double.TryParse(value, System.Globalization.NumberStyles.Any, CultureInfo.InvariantCulture, out result))
    {
        result = defaultValue;
    }
    return result;
}

1
पुन: "... क्योंकि कनाडा में हम 3.5 के बजाय 3,5 लिखते हैं" क्या आप इसके बारे में निश्चित हैं? दशमलव चिह्न के अनुसार : "वे देश जहां एक डॉट"। "दशमलव चिह्न के रूप में उपयोग किया जाता है ... कनाडा (अंग्रेजी का उपयोग करते समय)" । क्या यह विंडोज के फ्रेंच संस्करण का उपयोग करने के बारे में अधिक नहीं है?
पीटर मोर्टेनसेन

फ्रेंच संस्करण के कारण बेबे। मॉन्ट्रियल में हम 3,5 नहीं 3.5 लिखते हैं
मालुस जन

तो आपके तर्क के अनुसार, उनमें से केवल 1 ही सही है?
बैटमेसी


अभी भी एक त्रुटि है। GetDouble ("10 ,,,,,,, 0", 0.0) जैसे इनपुट स्ट्रिंग के लिए। उल्लेख समारोह रिटर्न 100
Krivers

21
Double.Parse("3,5".Replace(',', '.'), CultureInfo.InvariantCulture)

पार्सिंग से पहले अल्पविराम को एक बिंदु से बदलें। दशमलव विभाजक के रूप में अल्पविराम वाले देशों में उपयोगी। उपयोगकर्ता इनपुट (यदि आवश्यक हो) को एक अल्पविराम या बिंदु तक सीमित करने के बारे में सोचें।


1
उस व्यक्ति की तुलना में अधिक सही उत्तर, जिसके पास +133 वोट हैं ... यह "," या "" दोनों प्रणालियों पर रहने की अनुमति देता है। दशमलव विभाजक ...
Badiboy

@ बेदीबॉय आप बता सकते हैं कि इस उत्तर में क्या गलत है? जैसा कि मैं समझता हूं कि InvariantCulture हमेशा '' है। दशमलव विभाजक के रूप में। तो यह दोनों प्रणालियों के लिए काम करना चाहिए।
एलेक्स पी।

@ Alex11223 आप सही हैं। इसलिए मैंने कहा कि यह उत्तर बेहतर है और अधिक लोकप्रिय है। पुनश्च: अगर आपके पास "," लिस्ट सेपरेटर (यानी 1,234,560.01) के रूप में है, तो यह कोड बोलना भी विफल हो जाएगा, लेकिन मुझे नहीं पता कि यह कैसे हल किया जाए। :)
बादिबॉय

4
यह एक अच्छा जवाब नहीं है क्योंकि कुछ कल्चरिनफोस में, हजारों विभाजक है और इसका इस्तेमाल किया जा सकता है। यदि आप इसे एक बिंदु पर बदल देते हैं, तो आपके पास कई डॉट्स होते हैं और पार्स विफल हो जाएगा: Double.Parse ((123.6.67) .ToString ("एन", नई संस्कृतिइन्फो ("एन"))। प्रतिस्थापन (',', ')। '), CultureInfo.InvariantCulture) क्योंकि (12345.67) .ToString ("N", नई CultureInfo ("en")। प्रतिस्थापन (', ',' ') को "12.345.67" के रूप में स्वरूपित किया जाएगा
कोडिंगवे

1,234.56 -> 1.234.56 पार्सर नहीं। एक अन्य विचार यह जांचने का है कि क्या संख्या में 'है।' और ',' और 'बदलें', 'खाली स्ट्रिंग के साथ और यदि केवल', 'अल्पविराम ने इसे' की जगह 'प्रस्तुत किया।'
GDocal

16

चाल सभी संस्कृतियों में डॉट पार्स करने के लिए, अपरिवर्तनीय संस्कृति का उपयोग करना है।

double.Parse("3.5", System.Globalization.NumberStyles.AllowDecimalPoint, System.Globalization.NumberFormatInfo.InvariantInfo);

11

देखिए, उपरोक्त प्रत्येक उत्तर जो एक निरंतर स्ट्रिंग द्वारा स्ट्रिंग प्रतिस्थापन लिखने का प्रस्ताव करता है, केवल गलत हो सकता है। क्यों? क्योंकि आप Windows की क्षेत्र सेटिंग्स का सम्मान नहीं करते हैं! विंडोज उपयोगकर्ता को यह आश्वासन देता है कि उसके पास जो भी विभाजक चरित्र है, उसे सेट करने की स्वतंत्रता है। एस / वह नियंत्रण कक्ष खोल सकता है, क्षेत्र पैनल में जा सकता है, उन्नत पर क्लिक कर सकता है और किसी भी समय चरित्र बदल सकता है। अपने कार्यक्रम चलाने के दौरान भी। इस बारे में सोचो। एक अच्छे समाधान के बारे में पता होना चाहिए।

तो, पहले आपको खुद से पूछना होगा कि यह नंबर कहां से आ रहा है, कि आप पार्स करना चाहते हैं। यदि यह .NET फ्रेमवर्क में इनपुट से आ रहा है तो कोई समस्या नहीं है, क्योंकि यह उसी प्रारूप में होगा। लेकिन शायद यह बाहर से आ रहा था, शायद एक बाहरी सर्वर से, शायद एक पुराने डीबी से जो केवल स्ट्रिंग गुणों का समर्थन करता है। वहां, db एडमिन को एक नियम देना चाहिए कि किस फॉर्मेट में नंबर स्टोर किए जाने हैं। यदि आप उदाहरण के लिए जानते हैं कि यह यूएस प्रारूप वाला US DB होगा तो आप इस कोड का उपयोग कर सकते हैं:

CultureInfo usCulture = new CultureInfo("en-US");
NumberFormatInfo dbNumberFormat = usCulture.NumberFormat;
decimal number = decimal.Parse(db.numberString, dbNumberFormat);

यह दुनिया में कहीं भी ठीक काम करेगा। और कृपया 'Convert.ToXxxx' का उपयोग न करें। 'कन्वर्ट' वर्ग को केवल किसी भी दिशा में रूपांतरण के लिए आधार के रूप में माना जाता है। इसके अलावा: आप DateTimes के लिए भी इसी तरह के तंत्र का उपयोग कर सकते हैं।


माना! संस्कृति सुविधाओं को मैन्युअल रूप से लागू करने की कोशिश करना अंततः उस मामले में परिणाम देने वाला है जिसकी आपको उम्मीद नहीं थी और एक बड़ा सिरदर्द। .NET को ठीक से हैंडल करने दें।
खलोस

2
एक बड़ी समस्या यह है कि जब उपयोगकर्ता एक दशमलव विभाजक का उपयोग कर रहे हैं, जिसे उसकी सांस्कृतिक सेटिंग के लिए दशमलव विभाजक नहीं माना जाता है
EdmundYeung99

3
string testString1 = "2,457";
string testString2 = "2.457";    
double testNum = 0.5;
char decimalSepparator;
decimalSepparator = testNum.ToString()[1];

Console.WriteLine(double.Parse(testString1.Replace('.', decimalSepparator).Replace(',', decimalSepparator)));
Console.WriteLine(double.Parse(testString2.Replace('.', decimalSepparator).Replace(',', decimalSepparator)));

2

इस विषय पर मेरे दो सेंट, एक सामान्य, दोहरी रूपांतरण विधि प्रदान करने की कोशिश कर रहे हैं:

private static double ParseDouble(object value)
{
    double result;

    string doubleAsString = value.ToString();
    IEnumerable<char> doubleAsCharList = doubleAsString.ToList();

    if (doubleAsCharList.Where(ch => ch == '.' || ch == ',').Count() <= 1)
    {
        double.TryParse(doubleAsString.Replace(',', '.'),
            System.Globalization.NumberStyles.Any,
            CultureInfo.InvariantCulture,
            out result);
    }
    else
    {
        if (doubleAsCharList.Where(ch => ch == '.').Count() <= 1
            && doubleAsCharList.Where(ch => ch == ',').Count() > 1)
        {
            double.TryParse(doubleAsString.Replace(",", string.Empty),
                System.Globalization.NumberStyles.Any,
                CultureInfo.InvariantCulture,
                out result);
        }
        else if (doubleAsCharList.Where(ch => ch == ',').Count() <= 1
            && doubleAsCharList.Where(ch => ch == '.').Count() > 1)
        {
            double.TryParse(doubleAsString.Replace(".", string.Empty).Replace(',', '.'),
                System.Globalization.NumberStyles.Any,
                CultureInfo.InvariantCulture,
                out result);
        }
        else
        {
            throw new ParsingException($"Error parsing {doubleAsString} as double, try removing thousand separators (if any)");
        }
    }

    return result;
}

जैसा कि उम्मीद के साथ काम करता है:

  • 1.1
  • 1,1
  • 1,000,000,000
  • 1.000.000.000
  • 1,000,000,000.99
  • 1.000.000.000,99
  • 5,000,111.3
  • 5.000.111,3
  • 0.99,000,111,88
  • 0,99.000.111.88

कोई डिफ़ॉल्ट रूपांतरण लागू नहीं किया गया है, इसलिए यह पार्स 1.3,14, 1,3.14या इसी तरह के मामलों की कोशिश कर रहा है ।


1
"1,000" का इरादा एक हजार के रूप में विफल हो जाएगा।
Defkon1

1

निम्नलिखित कोड किसी भी परिदृश्य में काम करता है। यह थोडा पार्सिंग है।

List<string> inputs = new List<string>()
{
    "1.234.567,89",
    "1 234 567,89",
    "1 234 567.89",
    "1,234,567.89",
    "123456789",
    "1234567,89",
    "1234567.89",
};
string output;

foreach (string input in inputs)
{
    // Unify string (no spaces, only .)
    output = input.Trim().Replace(" ", "").Replace(",", ".");

    // Split it on points
    string[] split = output.Split('.');

    if (split.Count() > 1)
    {
        // Take all parts except last
        output = string.Join("", split.Take(split.Count()-1).ToArray());

        // Combine token parts with last part
        output = string.Format("{0}.{1}", output, split.Last());
    }

    // Parse double invariant
    double d = double.Parse(output, CultureInfo.InvariantCulture);
    Console.WriteLine(d);
}

2
1.234.567.890 पर 1234567.890
Dan Vogel

मैंने कोशिश नहीं की है, लेकिन अगर आप अलग-अलग कल्चर SO में ऐप निष्पादित करते हैं, तो यह कोड ट्रिक नहीं बनाएगा, मुझे लगता है: /
दानी बिशप

1

मुझे लगता है कि 100% सही रूपांतरण संभव नहीं है, अगर मूल्य उपयोगकर्ता इनपुट से आता है। उदाहरण के लिए यदि मान 123.456 है, तो यह एक समूहीकरण हो सकता है या यह एक दशमलव बिंदु हो सकता है। यदि आपको वास्तव में 100% की आवश्यकता है तो आपको अपने प्रारूप का वर्णन करना होगा और यदि यह सही नहीं है तो एक अपवाद फेंक दें।

लेकिन मैंने JanW के कोड में सुधार किया है, इसलिए हम 100% से थोड़ा आगे हैं। इसके पीछे विचार यह है, कि यदि अंतिम विभाजक एक समूह सूचक है, तो यह एक पूर्णांक प्रकार से अधिक होगा, एक दोहरे की तुलना में।

जोड़ा कोड पहले में है अगर की GetDouble

void Main()
{
    List<string> inputs = new List<string>() {
        "1.234.567,89",
        "1 234 567,89",
        "1 234 567.89",
        "1,234,567.89",
        "1234567,89",
        "1234567.89",
        "123456789",
        "123.456.789",
        "123,456,789,"
    };

    foreach(string input in inputs) {
        Console.WriteLine(GetDouble(input,0d));
    }

}

public static double GetDouble(string value, double defaultValue) {
    double result;
    string output;

    // Check if last seperator==groupSeperator
    string groupSep = System.Globalization.CultureInfo.CurrentCulture.NumberFormat.NumberGroupSeparator;
    if (value.LastIndexOf(groupSep) + 4 == value.Count())
    {
        bool tryParse = double.TryParse(value, System.Globalization.NumberStyles.Any, System.Globalization.CultureInfo.CurrentCulture, out result);
        result = tryParse ? result : defaultValue;
    }
    else
    {
        // Unify string (no spaces, only . )
        output = value.Trim().Replace(" ", string.Empty).Replace(",", ".");

        // Split it on points
        string[] split = output.Split('.');

        if (split.Count() > 1)
        {
            // Take all parts except last
            output = string.Join(string.Empty, split.Take(split.Count()-1).ToArray());

            // Combine token parts with last part
            output = string.Format("{0}.{1}", output, split.Last());
        }
        // Parse double invariant
        result = double.Parse(output, System.Globalization.CultureInfo.InvariantCulture);
    }
    return result;
}

1
        var doublePattern = @"(?<integer>[0-9]+)(?:\,|\.)(?<fraction>[0-9]+)";
        var sourceDoubleString = "03444,44426";
        var match = Regex.Match(sourceDoubleString, doublePattern);

        var doubleResult = match.Success ? double.Parse(match.Groups["integer"].Value) + (match.Groups["fraction"].Value == null ? 0 : double.Parse(match.Groups["fraction"].Value) / Math.Pow(10, match.Groups["fraction"].Value.Length)): 0;
        Console.WriteLine("Double of string '{0}' is {1}", sourceDoubleString, doubleResult);

0

सभी पार्स में एक लोकेल निर्दिष्ट करने के बजाय, मैं एक एप्लिकेशन वाइड लोकेल सेट करना पसंद करता हूं, हालांकि अगर स्ट्रिंग प्रारूप ऐप के अनुरूप नहीं हैं, तो यह काम नहीं कर सकता है।

CultureInfo.DefaultThreadCurrentCulture = new CultureInfo("pt-PT");
CultureInfo.DefaultThreadCurrentUICulture = new CultureInfo("pt-PT");

अपने आवेदन की शुरुआत में इसे परिभाषित करने से सभी डबल पार्स दशमलव अल्पविराम के रूप में अल्पविराम की उम्मीद करेंगे। आप एक उपयुक्त स्थान निर्धारित कर सकते हैं ताकि दशमलव और हजारों विभाजक आपके द्वारा पार्स किए जा रहे तार को फिट कर सकें।


0

दशमलव विभाजक को देखने के लिए निर्दिष्ट किए बिना यह मुश्किल है, लेकिन यदि आप ऐसा करते हैं, तो यह वह है जो मैं उपयोग कर रहा हूं:

    public static double Parse(string str, char decimalSep)
    {
        string s = GetInvariantParseString(str, decimalSep);
        return double.Parse(s, System.Globalization.CultureInfo.InvariantCulture);
    }

    public static bool TryParse(string str, char decimalSep, out double result)
    {
        // NumberStyles.Float | NumberStyles.AllowThousands got from Reflector
        return double.TryParse(GetInvariantParseString(str, decimalSep), NumberStyles.Float | NumberStyles.AllowThousands, System.Globalization.CultureInfo.InvariantCulture, out result);
    }

    private static string GetInvariantParseString(string str, char decimalSep)
    {
        str = str.Replace(" ", "");

        if (decimalSep != '.')
            str = SwapChar(str, decimalSep, '.');

        return str;
    }
    public static string SwapChar(string value, char from, char to)
    {
        if (value == null)
            throw new ArgumentNullException("value");

        StringBuilder builder = new StringBuilder();

        foreach (var item in value)
        {
            char c = item;
            if (c == from)
                c = to;
            else if (c == to)
                c = from;

            builder.Append(c);
        }
        return builder.ToString();
    }

    private static void ParseTestErr(string p, char p_2)
    {
        double res;
        bool b = TryParse(p, p_2, out res);
        if (b)
            throw new Exception();
    }

    private static void ParseTest(double p, string p_2, char p_3)
    {
        double d = Parse(p_2, p_3);
        if (d != p)
            throw new Exception();
    }

    static void Main(string[] args)
    {
        ParseTest(100100100.100, "100.100.100,100", ',');
        ParseTest(100100100.100, "100,100,100.100", '.');
        ParseTest(100100100100, "100.100.100.100", ',');
        ParseTest(100100100100, "100,100,100,100", '.');
        ParseTestErr("100,100,100,100", ',');
        ParseTestErr("100.100.100.100", '.');
        ParseTest(100100100100, "100 100 100 100.0", '.');
        ParseTest(100100100.100, "100 100 100.100", '.');
        ParseTest(100100100.100, "100 100 100,100", ',');
        ParseTest(100100100100, "100 100 100,100", '.');
        ParseTest(1234567.89, "1.234.567,89", ',');    
        ParseTest(1234567.89, "1 234 567,89", ',');    
        ParseTest(1234567.89, "1 234 567.89",     '.');
        ParseTest(1234567.89, "1,234,567.89",    '.');
        ParseTest(1234567.89, "1234567,89",     ',');
        ParseTest(1234567.89, "1234567.89",  '.');
        ParseTest(123456789, "123456789", '.');
        ParseTest(123456789, "123456789", ',');
        ParseTest(123456789, "123.456.789", ',');
        ParseTest(1234567890, "1.234.567.890", ',');
    }

यह किसी भी संस्कृति के साथ काम करना चाहिए। यह सही तरीके से उन स्ट्रिंग को पार्स करने में विफल रहता है, जिसमें एक से अधिक दशमलव विभाजक होते हैं, कार्यान्वयन के विपरीत जो स्वैप के बजाय बदल जाते हैं।


0

मैंने @JanW के कोड में भी सुधार किया ...

मुझे चिकित्सा उपकरणों से परिणामों को प्रारूपित करने की आवश्यकता है, और वे "> 1000", "23.3e02", "350E-02", और "नकारात्मक" भी भेजते हैं।

private string FormatResult(string vResult)
{
  string output;
  string input = vResult;

  // Unify string (no spaces, only .)
  output = input.Trim().Replace(" ", "").Replace(",", ".");

  // Split it on points
  string[] split = output.Split('.');

  if (split.Count() > 1)
  {
    // Take all parts except last
    output = string.Join("", split.Take(split.Count() - 1).ToArray());

    // Combine token parts with last part
    output = string.Format("{0}.{1}", output, split.Last());
  }
  string sfirst = output.Substring(0, 1);

  try
  {
    if (sfirst == "<" || sfirst == ">")
    {
      output = output.Replace(sfirst, "");
      double res = Double.Parse(output);
      return String.Format("{1}{0:0.####}", res, sfirst);
    }
    else
    {
      double res = Double.Parse(output);
      return String.Format("{0:0.####}", res);
    }
  }
  catch
  {
    return output;
  }
}

-2
System.Globalization.CultureInfo ci = System.Globalization.CultureInfo.CurrentCulture;

string _pos = dblstr.Replace(".",
    ci.NumberFormat.NumberDecimalSeparator).Replace(",",
        ci.NumberFormat.NumberDecimalSeparator);

double _dbl = double.Parse(_pos);

-3

मुझे लगता है कि यह सबसे अच्छा जवाब है:

public static double StringToDouble(string toDouble)
{
    toDouble = toDouble.Replace(",", "."); //Replace every comma with dot

    //Count dots in toDouble, and if there is more than one dot, throw an exception.
    //Value such as "123.123.123" can't be converted to double
    int dotCount = 0;
    foreach (char c in toDouble) if (c == '.') dotCount++; //Increments dotCount for each dot in toDouble
    if (dotCount > 1) throw new Exception(); //If in toDouble is more than one dot, it means that toCount is not a double

    string left = toDouble.Split('.')[0]; //Everything before the dot
    string right = toDouble.Split('.')[1]; //Everything after the dot

    int iLeft = int.Parse(left); //Convert strings to ints
    int iRight = int.Parse(right);

    //We must use Math.Pow() instead of ^
    double d = iLeft + (iRight * Math.Pow(10, -(right.Length)));
    return d;
}

अपने कोड की व्याख्या करना और अधिक विवरण प्रदान करना सहायक होगा।
चार्ली फिश

यहाँ क्या समझा जाए? सब कुछ टिप्पणियों में है
Endorphinex

-3

नीचे कम कुशल है, लेकिन मैं इस तर्क का उपयोग करता हूं। यह तभी मान्य है जब आपके पास दशमलव बिंदु के बाद दो अंक हों।

double val;

if (temp.Text.Split('.').Length > 1)
{
    val = double.Parse(temp.Text.Split('.')[0]);

    if (temp.Text.Split('.')[1].Length == 1)
        val += (0.1 * double.Parse(temp.Text.Split('.')[1]));
    else
        val += (0.01 * double.Parse(temp.Text.Split('.')[1]));
}
else
    val = double.Parse(RR(temp.Text));

-5

संख्या को गुणा करें और फिर इसे पहले से गुणा करके इसे विभाजित करें।

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

perc = double.Parse("3.555)*1000;
result = perc/1000
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.