Question

我想将方法调用和公式的组合作为文本或脚本存储到数据库中。例如，我想在Database中将这样的东西存储为字符串，并在代码中的某处执行：

if(Vessel.Weight>200) 
{
    return Cargo.Weight*Cargo.Tariff*2
} 
else 
{
    Cargo.Weight*Cargo.Tariff
}

调用：

var cost = executeFormula("CalculateTariff",new {Cargo= GetCargo(), Vessel=GetVessel()});

因为这些规则会经常更改，我不想部署dll（CLR解决方案），我也不想将这些规则存储为SP并将业务规则与DAL混合。

任何想法或工具？

Answer 1

如果通过更改，将所有值放在哈希表或字典中。使用_（Vessel.Weight将变为“Vessel_Weight”）并将语法简化为一行，将更容易创建解决方案。此规则可以编写为：

result=(Vessel_Weight>200)
    ?(Cargo_Weight*Cargo_Tariff*2)
    :(Cargo_Weight*Cargo_Tariff)

如上所述定义规则，您可以使用以下（草稿，非最佳......）代码作为正确编码功能的指南，以完成工作。我再说一遍，下面的代码并不完美，但是作为一个概念证据，它的底线就足够了。

Dictionary<string, dynamic> compute = new Dictionary<string, dynamic>();
compute.Add("Vessel_Weight", 123);
compute.Add("Cargo_Weight", 24);
compute.Add("Cargo_Tariff", 9);

    string rule = "result=(Vessel_Weight>200)
        ?(Cargo_Weight*Cargo_Tariff*2)
        :(Cargo_Weight*Cargo_Tariff)";

    string process = rule.Replace(" ", "");
    foreach (Match level1 in Regex.Matches(process, "\\([^\\)]+\\)"))
    {
        string parenthesis = level1.Value;
        string keepit = parenthesis;
        Console.Write("{0} -> ", parenthesis);
        // replace all named variable with values from the dictionary
        foreach (Match level2 in Regex.Matches(parenthesis, "[a-zA-z0-9_]+"))
        {
            string variable = level2.Value;
            if (Regex.IsMatch(variable, "[a-zA-z_]+"))
            {
                if (!compute.ContainsKey(variable))
                    throw new Exception("Variable not found");
                parenthesis = parenthesis.Replace(variable, compute[variable].ToString());
            }
        }
        parenthesis = parenthesis.Replace("(", "").Replace(")", "");
        Console.Write("{0} -> ", parenthesis);
        // do the math
        List<double> d = new List<double>();
        foreach (Match level3 in Regex.Matches(parenthesis, "[0-9]+(\\.[0-9]+)?"))
        {
            d.Add(double.Parse(level3.Value));
            parenthesis = Regex.Replace(parenthesis, level3.Value, "");
        }
        double start = d[0];
        for (var i = 1; i < d.Count; i++)
        {
            switch (parenthesis[i - 1])
            {
                case '+':
                    start += d[i];
                    break;
                case '-':
                    start -= d[i];
                    break;
                case '*':
                    start *= d[i];
                    break;
                case '/':
                    start /= d[i];
                    break;
                case '=':
                    start = (start == d[i]) ? 0 : 1;
                    break;
                case '>':
                    start = (start > d[i]) ? 0 : 1;
                    break;
                case '<':
                    start = (start < d[i]) ? 0 : 1;
                    break;
            }
        }
        parenthesis = start.ToString();
        Console.WriteLine(parenthesis);
        rule = rule.Replace(keepit, parenthesis);
    }
    Console.WriteLine(rule);
    // peek a value in case of a condition
    string condition = "[0-9]+(\\.[0-9]+)?\\?[0-9]+(\\.[0-9]+)?:[0-9]+(\\.[0-9]+)?";
    if (Regex.IsMatch(rule, condition))
    {
        MatchCollection m = Regex.Matches(rule, "[0-9]+(\\.[0-9]+)?");
        int check = int.Parse(m[0].Value) + 1;
        rule = rule.Replace(Regex.Match(rule, condition).Value, m[check].Value);
    }
    Console.WriteLine(rule);
    // final touch
    int equal = rule.IndexOf("=");
    compute.Add(rule.Substring(0, equal - 1), double.Parse(rule.Substring(equal + 1)));

现在结果是字典中的命名项。这样，您可以在中间结果的意义上处理更多规则，并根据它们制定最终规则。编写的代码并不能保证算术运算的正确执行顺序，但是如果你保持规则简单（如果需要你可以将它们分开），你的目标就会实现。

将文本或脚本分配到C＃代码中

1 个答案: