Làm cách nào để phân tích một chuỗi có dấu thập phân thành gấp đôi?

Tôi muốn phân tích một chuỗi như "3.5"gấp đôi. Tuy nhiên,

double.Parse("3.5") 

mang lại 35 và

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

ném a FormatException.

Bây giờ ngôn ngữ máy tính của tôi được đặt thành tiếng Đức, trong đó dấu phẩy được sử dụng làm dấu tách thập phân. Nó có thể phải làm một cái gì đó với điều đó và double.Parse()mong đợi "3,5"là đầu vào, nhưng tôi không chắc chắn.

Làm cách nào tôi có thể phân tích một chuỗi chứa một số thập phân có thể hoặc không thể được định dạng như được chỉ định trong ngôn ngữ hiện tại của tôi?

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

Tôi thường sử dụng chức năng đa văn hóa để phân tích cú pháp đầu vào của người dùng, chủ yếu là vì nếu ai đó đã quen với numpad và đang sử dụng văn hóa sử dụng dấu phẩy làm dấu tách thập phân, người đó sẽ sử dụng điểm của dấu phẩy thay vì dấu phẩy.

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

Hãy coi chừng, ý kiến ​​@nikie là đúng. Để bảo vệ tôi, tôi sử dụng chức năng này trong một môi trường được kiểm soát nơi tôi biết rằng văn hóa có thể là en-US, en-CA hoặc fr-CA. Tôi sử dụng chức năng này bởi vì trong tiếng Pháp, chúng tôi sử dụng dấu phẩy làm dấu tách thập phân, nhưng bất kỳ ai từng làm việc trong lĩnh vực tài chính sẽ luôn sử dụng dấu tách thập phân trên numpad, nhưng đây là một điểm chứ không phải dấu phẩy. Vì vậy, ngay cả trong văn hóa fr-CA, tôi cần phân tích số sẽ có một điểm là dấu phân cách thập phân.

Tôi không thể viết bình luận, vì vậy tôi viết ở đây:

double.Pude ("3.5", CultureInfo.InvariantCARM) không phải là một ý tưởng hay, bởi vì ở Canada chúng tôi viết 3,5 thay vì 3,5 và kết quả là hàm này mang lại cho chúng tôi 35 kết quả.

Tôi đã thử nghiệm cả trên máy tính của mình:

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

Đây là một cách chính xác mà Pierre-Alain Vigeant đã đề cập

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)

Thay thế dấu phẩy bằng một điểm trước khi phân tích cú pháp. Hữu ích ở các quốc gia có dấu phẩy là dấu phân cách thập phân. Hãy suy nghĩ về việc giới hạn đầu vào của người dùng (nếu cần) ở một dấu phẩy hoặc điểm.

Bí quyết là sử dụng văn hóa bất biến, phân tích dấu chấm trong tất cả các nền văn hóa.

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

Hãy nhìn xem, mọi câu trả lời ở trên đề xuất viết thay thế chuỗi bằng một chuỗi không đổi chỉ có thể sai. Tại sao? Bởi vì bạn không tôn trọng cài đặt vùng của Windows! Windows đảm bảo người dùng có quyền tự do đặt bất kỳ ký tự phân tách nào họ muốn. S / Anh ta có thể mở bảng điều khiển, đi vào bảng điều khiển khu vực, nhấp vào nâng cao và thay đổi nhân vật bất cứ lúc nào. Ngay cả trong chương trình của bạn chạy. Hãy nghĩ về điều này. Một giải pháp tốt phải nhận thức được điều này.

Vì vậy, trước tiên bạn sẽ phải tự hỏi, con số này đến từ đâu, mà bạn muốn phân tích. Nếu nó đến từ đầu vào trong .NET Framework thì không vấn đề gì, bởi vì nó sẽ có cùng định dạng. Nhưng có lẽ nó đến từ bên ngoài, có thể từ một máy chủ bên ngoài, có thể từ một DB cũ chỉ hỗ trợ các thuộc tính chuỗi. Ở đó, quản trị viên db nên đưa ra một quy tắc trong đó định dạng các số sẽ được lưu trữ. Nếu bạn biết ví dụ rằng đó sẽ là một US DB có định dạng US, bạn có thể sử dụng đoạn mã này:

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

Điều này sẽ hoạt động tốt ở bất cứ đâu trên thế giới. Và vui lòng không sử dụng 'Convert.ToXxxx'. Lớp 'Convert' chỉ được coi là cơ sở cho các chuyển đổi theo bất kỳ hướng nào. Ngoài ra: Bạn cũng có thể sử dụng cơ chế tương tự cho DateTimes.

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

Hai xu của tôi về chủ đề này, cố gắng cung cấp một phương thức chuyển đổi kép, chung chung:

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

Hoạt động như mong đợi với:

• 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,11,88
• 0,99.000.111,88,88

Không chuyển đổi mặc định được thực hiện, vì vậy nó sẽ không cố gắng để phân tích 1.3,14, 1,3.14hoặc các trường hợp tương tự.

Các mã sau đây thực hiện công việc trong bất kỳ kịch bản. Đó là một chút phân tích cú pháp.

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

Tôi nghĩ chuyển đổi chính xác 100% là không thể, nếu giá trị đến từ đầu vào của người dùng. ví dụ: nếu giá trị là 123.456, nó có thể là một nhóm hoặc nó có thể là một dấu thập phân. Nếu bạn thực sự cần 100%, bạn phải mô tả định dạng của mình và đưa ra một ngoại lệ nếu nó không đúng.

Nhưng tôi đã cải thiện mã của JanW, vì vậy chúng tôi nhận được thêm một chút về phía trước tới 100%. Ý tưởng đằng sau là, nếu dấu phân cách cuối cùng là một nhómSeperator, thì đây sẽ là một kiểu số nguyên, hơn là một số kép.

Các mã tăng là trong lần đầu tiên nếu các 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);

Thay vì phải chỉ định một miền trong tất cả các phân tích cú pháp, tôi thích đặt một miền rộng ứng dụng, mặc dù nếu các định dạng chuỗi không nhất quán trên ứng dụng, điều này có thể không hoạt động.

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

Xác định điều này khi bắt đầu ứng dụng của bạn sẽ làm cho tất cả các phân tích cú pháp kép mong đợi một dấu phẩy là dấu phân cách thập phân. Bạn có thể đặt một miền địa phương phù hợp sao cho dấu thập phân và dấu phân cách hàng nghìn phù hợp với chuỗi bạn đang phân tích cú pháp.

Thật khó khăn khi không chỉ định phân tách thập phân nào cần tìm, nhưng nếu bạn làm thế, đây là thứ tôi đang sử dụng:

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

Điều này nên làm việc với bất kỳ văn hóa. Nó chính xác không phân tích các chuỗi có nhiều hơn một dấu phân cách thập phân, không giống như các triển khai thay thế thay vì hoán đổi.

Tôi cũng đã cải thiện mã của @JanW ...

Tôi cần nó để định dạng kết quả từ các dụng cụ y tế và họ cũng gửi "> 1000", "23.3e02", "350E-02" và "NEGECT".

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

Tôi nghĩ đó là câu trả lời tốt nhất:

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

Dưới đây là ít hiệu quả hơn, nhưng tôi sử dụng logic này. Điều này chỉ hợp lệ nếu bạn có hai chữ số sau dấu thập phân.

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

Nhân số và sau đó chia nó với số bạn đã nhân nó trước đó.

Ví dụ,

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