Wie analysiere ich eine Zeichenfolge mit einem Dezimalpunkt zu einem Double?

230

Ich möchte einen String wie "3.5"einen Double analysieren . Jedoch,

double.Parse("3.5") 

ergibt 35 und

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

wirft a FormatException.

Jetzt ist das Gebietsschema meines Computers auf Deutsch eingestellt, wobei ein Komma als Dezimaltrennzeichen verwendet wird. Es könnte etwas damit zu tun haben und als Eingabe double.Parse()erwarten "3,5", aber ich bin nicht sicher.

Wie kann ich eine Zeichenfolge analysieren, die eine Dezimalzahl enthält, die möglicherweise wie in meinem aktuellen Gebietsschema angegeben formatiert ist oder nicht?

CodeCaster
quelle
Das Dezimalkomma wirkt sich sicherlich auf die Ausgabe aus.
ChrisF
12
Vergessen Sie nicht die double.TryParse () -Methode, wenn sie für Ihre Situation geeignet ist.
Kyle Gagnet

Antworten:

414
double.Parse("3.5", CultureInfo.InvariantCulture)
Mehrdad Afshari
quelle
Ich benutze die XmlConvertKlasse gerne ... hast du irgendwelche Ideen, ob dies besser, schlechter und / oder anders ist als die Verwendung CultureInfo.InvariantCulture?
ChrisW
1
Nun, XmlConvertist nicht wirklich dazu gedacht, einen einzelnen Doppelwert im Code zu analysieren. Ich bevorzuge zu verwenden double.Parseoder Convert.ToDoubledas macht meine Absicht offensichtlich.
Mehrdad Afshari
4
Dies bedeutet doulble.Parse verwendet die Standardkultur, die möglicherweise keinen Punkt als Dezimalpunkt enthält?
Ahmed Said
3
Wenn 12345678.12345678 konvertiert wird, konvertiert es auch 12345678.123457
PUG
4
hat bei mir nicht funktioniert: überspringt Komma und kehrt zurück und int als double
fnc12
75

Normalerweise verwende ich eine Multikulturfunktion, um Benutzereingaben zu analysieren, hauptsächlich, weil jemand, der an das Nummernfeld gewöhnt ist und eine Kultur verwendet, die ein Komma als Dezimaltrennzeichen verwendet, den Punkt des Nummernblocks anstelle eines Kommas verwendet.

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

Achtung, @ nikie Kommentare sind wahr. Zu meiner Verteidigung verwende ich diese Funktion in einer kontrollierten Umgebung, in der ich weiß, dass die Kultur entweder en-US, en-CA oder fr-CA sein kann. Ich benutze diese Funktion, weil wir auf Französisch das Komma als Dezimaltrennzeichen verwenden, aber jeder, der jemals im Finanzbereich gearbeitet hat, wird immer das Dezimaltrennzeichen auf dem Nummernblock verwenden, aber dies ist ein Punkt, kein Komma. Selbst in der fr-CA-Kultur muss ich eine Zahl analysieren, die einen Punkt als Dezimaltrennzeichen hat.

Pierre-Alain Vigeant
quelle
18
Ich bin mir nicht sicher, ob das eine gute Idee ist. Sie können ein Double nicht zuverlässig analysieren, wenn Sie die Kultur nicht kennen: In Deutschland können Doppelwerte '.' Enthalten, aber dort werden sie als Tausendertrennzeichen betrachtet. In Legates Fall würde GetDouble ("3.5") also 35 in einem deutschen Gebietsschema und 3.5 in einer en-us-Umgebung zurückgeben.
Niki
Nein, Pierre Alain hat recht, da es genau so ist, wie es geschrieben steht. Wenn Ihre Kultur sagt, dass "Punkt ist tausend" Trennzeichen, dann wird "3.5" als "35" angesehen und es ist gut. Wenn Sie jedoch keine Regeln für den "Punkt" festlegen, wird das Zeichen als Dezimalpunkt analysiert und funktioniert auch. Ich hätte es vermieden, die enUS-Kultur auszuprobieren, aber es ist eine persönliche Entscheidung.
Xryl669
Wenn Sie in Kultur mit Komma Numpad verwenden, wird die Punkttaste als Komma gesetzt.
CrazyBaran
Das Dezimaltrennzeichen für das Nummernfeld hängt vom Tastaturlayout ab (und nicht von den regionalen Einstellungen - zumindest unter Windows 7) (ich verwende Ungarisch zum Schreiben von Text, E-Mails ... und en-US zum Schreiben von Code, daher kann es sich um einen Punkt handeln oder Komma. Ich verwende auch benutzerdefinierte regionale Einstellungen, bei denen ich das Dezimaltrennzeichen von ',' in '.' und das Listentrennzeichen von ';' in ',' geändert habe. Sie wissen, verursachen CSV ... Viel Glück für uns alle, die Multi schreiben -Kultur-Apps;)
Steven Spark
25

Ich konnte keinen Kommentar schreiben, also schreibe ich hier:

double.Parse ("3.5", CultureInfo.InvariantCulture) ist keine gute Idee, da wir in Kanada 3,5 statt 3,5 schreiben und diese Funktion 35 ergibt.

Ich habe beide auf meinem Computer getestet:

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

Dies ist ein korrekter Weg, den Pierre-Alain Vigeant erwähnt hat

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;
}
Malus Jan.
quelle
1
Betreff: "... weil wir in Kanada 3,5 statt 3,5 schreiben" Sind Sie sich da sicher? Laut Dezimalzeichen : "Länder, in denen ein Punkt". "Als Dezimalzeichen verwendet wird, umfassen ... Kanada (bei Verwendung von Englisch)" . Geht es nicht mehr um die Verwendung einer französischen Windows-Version?
Peter Mortensen
Baybe wegen der französischen Version. In Montreal schreiben wir 3,5 nicht 3,5
Malus Jan
Nach Ihrer Logik gibt also immer nur 1 von ihnen true zurück?
Batmaci
Schau es
Malus Jan
Es liegt immer noch ein Fehler vor. Für die Eingabezeichenfolge wie GetDouble ("10 ,,,,,,,, 0", 0.0). Die erwähnte Funktion gibt 100 zurück.
Krivers
20
Double.Parse("3,5".Replace(',', '.'), CultureInfo.InvariantCulture)

Ersetzen Sie das Komma vor dem Parsen durch einen Punkt. Nützlich in Ländern mit einem Komma als Dezimaltrennzeichen. Denken Sie daran, Benutzereingaben (falls erforderlich) auf ein Komma oder einen Punkt zu beschränken.

Baluda
quelle
1
Viel korrektere Antwort als die mit +133 Stimmen ... Es erlaubt, auf beiden Systemen mit "," oder "zu leben. Dezimaltrennzeichen ...
Badiboy
@Badiboy kannst du erklären, was mit dieser Antwort falsch ist? Soweit ich weiß, hat InvariantCulture immer '.' als Dezimaltrennzeichen. Es sollte also für beide Systeme funktionieren.
Alex P.
@ Alex11223 Du hast recht. Deshalb habe ich gesagt, dass diese Antwort besser ist als die populärere. PS: Freundlicherweise spricht dieser Code auch aus, wenn Sie das "," als LIST SEPARATOR (dh 1.234.560,01) haben, aber ich weiß nicht, wie ich das überhaupt lösen soll. :)
Badiboy
4
Dies ist keine gute Antwort, da in einigen Kulturen das Tausendertrennzeichen ist und verwendet werden kann. Wenn Sie es durch einen Punkt ersetzen, haben Sie am Ende mehrere Punkte und das Parsen schlägt fehl: Double.Parse ((12345.67) .ToString ("N", neues CultureInfo ("en")). Ersetzen Sie (',', '. '), CultureInfo.InvariantCulture), weil (12345.67) .ToString ("N", neues CultureInfo ("en")). Ersetzen (', ','. ') Als "12.345.67" formatiert wird
Kodierungsdave
1.234,56 -> 1.234,56 nicht Parser. Eine andere Idee ist zu überprüfen, ob die Nummer '.' enthält. und ',' und ersetzen ',' durch leere Zeichenfolge und wenn nur ',' Komma ersetzen ersetzen durch '.'
GDocal
16

Der Trick besteht darin, eine invariante Kultur zu verwenden, um Punkte in allen Kulturen zu analysieren.

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

Schauen Sie, jede Antwort oben, die vorschlägt, eine Zeichenfolge durch eine konstante Zeichenfolge zu ersetzen, kann nur falsch sein. Warum? Weil Sie die Regionseinstellungen von Windows nicht respektieren! Windows stellt sicher, dass der Benutzer die Freiheit hat, beliebige Trennzeichen festzulegen. Er kann das Bedienfeld öffnen, in das Regionsfenster gehen, auf Erweitert klicken und den Charakter jederzeit ändern. Auch während Ihres Programmlaufs. Denken Sie daran. Eine gute Lösung muss sich dessen bewusst sein.

Zuerst müssen Sie sich fragen, woher diese Nummer kommt, die Sie analysieren möchten. Wenn es von der Eingabe in .NET Framework kommt, kein Problem, da es im gleichen Format sein wird. Aber vielleicht kam es von außen, vielleicht von einem externen Server, vielleicht von einer alten Datenbank, die nur String-Eigenschaften unterstützt. Dort sollte der Datenbankadministrator eine Regel angegeben haben, in welchem ​​Format die Nummern gespeichert werden sollen. Wenn Sie beispielsweise wissen, dass es sich um eine US-Datenbank im US-Format handelt, können Sie diesen Code verwenden:

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

Dies wird überall auf der Welt gut funktionieren. Und bitte verwenden Sie nicht 'Convert.ToXxxx'. Die 'Convert'-Klasse dient nur als Basis für Conversions in jede Richtung. Außerdem: Sie können den ähnlichen Mechanismus auch für DateTimes verwenden.

AndresRohrAtlasInformatik
quelle
Einverstanden! Der Versuch, Kulturfunktionen manuell zu implementieren, führt schließlich zu einem Fall, den Sie nicht erwartet haben, und zu großen Kopfschmerzen. Lassen Sie .NET richtig damit umgehen.
Khalos
2
Ein großes Problem ist, wenn Benutzer ein Dezimaltrennzeichen verwenden, das für seine kulturellen Einstellungen nicht als Dezimaltrennzeichen gilt
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)));
Martin
quelle
2

Meine zwei Cent zu diesem Thema, die versuchen, eine generische, doppelte Konvertierungsmethode bereitzustellen:

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

Funktioniert wie erwartet mit:

  • 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

Keine Standardkonvertierung implementiert ist , so wäre es nicht zu analysieren versuchen 1.3,14, 1,3.14oder ähnliche Fälle.

eduherminio
quelle
1
"1.000", die als eintausend gedacht sind, werden fehlschlagen.
Defkon1
1

Der folgende Code erledigt den Job in jedem Szenario. Es ist ein bisschen Parsen.

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);
}
JanW
quelle
2
1.234.567.890 würde 1234567.890
Dan Vogel
Ich habe es nicht versucht, aber wenn Sie die App in verschiedenen Kultur-SOs ausführen, würde dieser Code nicht den Trick machen, denke ich: /
Dani BISHOP
1

Ich denke, eine 100% korrekte Konvertierung ist nicht möglich, wenn der Wert aus einer Benutzereingabe stammt. Wenn der Wert beispielsweise 123,456 ist, kann es sich um eine Gruppierung oder einen Dezimalpunkt handeln. Wenn Sie wirklich 100% benötigen, müssen Sie Ihr Format beschreiben und eine Ausnahme auslösen, wenn es nicht korrekt ist.

Aber ich habe den Code von JanW verbessert, damit wir ein bisschen mehr auf 100% kommen. Die Idee dahinter ist, dass wenn das letzte Trennzeichen ein groupSeperator ist, dies eher ein ganzzahliger Typ als ein Double ist.

Der hinzugefügte Code befindet sich im ersten if von 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;
}
Schorsch
quelle
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);
Alexander
quelle
0

Anstatt in allen Parses ein Gebietsschema angeben zu müssen, ziehe ich es vor, ein anwendungsweites Gebietsschema festzulegen. Wenn die Zeichenfolgenformate jedoch nicht in der gesamten App konsistent sind, funktioniert dies möglicherweise nicht.

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

Wenn Sie dies zu Beginn Ihrer Anwendung definieren, erwarten alle Doppelparsen ein Komma als Dezimaltrennzeichen. Sie können ein geeignetes Gebietsschema festlegen, sodass das Trennzeichen für Dezimalstellen und Tausenderzeichen zu den Zeichenfolgen passt, die Sie analysieren.

Miguel Mesquita Alfaiate
quelle
0

Es ist schwierig, ohne anzugeben, nach welchem ​​Dezimaltrennzeichen gesucht werden soll, aber wenn Sie dies tun, verwende ich Folgendes:

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

Dies sollte mit jeder Kultur funktionieren. Im Gegensatz zu Implementierungen, die anstelle von Swap ersetzen, können Zeichenfolgen mit mehr als einem Dezimaltrennzeichen nicht korrekt analysiert werden.

osexpert
quelle
0

Ich habe auch den Code von @JanW verbessert ...

Ich brauche es, um Ergebnisse von medizinischen Instrumenten zu formatieren, und sie senden auch "> 1000", "23.3e02", "350E-02" und "NEGATIVE".

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;
  }
}
JacekK
quelle
-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);
Kartal Turgut
quelle
-3

Ich denke, es ist die beste Antwort:

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
quelle
Es wäre hilfreich, Ihren Code zu erklären und mehr Details anzugeben.
Charlie Fish
Was ist hier zu erklären? Alles ist in Kommentaren
Endorphinex
-3

Das Folgende ist weniger effizient, aber ich benutze diese Logik. Dies gilt nur, wenn Sie zwei Nachkommastellen haben.

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));
Fachwissen
quelle
-5

Multiplizieren Sie die Zahl und dividieren Sie sie durch das, womit Sie sie zuvor multipliziert haben.

Beispielsweise,

perc = double.Parse("3.555)*1000;
result = perc/1000
Percy
quelle