正在计算字符串“3*(4+2)” 产量整数 18

Question

.NET 框架是否有一个函数可以计算字符串中包含的数字表达式并返回结果？ Fe：

string mystring = "3*(2+4)";
int result = EvaluateExpression(mystring);
Console.Writeln(result); // Outputs 18

是否有一个标准框架函数可以替代我的 EvaluateExpression 方法？

Answer 1

static double Evaluate(string expression) { 
  var loDataTable = new DataTable(); 
  var loDataColumn = new DataColumn("Eval", typeof (double), expression); 
  loDataTable.Columns.Add(loDataColumn); 
  loDataTable.Rows.Add(0); 
  return (double) (loDataTable.Rows[0]["Eval"]); 
} 

其工作原理说明：

首先，我们在 var loDataTable = new DataTable(); 部分创建一个表，就像在数据库引擎中一样（例如 MS SQL）。

然后是一个带有一些特定参数的列（var loDataColumn = new DataColumn("Eval", typeof (double), expression);）。

"Eval" 参数是列的名称（ColumnName 属性）。

typeof (double) 是要存储在列中的数据类型，相当于 put System.Type.GetType("System.Double"); 。

表达式 是Evaluate 方法接收的字符串，并存储在列的属性Expression 中。 这个属性有一个真正特定的目的（显而易见），即放置在列上的每一行都将用“表达式”填充，并且它实际上接受可以放入 SQL 查询中的任何内容。 请参阅 http:// msdn.microsoft.com/en-us/library/system.data.datacolumn.expression(v=vs.100).aspx 了解可以在 Expression 属性中放入哪些内容以及如何计算它。

然后，loDataTable.Columns.Add(loDataColumn); 将列 loDataColumn 添加到 loDataTable 表中。

然后，通过 loDataTable.Rows.Add(0); 向表中添加一行，其中包含带有 Expression 属性的个性化列。 当我们添加这一行时，表 loDataTable 的“Eval”列的单元格会自动填充其“Expression”属性，并且，如果它有运算符和 SQL 查询等，则会对其进行评估并进行计算然后存储到单元格中，所以，这里发生了“魔术”，带有运算符的字符串被计算并存储到单元格中...

最后，只需返回存储到第 0 行“Eval”列的单元格中的值（它是索引，从零开始计数），并使用 return (double) (loDataTable.Rows[0]["Eval"]); 转换为双精度值。

这就是全部...工作完成！

这里有一个更容易理解的代码，它的作用是相同的......它不在方法内部，并且也进行了解释。

DataTable MyTable = new DataTable();
DataColumn MyColumn = new DataColumn();
MyColumn.ColumnName = "MyColumn";
MyColumn.Expression = "5+5/5"
MyColumn.DataType = typeof(double);
MyTable.Columns.Add(MyColumn);
DataRow MyRow = MyTable.NewRow();
MyTable.Rows.Add(MyRow);
return (double)(MyTable.Rows[0]["MyColumn"]);

首先，使用 DataTable MyTable = new DataTable(); 创建表

，然后使用 DataColumn MyColumn = new DataColumn(); 创建列

，接下来，我们为该列命名。 这样我们就可以在它存储到表中时搜索它的内容。 通过 MyColumn.ColumnName = "MyColumn";

然后是表达式，这里我们可以放置一个字符串类型的变量，在本例中有一个预定义的字符串“5+5/5”，其结果是6.

要存储到列的数据类型 MyColumn.DataType = typeof(double);

将列添加到表中... MyTable.Columns.Add(MyColumn);< /code>

创建一行要插入到表中，这会复制表结构 DataRow MyRow = MyTable.NewRow();

使用 MyTable.Rows.Add( 将行添加到表中MyRow);

并返回表 MyTable 的 MyColumn 列的第 0 行单元格的值，其中 return (double)(MyTable. Rows[0]["MyColumn"]);

课程完成！！！

Answer 2

这是从右到左执行，因此需要使用适当的括号来执行表达式

    // 2+(100/5)+10 = 32
    //((2.5+10)/5)+2.5 = 5
    // (2.5+10)/5+2.5 = 1.6666
    public static double Evaluate(String expr)
    {

        Stack<String> stack = new Stack<String>();

        string value = "";
        for (int i = 0; i < expr.Length; i++)
        {
            String s = expr.Substring(i, 1);
            char chr = s.ToCharArray()[0];

            if (!char.IsDigit(chr) && chr != '.' && value != "")
            {
                stack.Push(value);
                value = "";
            }

            if (s.Equals("(")) {

                string innerExp = "";
                i++; //Fetch Next Character
                int bracketCount=0;
                for (; i < expr.Length; i++)
                {
                    s = expr.Substring(i, 1);

                    if (s.Equals("("))
                        bracketCount++;

                    if (s.Equals(")"))
                        if (bracketCount == 0)
                            break;
                        else
                            bracketCount--;


                    innerExp += s;
                }

                stack.Push(Evaluate(innerExp).ToString());

            }
            else if (s.Equals("+")) stack.Push(s);
            else if (s.Equals("-")) stack.Push(s);
            else if (s.Equals("*")) stack.Push(s);
            else if (s.Equals("/")) stack.Push(s);
            else if (s.Equals("sqrt")) stack.Push(s);
            else if (s.Equals(")"))
            {
            }
            else if (char.IsDigit(chr) || chr == '.')
            {
                value += s;

                if (value.Split('.').Length > 2)
                    throw new Exception("Invalid decimal.");

                if (i == (expr.Length - 1))
                    stack.Push(value);

            }
            else
                throw new Exception("Invalid character.");

        }


        double result = 0;
        while (stack.Count >= 3)
        {

            double right = Convert.ToDouble(stack.Pop());
            string op = stack.Pop();
            double left = Convert.ToDouble(stack.Pop());

            if (op == "+") result = left + right;
            else if (op == "+") result = left + right;
            else if (op == "-") result = left - right;
            else if (op == "*") result = left * right;
            else if (op == "/") result = left / right;

            stack.Push(result.ToString());
        }


        return Convert.ToDouble(stack.Pop());
    }

Answer 3

您可以相当轻松地通过 CSharpCodeProvider 运行它，并使用合适的绒毛包装它（基本上是类型和方法）。 同样，您可以使用 VB 等 - 或 JavaScript，正如另一个答案所建议的那样。 目前我不知道框架中还内置了任何其他内容。

我预计 .NET 4.0 及其对动态语言的支持很可能在这方面具有更好的功能。

Answer 4

我最近需要为一个项目执行此操作，最终使用 IronPython 来做到这一点。 您可以声明引擎的实例，然后传递任何有效的 python 表达式并获取结果。 如果您只是做简单的数学表达式，那么就足够了。 我的代码最终看起来类似于：

IronPython.Hosting.PythonEngine pythonEngine = new IronPython.Hosting.PythonEngine();
string expression = "3*(2+4)";
double result = pythonEngine.EvaluateAs<double>(expression);

您可能不想为每个表达式创建引擎。 您还需要对 IronPython.dll 的引用

Answer 5

编辑：意识到我真的应该将加法和减法分开，以使其更符合 BODMAS 要求。

非常感谢 Rajesh Jinaga 基于堆栈的方法。 我发现它对我的需求非常有用。 以下代码是对 Rajesh 方法的轻微修改，该方法首先处理除法，然后处理乘法，最后处理加法和减法。 它还允许在表达式中使用布尔值，其中 true 被视为 1， false 被视为 0。允许在表达式中使用布尔逻辑。

public static double Evaluate(string expr)
    {
        expr = expr.ToLower();
        expr = expr.Replace(" ", "");
        expr = expr.Replace("true", "1");
        expr = expr.Replace("false", "0");

        Stack<String> stack = new Stack<String>();

        string value = "";
        for (int i = 0; i < expr.Length; i++)
        {
            String s = expr.Substring(i, 1);
            // pick up any doublelogical operators first.
            if (i < expr.Length - 1)
            {
                String op = expr.Substring(i, 2);
                if (op == "<=" || op == ">=" || op == "==")
                {
                    stack.Push(value);
                    value = "";
                    stack.Push(op);
                    i++;
                    continue;
                }
            }

            char chr = s.ToCharArray()[0];

            if (!char.IsDigit(chr) && chr != '.' && value != "")
            {
                stack.Push(value);
                value = "";
            }
            if (s.Equals("("))
            {
                string innerExp = "";
                i++; //Fetch Next Character
                int bracketCount = 0;
                for (; i < expr.Length; i++)
                {
                    s = expr.Substring(i, 1);

                    if (s.Equals("(")) bracketCount++;

                    if (s.Equals(")"))
                    {
                        if (bracketCount == 0) break;
                        bracketCount--;
                    }
                    innerExp += s;
                }
                stack.Push(Evaluate(innerExp).ToString());
            }
            else if (s.Equals("+") ||
                     s.Equals("-") ||
                     s.Equals("*") ||
                     s.Equals("/") ||
                     s.Equals("<") ||
                     s.Equals(">"))
            {
                stack.Push(s);
            }
            else if (char.IsDigit(chr) || chr == '.')
            {
                value += s;

                if (value.Split('.').Length > 2)
                    throw new Exception("Invalid decimal.");

                if (i == (expr.Length - 1))
                    stack.Push(value);

            }
            else
            {
                throw new Exception("Invalid character.");
            }

        }
        double result = 0;
        List<String> list = stack.ToList<String>();
        for (int i = list.Count - 2; i >= 0; i--)
        {
            if (list[i] == "/")
            {
                list[i] = (Convert.ToDouble(list[i - 1]) / Convert.ToDouble(list[i + 1])).ToString();
                list.RemoveAt(i + 1);
                list.RemoveAt(i - 1);
                i -= 2;
            }
        }

        for (int i = list.Count - 2; i >= 0; i--)
        {
            if (list[i] == "*")
            {
                list[i] = (Convert.ToDouble(list[i - 1]) * Convert.ToDouble(list[i + 1])).ToString();
                list.RemoveAt(i + 1);
                list.RemoveAt(i - 1);
                i -= 2;
            }
        }
        for (int i = list.Count - 2; i >= 0; i--)
        {
            if (list[i] == "+")
            {
                list[i] = (Convert.ToDouble(list[i - 1]) + Convert.ToDouble(list[i + 1])).ToString();
                list.RemoveAt(i + 1);
                list.RemoveAt(i - 1);
                i -= 2;
            }
        }
        for (int i = list.Count - 2; i >= 0; i--)
        {
            if (list[i] == "-")
            {
                list[i] = (Convert.ToDouble(list[i - 1]) - Convert.ToDouble(list[i + 1])).ToString();
                list.RemoveAt(i + 1);
                list.RemoveAt(i - 1);
                i -= 2;
            }
        }
        stack.Clear();
        for (int i = 0; i < list.Count; i++)
        {
            stack.Push(list[i]);
        }
        while (stack.Count >= 3)
        {
            double right = Convert.ToDouble(stack.Pop());
            string op = stack.Pop();
            double left = Convert.ToDouble(stack.Pop());

            if (op == "<") result = (left < right) ? 1 : 0;
            else if (op == ">") result = (left > right) ? 1 : 0;
            else if (op == "<=") result = (left <= right) ? 1 : 0;
            else if (op == ">=") result = (left >= right) ? 1 : 0;
            else if (op == "==") result = (left == right) ? 1 : 0;

            stack.Push(result.ToString());
        }
        return Convert.ToDouble(stack.Pop());
    }

我知道可能有一种更干净的方法来做到这一点，我想我只是分享一下它的第一眼，以防有人发现它有用。

Answer 6

非常感谢拉梅什。 我使用他的简单代码的一个版本从数据库中提取一个字符串，并用它在我的代码中执行布尔运算。

x 是一个数字，如 1500 或 2100 等。

函数将是一个存储的评估，例如 x > 1400且x＜1 1600

function = relation[0].Replace("and","&&").Replace("x",x);

DataTable f_dt = new DataTable();
var f_var = f_dt.Compute(function,"");

if (bool.Parse(f_var.ToString()) { do stuff  }

Answer 7

那没有。 您将需要使用一些外部库，或编写自己的解析器。 如果您有时间这样做，我建议您编写自己的解析器，因为这是一个非常有趣的项目。 否则，您将需要使用类似 bcParser 的东西。

Answer 8

简短回答：我不这么认为。 据我所知，C# .Net 已编译（为字节码），并且无法在运行时评估字符串。 然而，JScript .Net 可以； 但我仍然建议您自己编写一个解析器和基于堆栈的求值器。

Answer 9

如果您想计算字符串表达式，请使用以下代码片段。

using System.Data;

DataTable dt = new DataTable();
var v = dt.Compute("3 * (2+4)","");

Answer 10

使用编译器执行此操作意味着内存泄漏，因为生成的程序集已加载但从未释放。 它的性能也低于使用真正的表达式解释器。 为此，您可以使用 Ncalc，这是一个仅用于此目的的开源框架。 如果已经包含的变量和自定义函数还不够，您还可以定义自己的变量和自定义函数。

例子：

Expression e = new Expression("2 + 3 * 5");
Debug.Assert(17 == e.Evaluate());

Answer 11

尝试这个：

static double Evaluate(string expression) {
  var loDataTable = new DataTable();
  var loDataColumn = new DataColumn("Eval", typeof (double), expression);
  loDataTable.Columns.Add(loDataColumn);
  loDataTable.Rows.Add(0);
  return (double) (loDataTable.Rows[0]["Eval"]);
}

Answer 12

您可以查看“XpathNavigator.Evaluate”，我用它来处理我的 GridView 的数学表达式，它对我来说效果很好。

这是我的程序使用的代码：

public static double Evaluate(string expression)
{
    return (double)new System.Xml.XPath.XPathDocument
    (new StringReader("<r/>")).CreateNavigator().Evaluate
    (string.Format("number({0})", new
    System.Text.RegularExpressions.Regex(@"([\+\-\*])")
    .Replace(expression, " ${1} ")
    .Replace("/", " div ")
    .Replace("%", " mod ")));
}

Answer 13

这是一个使用堆栈的简单表达式求值器

public class MathEvaluator
{
    public static void Run()
    {
        Eval("(1+2)");
        Eval("5*4/2");
        Eval("((3+5)-6)");
    }

    public static void Eval(string input)
    {
        var ans = Evaluate(input);
        Console.WriteLine(input + " = " + ans);
    }

    public static double Evaluate(String input)
    {
        String expr = "(" + input + ")";
        Stack<String> ops = new Stack<String>();
        Stack<Double> vals = new Stack<Double>();

        for (int i = 0; i < expr.Length; i++)
        {
            String s = expr.Substring(i, 1);
            if (s.Equals("(")){}
            else if (s.Equals("+")) ops.Push(s);
            else if (s.Equals("-")) ops.Push(s);
            else if (s.Equals("*")) ops.Push(s);
            else if (s.Equals("/")) ops.Push(s);
            else if (s.Equals("sqrt")) ops.Push(s);
            else if (s.Equals(")"))
            {
                int count = ops.Count;
                while (count > 0)
                {
                    String op = ops.Pop();
                    double v = vals.Pop();
                    if (op.Equals("+")) v = vals.Pop() + v;
                    else if (op.Equals("-")) v = vals.Pop() - v;
                    else if (op.Equals("*")) v = vals.Pop()*v;
                    else if (op.Equals("/")) v = vals.Pop()/v;
                    else if (op.Equals("sqrt")) v = Math.Sqrt(v);
                    vals.Push(v);

                    count--;
                }
            }
            else vals.Push(Double.Parse(s));
        }
        return vals.Pop();
    }
}