解析表达式的最佳方法 - 多个变量

Question

我有一种情况，我需要解析多个 n 个相关字段（不想评估）：

    string exp1 = "10";
    string exp2 = "20";
    string exp3= "exp1 + exp2 + 30";
    string exp4 = "exp5 - exp3"; 
    string exp5 = "exp3 / 10";

    Dictionary<string,string> expressions = new Dictionary<string,string>();
    expressions.Add("exp1", exp1);
    expressions.Add("exp2", exp2);
    expressions.Add("exp3", exp3);
    expressions.Add("exp4", exp3);
    expressions.Add("exp5", exp5);

现在我们要遍历所有表达式字段并用实际值解析表达式（也应该应用 Bodmas）。所以，解析后，我们希望下面作为输出：

exp1 = "10";
exp2 = "20";
exp3= "10 + 20 + 30";
exp4 = "((10 + 20 + 30 )/10) - (10+ 20 + 30)";
exp5 = "(10 + 29 + 30)/ 10";

我应该在这里使用什么数据结构来使用通用方式对其进行解析？会是二叉树、图表、表达式树吗？

Answer 1

守则

using System.Collections.Generic;
using Microsoft.VisualBasic;    //the code was written in VB and converted. make appropriate changes if you don't want to use this namespace

class Exp
{
    private Dictionary<string, string> AllExpressions = new Dictionary<string, string>();

    public void Add(string name, string value)
    {
        AllExpressions.Add(name, value);
    }

    public string ValueOf(string name)
    {
        var parts = Strings.Split(AllExpressions[name]);
        for (int i = 0; i <= parts.Length - 1; i++)
        {
            if (AllExpressions.ContainsKey(parts[i]))
            {
                var partVal = ValueOf(parts[i]);
                parts[i] =  Information.IsNumeric(partVal) ? partVal : $"({partVal})";
            }
        }
        return Strings.Join(parts);
    }
}

用法

Exp myExp = new Exp();
myExp.Add("exp1", "10");
myExp.Add("exp2", "20");
myExp.Add("exp3", "exp1 + exp2 + 30");
myExp.Add("exp4", "exp5 - exp3");
myExp.Add("exp5", "exp3 / 10");

// Test to see if we can get correct values 
Console.WriteLine(myExp.ValueOf("exp1"));
Console.WriteLine(myExp.ValueOf("exp2"));
Console.WriteLine(myExp.ValueOf("exp3"));
Console.WriteLine(myExp.ValueOf("exp4"));
Console.WriteLine(myExp.ValueOf("exp5"));

结果

10
20
10 + 20 + 30
((10 + 20 + 30) / 10) - (10 + 20 + 30)
(10 + 20 + 30) / 10

Answer 2

字符串替换是不可避免的，但我们可以通过一个类来表示我们的表达式来减少循环和替换操作的数量。当我们将算术表达式包装在引用类型中时，我们可以添加特征并在以后使用它们：

public class ArithmeticExpression
{
    public string Value;
    public bool IsLiteral;
    public bool IsFinalized;

    public string ArithmeticSafeValue { get { return IsLiteral ? Value : "(" + Value + ")"; } }

    public ArithmeticExpression(string value)
    {
        Value = value;
        int dummy;
        IsFinalized = IsLiteral = int.TryParse(value, out dummy);
    }
}

下面是评估我们表达式最终版本的方法，将它们更改为文字：

private static void Resolve(Dictionary<string, ArithmeticExpression> expressions)
{
    foreach (string expressionKey in expressions.Keys.ToArray())
    {
        Resolve(expressionKey, expressions);
    }
}

private static void Resolve(string expressionKey, Dictionary<string, ArithmeticExpression> expressions)
{
    ArithmeticExpression expression = expressions[expressionKey];

    if (expression.IsFinalized) return;

    List<string> containedExpressions = expressions.Keys.Where(x => expression.Value.Contains(x)).ToList();
    if (containedExpressions.Count > 0)
    {
        containedExpressions.ForEach((x) => Resolve(x, expressions));
        containedExpressions.ForEach((x) => expression.Value = expression.Value.Replace(x, expressions[x].ArithmeticSafeValue));
        expression.IsFinalized = true;
    }
}

下面是如何使用它：

public static void Main()
{
    string exp1 = "10";
    string exp2 = "20";
    string exp3 = "exp1 + exp2 + 30";
    string exp4 = "exp5 - exp3";
    string exp5 = "exp3 / 10";

    Dictionary<string, ArithmeticExpression> expressions = new Dictionary<string, ArithmeticExpression>();
    expressions.Add("exp1", new ArithmeticExpression(exp1));
    expressions.Add("exp2", new ArithmeticExpression(exp2));
    expressions.Add("exp3", new ArithmeticExpression(exp3));
    expressions.Add("exp4", new ArithmeticExpression(exp4));
    expressions.Add("exp5", new ArithmeticExpression(exp5));

    Resolve(expressions);
    expressions.Keys.ToList().ForEach
    (
        (x) => Console.WriteLine("{0}: {1}", x, expressions[x].Value)
    );
}

希望这会有所帮助。

Answer 3

嗯，不是最优雅的解决方案，但我认为它有效

            string exp1 = "10";
            string exp2 = "20";
            string exp3 = "exp1 + exp2 + 30";
            string exp4 = "exp5 - exp3";
            string exp5 = "exp3 / 10";         

            var dic = new Dictionary<String, String>();
            dic.Add("exp1", exp1);
            dic.Add("exp2", exp2);
            dic.Add("exp3", exp3);
            dic.Add("exp4", exp4);
            dic.Add("exp5", exp5);


            for (int i = 0; i < dic.Count; i++)          
            {
                var dicItem = dic.ElementAt(i);
                var splitted = dicItem.Value.Split(' ');
                var sb = new StringBuilder();
                foreach (var splittedItem in splitted)
                {                

                    if(dic.ContainsKey(splittedItem))
                    {
                        sb.Append(dic[splittedItem]);

                    }
                    else
                    {
                        sb.Append(splittedItem);
                    }
                    sb.Append(" ");

                }
                var parsed = sb.ToString();
                if (parsed.Contains("exp"))
                    i--; //go back and try to evaluate it again

                dic.Remove(dicItem.Key);
                dic.Add(dicItem.Key, sb.ToString());

            }

为了不使其更具可读性，您可以使用DynamicExpression

            var p = Expression.Parameter(typeof(String));
            foreach (var exp in dic.Values)
            {
                var e = System.Linq.Dynamic.DynamicExpression.ParseLambda(new[] { p }, null, exp);
                System.Diagnostics.Trace.WriteLine(e.Body);
            }

输出

10

20

((10 + 20) + 30)

((((((10 + 20) + (30 / 10)) - 10) + 20) + 30)

((10 + 20) + (30 / 10))

Answer 4

此解决方案仅替换变量：

var results = expressions.ToDictionary(x => x.Key, x => x.Value);

bool expanded;
do
{
    expanded = false;

    foreach (var key in expressions.Keys)
    {
        foreach (var kvpReplaceWith in expressions)
        {
            if (key == kvpReplaceWith.Key)
            {
                continue;
            }

            var lengthBefore = results[key].Length;
            results[key] = results[key].Replace(kvpReplaceWith.Key, "(" + kvpReplaceWith.Value + ")");
            var lengthAfter = results[key].Length;
            expanded = expanded || lengthBefore != lengthAfter;
        }

    }
}
while (expanded);