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

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?

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

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.

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

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.

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

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.

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

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.

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

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

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

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.

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.

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

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

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

double _dbl = double.Parse(_pos);

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

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

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