[转]C#通过Expression实现 字符串转表达式 自定义计算体积参数

最新推荐文章于 2023-12-05 20:50:59 发布
最新推荐文章于 2023-12-05 20:50:59 发布
阅读量302 收藏
点赞数
文章标签： c# 数据库 服务器
原文链接：https://blog.csdn.net/m0_48365841/article/details/121380411
版权

(转载请删除括号里的内容)

Expression实现 字符串转表达式 自定义计算体积参数


这篇文章是为了解决我工作中的一个需求而写，希望能帮到有需要的人

需求的这样的:
业务想让用户输入任意表达式进行计算假如成立则允许操作

表达式组成：
常量与特殊变量进行任意加减乘除有特殊值比较大小

表达式实例:

  1. L+2*W<200
  2. H>50
  3. L/W+H*20-10>=100

调用方法

ExpressionVolume expressionVolume = new ExpressionVolume();

            //计算表达式的值
            Console.WriteLine(expressionVolume.InvokeOperator("L+10+2*W/10+H+200-800/20+L+W>=200", new ExpressionVolume.VolumeClass(10, 50, 100)));
            Console.WriteLine(expressionVolume.InvokeOperator("L+10+2*W/10+H+200-800/4+L+H/W>=200", new ExpressionVolume.VolumeClass(1, 1, 1)));

            Console.WriteLine((decimal)10 + (decimal)10 + (decimal)2 * (decimal)50 / (decimal)10 + (decimal)100 + (decimal)200 - (decimal)800 / (decimal)20 + (decimal)10 + (decimal)50);
            Console.WriteLine((decimal)1 + (decimal)10 + (decimal)2 * (decimal)1 / (decimal)10 + (decimal)1 + (decimal)200 - (decimal)800 / (decimal)4 + (decimal)1 + (decimal)1 / (decimal)1);

            //比较表达式是否成立
            Console.WriteLine(expressionVolume.InvokeEqual("L+10+2*W/10+H+200-800/20+L+W<200", new ExpressionVolume.VolumeClass(10, 50, 100)));
            Console.WriteLine(expressionVolume.InvokeEqual("L+10+2*W/10+H+200-800/4+L+H/W<200", new ExpressionVolume.VolumeClass(1, 1, 1)));

            //验证表达式是否成立(!=-1表示成立)
            Console.WriteLine(expressionVolume.Verification("L+10+2*W/10+H+200-800/20+L+W<200")); 
            Console.WriteLine(expressionVolume.Verification("W+10+2*W/10+H+200-800/20+W+W<200"));
            Console.WriteLine(expressionVolume.Verification("L+2+2*-W/10+H+200-800/20+L+W<=200"));
            Console.WriteLine(expressionVolume.Verification("-L+33+2/*W/10+H+200-800/20+L+W>=200"));
            Console.WriteLine(expressionVolume.Verification("L+10-+2*W/10+H+200-800/20+L+W"));
            Console.WriteLine(expressionVolume.Verification("L++10+2*W/10+H+200-800/20+L+W"));
            expressionVolume.Verification("L+10+2*W/10+HL+200-800/20+L+W<200");

代码实现

/// <summary>
    /// 计算体积参数
    /// </summary>
    public class ExpressionVolume
    {
        #region 私有类
        /// <summary>
        /// 体积参数类
        /// </summary>
        public class VolumeClass
        {
            /// <summary>
            /// 不可以去掉
            /// Expression合成方法时需要支持无参实例化
            /// </summary>
            public VolumeClass()
            {

            }

            /// <summary>
            /// 实例化
            /// </summary>
            /// <param name="Long">长</param>
            /// <param name="Width">宽</param>
            /// <param name="Height">高</param>
            public VolumeClass(decimal? Long, decimal? Width, decimal? Height, decimal? Wt_Weight = null)
            {
                this.L = Long ?? 0;
                this.W = Width ?? 0;
                this.H = Height ?? 0;
                this.Wt_Weight = Wt_Weight ?? 0;
            }

            /// <summary>
            /// 长
            /// </summary>
            /// <remarks>
            /// 不能随意改变字段名
            /// Expression合成方法时需要
            /// </remarks>
            public decimal L { get; set; }

            /// <summary>
            /// 宽
            /// </summary>
            /// <remarks>
            /// 不能随意改变字段名
            /// Expression合成方法时需要
            /// </remarks>
            public decimal W { get; set; }

            /// <summary>
            /// 高
            /// </summary>
            /// <remarks>
            /// 不能随意改变字段名
            /// Expression合成方法时需要
            /// </remarks>
            public decimal H { get; set; }

            /// <summary>
            /// 重量
            /// </summary>
            public decimal Wt_Weight { get; set; }
        }
        #endregion

        /// <summary>
        /// 线程锁，防止缓存键值对时异常
        /// </summary>
        private readonly static object Lock = new object { };

        /// <summary>
        /// 缓存表达式(比较)
        /// </summary>
        private readonly static Dictionary<string, Func<VolumeClass, bool>> DicEqual = new Dictionary<string, Func<VolumeClass, bool>>();

        /// <summary>
        /// 比较表达式是否成立
        /// </summary>
        /// <param name="expressionString">表达式</param>
        /// <param name="volume">体积参数</param>
        /// <returns></returns>
        public bool InvokeEqual(string expressionString, VolumeClass volume)
        {
            if (DicEqual.ContainsKey(expressionString))
            {
                return DicEqual[expressionString].Invoke(volume);
            }

            var strs = expressionString.Split('>', '<');

            if (strs.Length != 2)
            {
                DicEqual.Add(expressionString, t => false);
                return false;
            }

            //定义体积参数
            ParameterExpression parameterExpression = Expression.Parameter(typeof(VolumeClass), "volume");
            Expression expression = GetExpression(strs[0], parameterExpression);

            //是否大于
            bool IsGreaterThan = expressionString.Contains('>');

            //是否允许相等
            bool IsEqual = strs[1].StartsWith("=");
            strs[1] = strs[1].TrimStart('=');

            decimal Equal = decimal.Parse(strs[1]);

            if (IsGreaterThan)
            {
                if (IsEqual)
                {
                    expression = Expression.GreaterThanOrEqual(expression, Expression.Constant(Equal, typeof(decimal)));
                }
                else
                {
                    expression = Expression.GreaterThan(expression, Expression.Constant(Equal, typeof(decimal)));
                }
            }
            else
            {
                if (IsEqual)
                {
                    expression = Expression.LessThanOrEqual(expression, Expression.Constant(Equal, typeof(decimal)));
                }
                else
                {
                    expression = Expression.LessThan(expression, Expression.Constant(Equal, typeof(decimal)));
                }
            }
            //获得Lambda表达式
            Expression<Func<VolumeClass, bool>> Lambda = Expression.Lambda<Func<VolumeClass, bool>>(expression, parameterExpression);

            //生成对应的委托
            var func = Lambda.Compile();

            //防止并发导致异常
            if (!DicEqual.ContainsKey(expressionString))
            {
                lock (Lock)
                {
                    if (!DicEqual.ContainsKey(expressionString))
                    {
                        //缓存委托
                        DicEqual.Add(expressionString, func);
                    }
                }
            }

            return func.Invoke(volume);
        }

        /// <summary>
        /// 缓存表达式(计算值)
        /// </summary>
        private readonly static Dictionary<string, Func<VolumeClass, decimal>> DicOperator = new Dictionary<string, Func<VolumeClass, decimal>>();

        /// <summary>
        /// 得到表达式左侧的值
        /// </summary>
        /// <param name="expressionString">表达式</param>
        /// <param name="volume">体积参数</param>
        /// <returns></returns>
        public decimal InvokeOperator(string expressionString, VolumeClass volume)
        {
            if (DicOperator.ContainsKey(expressionString))
            {
                return DicOperator[expressionString].Invoke(volume);
            }

            var strs = expressionString.Split('>', '<');

            if (strs.Length != 2)
            {
                DicOperator.Add(expressionString, t => -1);
                return -1;
            }

            //定义体积参数
            ParameterExpression parameterExpression = Expression.Parameter(typeof(VolumeClass), "volume");
            System.Linq.Expressions.Expression expression = GetExpression(strs[0], parameterExpression);

            //获得Lambda表达式
            Expression<Func<VolumeClass, decimal>> Lambda = Expression.Lambda<Func<VolumeClass, decimal>>(expression, parameterExpression);

            //生成对应的委托
            var func = Lambda.Compile();

            //防止并发导致异常
            if (!DicOperator.ContainsKey(expressionString))
            {
                lock (Lock)
                {
                    if (!DicOperator.ContainsKey(expressionString))
                    {
                        //缓存委托
                        DicOperator.Add(expressionString, func);
                    }
                }
            }
            return func.Invoke(volume);
        }

        /// <summary>
        /// 验证表达式
        /// </summary>
        /// <param name="expressionString">表达式</param>
        /// <returns></returns>
        public decimal Verification(string expressionString)
        {
            var strs = expressionString.Split('>', '<');

            if (strs.Length != 2)
            {
                DicOperator.Add(expressionString, t => -1);
                return -1;
            }
            if (string.IsNullOrEmpty(strs[1]))
            {
                return -1;
            }

            //定义体积参数
            ParameterExpression parameterExpression = Expression.Parameter(typeof(VolumeClass), "volume");
            System.Linq.Expressions.Expression expression = GetExpression(strs[0], parameterExpression);

            //获得Lambda表达式
            Expression<Func<VolumeClass, decimal>> Lambda = Expression.Lambda<Func<VolumeClass, decimal>>(expression, parameterExpression);

            //生成对应的委托
            var func = Lambda.Compile();

            return func.Invoke(new VolumeClass(1, 1, 1));
        }

        #region 私有方法
        /// <summary>
        /// 生成公共表达式
        /// </summary>
        /// <param name="str"></param>
        /// <param name="parameterExpression">定义体积参数</param>
        /// <returns></returns>
        private System.Linq.Expressions.Expression GetExpression(string str, ParameterExpression parameterExpression)
        {
            if (str.StartsWith("+") || str.StartsWith("-") || str.StartsWith("*") || str.StartsWith("/"))
            {
                throw new Exception("表达式不能已符号开头");
            }
            Expression expression = null;
            foreach (var Add in str.Split('+'))
            {
                if (Add.Contains('-'))
                {
                    //假如是第一次进入则表示还是+
                    bool IsFirst = true;
                    foreach (var Subtract in Add.Split('-'))
                    {
                        Expression _expression = null;
                        if (Subtract.Contains('*'))
                        {
                            _expression = MultiplyAction(Subtract, parameterExpression);
                        }
                        else if (Subtract.Contains('/'))
                        {
                            _expression = DivideAction(Subtract, parameterExpression);
                        }
                        else
                        {
                            _expression = GetPropertyOrConstant(Subtract, parameterExpression);
                        }
                        if (IsFirst)
                        {
                            expression = expression == null ? _expression : Expression.Add(expression, _expression);
                        }
                        else
                        {
                            //不是第一次进入不可能是null
                            expression = Expression.Subtract(expression, _expression);
                        }
                        IsFirst = false;
                    }
                }
                else if (Add.Contains('*'))
                {
                    Expression _expression = MultiplyAction(Add, parameterExpression);
                    expression = expression == null ? _expression : Expression.Add(expression, _expression);
                }
                else if (Add.Contains('/'))
                {
                    Expression _expression = DivideAction(Add, parameterExpression);
                    expression = expression == null ? _expression : Expression.Add(expression, _expression);
                }
                else
                {
                    //拼接+
                    Expression _expression = GetPropertyOrConstant(Add, parameterExpression);
                    expression = expression == null ? _expression : Expression.Add(expression, _expression);
                }
            }

            return expression;
        }

        /// <summary>
        /// 乘
        /// </summary>
        /// <param name="str"></param>
        private System.Linq.Expressions.Expression MultiplyAction(string str, ParameterExpression parameterExpression)
        {
            List<Expression> list = new List<Expression>();
            foreach (var Multiply in str.Split('*'))
            {
                list.Add(Multiply.Contains('/') ? DivideAction(Multiply, parameterExpression) : GetPropertyOrConstant(Multiply, parameterExpression));
            }
            Expression MultiplyExpression = list[0];
            for (int i = 1; i < list.Count; i++)
            {
                MultiplyExpression = Expression.Multiply(MultiplyExpression, list[i]);
            }
            return MultiplyExpression;
        }

        /// <summary>
        /// 除
        /// </summary>
        /// <param name="str"></param>
        private System.Linq.Expressions.Expression DivideAction(string str, ParameterExpression parameterExpression)
        {
            string[] strs = str.Split('/');
            return Expression.Divide(GetPropertyOrConstant(strs[0], parameterExpression), GetPropertyOrConstant(strs[1], parameterExpression));
        }

        /// <summary>
        /// 获取属性或常量
        /// </summary>
        /// <param name="value">字符串</param>
        /// <param name="parameterExpression">变量参数</param>
        /// <returns></returns>
        private System.Linq.Expressions.Expression GetPropertyOrConstant(string value, ParameterExpression parameterExpression)
        {
            if (string.IsNullOrEmpty(value))
            {
                throw new Exception("符号不能相连");
            }
            Expression expression = null;
            if (value == "L" || value == "W" || value == "H")
            {
                //读取变量的属性
                expression = Expression.Property(parameterExpression, value);
            }
            else
            {
                try
                {
                    expression = Expression.Constant(decimal.Parse(value), typeof(decimal));
                }
                catch (Exception)
                {
                    throw new Exception("长宽高不能相连");
                }
            }
            return expression;
        }
        #endregion
    }

实体类赋值(与本文章无关内容放到这边方便复制)

/// <summary>
   /// 不支持DataRow  泛型缓存
   /// </summary>
   /// <typeparam name="Tout">返回类型</typeparam>
   /// <typeparam name="Tin">接受类型</typeparam>
   public class ModelCopy<Tin, Tout>
   {
       private static Func<Tin, Tout> func { get; set; }//静态缓存字段

       /// <summary>
       /// 赋值
       /// </summary>
       /// <param name="model"></param>
       /// <returns></returns>
       public static Tout Invoke(Tin model)//公共方法，返回Map到的对象实例
       {
           #region 为Func赋值
           if (func == null)
           {
               Type inType = typeof(Tin);
               Type outType = typeof(Tout);

               ParameterExpression parameterExpression = Expression.Parameter(inType, "tIn");//准备一个参数表达式
               List<MemberBinding> memberBindings = new List<MemberBinding>();//准备属性绑定的集合
               foreach (var item in outType.GetProperties())//遍历所有的属性
               {
                   PropertyInfo propertyInfo = inType.GetProperty(item.Name);//获取到传入实例中的属性
                   if (propertyInfo == null)
                       continue;
                   MemberExpression memberExpression = Expression.Property(parameterExpression, propertyInfo);//准备一个成员的表达式
                   MemberBinding memberBinding = Expression.Bind(item, memberExpression);//绑定
                   memberBindings.Add(memberBinding);//添加到列表
               }

               //字段
               //foreach (var item in outType.GetFields())
               //{
               //    FieldInfo fieldInfo = inType.GetField(item.Name);
               //    if (fieldInfo == null)
               //        continue;
               //    MemberExpression memberExpression = Expression.Field(parameterExpression, fieldInfo);
               //    MemberBinding memberBinding = Expression.Bind(item, memberExpression);
               //    memberBindings.Add(memberBinding);
               //}

               MemberInitExpression memberInitExpression = Expression.MemberInit(Expression.New(outType), memberBindings.ToArray());
               Expression<Func<Tin, Tout>> lambdaExpression = Expression.Lambda<Func<Tin, Tout>>(memberInitExpression, new ParameterExpression[] { parameterExpression });
               func = lambdaExpression.Compile();//表达式编译为委托
           }
           #endregion

           return func.Invoke(model);
       }
   }


---------------------
作者：樱桃丶老丸子
来源：CSDN
原文：https://blog.csdn.net/m0_48365841/article/details/121380411
版权声明：本文为作者原创文章，转载请附上博文链接！
 

SkyLee708
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
C#动态执行字符串，可以将字符串作为表达式执行
08-17
可以动态解析并执行字符串 参见http://blog.csdn.net/hsrzq/archive/2009/08/17/4456361.aspx 别忘了引用EvalGuy命名空间！
C#通过Expression实现 字符串转表达式 自定义计算体积参数
m0_48365841的博客
11-17 2014
Expression实现 字符串转表达式 自定义计算体积参数 调用方法 ExpressionVolume expressionVolume = new ExpressionVolume(); //计算表达式的值 Console.WriteLine(expressionVolume.InvokeOperator("L+10+2*W/10+H+200-800/20+L+W>=200", new ExpressionVolume.VolumeClass(10
C#实现将字符串作为表达式运算
Nemo的笔记本
04-11 3637
曾经有个需求，要把一段字符串表达式作为C#的一段语句来执行。或者直接在sql中存储上不同的含参数的工时如180+20*（n-4)。查出来之后带入参数计算。又好比在win7计算器中粘贴一个表达式，直接输出了结果。碰到这个问题，查了一下网上的资料，发现有以下几种适合我的方案：1.把表达式用字符串的各种函数拆分出来数字和小括号和运算符的组合。然后去运算（即自己写一个类和函数）2.采用T-sql脚本计算。
C#中字符串转换为计算公式（自定义公式的计算）
风林山火的专栏
07-31 3766
添加COM引用：   private void button2_Click(object sender, EventArgs e)         {             MSScriptControl.ScriptControl sc = new MSScriptControl.ScriptControlClass();             sc.Language = "Jav
C#正则表达式匹配与替换字符串功能示例
12-31
本文实例讲述了C#正则表达式匹配与替换字符串功能。分享给大家供大家参考，具体如下： 事例一：\w+=>[A-Za-z1-9_],\s+=>任何空白字符,()=>捕获  string text = @public string testMatchObj string s string match...
C#字符串和正则表达式参考手册
04-11
在C#编程语言中，字符串和正则表达式是两个非常重要的概念，广泛应用于数据处理、文本分析和验证。下面将详细阐述这两个主题的核心知识点。 一、C#字符串 1. 字符串基础：在C#中，字符串是不可变的对象，意味着...
将字符串转换为lambda表达式
06-05
总结起来，将字符串转换为`lambda`表达式是编程中的一种高级技巧，尤其在动态计算和用户交互的场合中非常有用。通过使用`ast`模块，我们可以安全地实现这个功能，避免了`eval()`和`exec()`带来的潜在风险。同时，...
C#动态执行字符串(动态创建代码)的实例代码
09-05
本篇文章将深入探讨如何在C#中实现动态执行字符串，并通过一个具体的实例代码来说明。 在C#中，我们可以利用`System.CodeDom`和`Microsoft.CSharp`命名空间中的类来实现动态代码编译和执行。主要涉及的类包括`...
C#将Lambda表达式转成Sql语句
09-21
它可能包括了一个自定义的`ExpressionVisitor`类，这个类遍历表达式树并生成SQL字符串。此外，可能还有一个`DbContext`的子类，用于处理特定的数据模型和数据库操作。 总的来说，将C#的Lambda表达式转换为SQL语句是...
把字符串转化为表达式
12-06
本例子包含Interop.MSScriptControl.dll 将一串合法的字符串，转换为数学表达式，并计算出结果。
字符串转表达式，进行加减乘除等逻辑运算
09-16
将字符串转表达式，进行加减乘除等逻辑运算，进行逻辑运算。 1.中缀转后缀。 2.后缀求值。
c# 将字符串转换为逻辑表达式（字符串转换布尔）
dazhexuan0219的博客
07-25 1602
比如：string str="6>5"; 要的效果是：bool result=6>5 方案一： 命名空间：System.Data； DataTable dt = new DataTable(); bool result= (bool)dt.Compute("","");dt.Compute(str, ""); 方案二： 动态表达式： 1 p...
C#将运算字符串直接转换成表达式且计算结果
weixin_30387663的博客
03-08 1046
DataTable dt = new DataTable(); var Result= dt.Compute("1+2*3+2", "");//将运算字符串转换成表达式运算 NumberTxt.Text = Result.ToString(); 转载于:http...
C#构造Expression表达式调用字符串Contains
网络大杂烩
04-22 1860
如果你是一个C#开发人员，学会用Expression，会对编写一些功能带来一些好处，例如我们在开发一个分页功能时，会拥有很多的查询条件，对于新手来说这些查询条件的代码他们可能会通过拼接 sql的where条件方式来处理，当你学会用表达式，这将是非常简单的一个功能。 这个贴子中的示例代码，是来源于我在基于 asp.net 实现服务器端对提交的表单数据自动进行合法性验证时提取出的代码，因为其中有一个功能就是根据表单控件添加的自定义属性进行”>”, “<“, “=”, “>=”, “<=
C# 使用表达式树复制属性值，转化为指定类型 ExpressionTree CopyProperties
weixin_30556161的博客
06-01 422
之前使用的是网上的一个表达式树版本，使用时需要显示写出参数及返回值的类型 Tin TOut, 略显麻烦 public static class TransExpV2<TIn, TOut> { private static readonly Func<TIn, TOut> Func = GetFunc(); priv...
Fluent常见问题：获取在某个范围内物理量的分布
驭风之道
12-05 1494
在单元注册器的设置界面上可设置物理量的判断条件，包括取值范围、分布百分比范围、偏离标准差的范围。上述两种方法创建的区域，其体积信息均可通过“report definitions”功能的“volume report”获得，其形状、位置、物理量分布等可利用网格、云图等模式进行展示。等值切面的面积可通过“report definitions”功能的“surface report”获得，其形状、位置、物理量分布可利用网格、云图等模式进行展示。在等值切面的设置界面，设置物理量取值范围与曲面区域。
字符串表达式计算C#程序设计
vbprog的专栏
01-10 1242
      在编程应用程序过程中，有时需要字符串表达式的值。如字符串："23+56/(102-100)*((36-24)/(8-6))"，结果=191。      根据数据结构栈的应用介绍，通过把表达式由中序式转换成后序式，再用栈来进行计算。如上述字符串表达式："23+56/(102-100)*((36-24)/(8-6))"，转换为后序时为："23|56|102|100|-|/|*|36|24|
c#正则表达式截取字符串
最新发布
06-14
在C#中，正则表达式（Regular Expression）是一种强大的文本处理工具，用于在字符串中进行模式匹配、搜索和替换操作。如果你想截取字符串中的特定部分，可以使用`Regex`类提供的方法。下面是一个基本的例子，展示...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值