Expression表达式树 案例

最新推荐文章于 2025-06-16 09:56:00 发布
转载 最新推荐文章于 2025-06-16 09:56:00 发布 · 386 阅读 · 0

本文深入探讨了C#中表达式树的使用，包括Lambda表达式的调用与执行，以及如何通过表达式树实现EF的复杂查询与过滤。通过实际案例，展示了如何构建表达式树来执行数学运算、属性比较以及数据库查询。

https://www.cnblogs.com/zd1994/p/6678367.html

 

1，Expression.Invoke

复制代码

//运用委托或Lambda表达式
            System.Linq.Expressions.Expression<Func<int, int, bool>> largeSumTest =(num1, num2) => (num1 + num2) > 1000;
            System.Linq.Expressions.InvocationExpression invocationExpression =
                System.Linq.Expressions.Expression.Invoke(
                    largeSumTest,
                    System.Linq.Expressions.Expression.Constant(539),
                    System.Linq.Expressions.Expression.Constant(281));
            Console.WriteLine(invocationExpression.ToString());//输出：Invoke((num1, num2) => ((num1 + num2) > 1000), 539, 281)
            Console.WriteLine(Expression.Lambda<Func<bool>>(invocationExpression).Compile()());//计算委托 返回false
            Console.ReadKey();

复制代码

 

案例：

//执行1+2
var a = Expression.Add(Expression.Constant(1), Expression.Constant(2));
var lambda = Expression.Lambda<Func<int>>(a).Compile();
            Console.WriteLine(lambda());

复制代码

//执行Math.Sin()
var p = Expression.Parameter(typeof(double), "a");
//Sin(a)
var exp = Expression.Call(null, typeof(Math).GetMethod("Sin", BindingFlags.Public | BindingFlags.Static), p);
//a=>Sin(a)
var l = Expression.Lambda<Func<double,double>>(exp, p).Compile();
Console.WriteLine(l(123));

复制代码

//执行i => i委托
Expression<Func<int, int>> ex1 = i => i;
var paraemter = Expression.Parameter(typeof(int), "a");
Console.WriteLine(Expression.Lambda<Func<int, int>>(Expression.Invoke(ex1, paraemter), paraemter).Compile()(1));

复制代码

//输出：((r.Name == "张三") AndAlso Invoke(r => (r.Sex == "男"), r))
Expression<Func<Product, bool>> where = r => r.Name == "张三";
Expression<Func<Product, bool>> where2 = r => r.Sex == "男";
var invoke = Expression.Invoke(where2, where.Parameters);
Console.WriteLine(invoke);
var and = Expression.AndAlso(where.Body, invoke);
Console.WriteLine(and);

复制代码

复制代码

using LinqKit;
//ef查询
DbContext db = new DbContext(ConfigurationManager.ConnectionStrings["blogEntities"].ConnectionString);
Expression<Func<products, bool>> where = r => true;
Expression<Func<products, bool>> wherename = r => r.Name == "asd";
where = Expression.Lambda<Func<products, bool>>(Expression.AndAlso(where.Body, Expression.Invoke(wherename,where.Parameters)), where.Parameters);
var ps = db.Set<products>().AsNoTracking().AsExpandable().Where(where).AsQueryable().ToList();
foreach (var item in ps)
{
      Console.WriteLine($"id:{item.Id} qty:{item.Qty} name:{item.Name} aa:{item.AA}");
}

复制代码

//执行Lambda r => r 输出：1
Expression<Func<int, int>> exr = r => r;
var invoke = Expression.Invoke(exr, Expression.Constant(1));
var d = Expression.Lambda(invoke).Compile();
Console.WriteLine(d.DynamicInvoke());

 一、QueryFilter

复制代码

using System;
using System.Collections.Generic;
using System.Linq;
using System.Linq.Expressions;
using System.Text;
using System.Threading.Tasks;
using System.Reflection;

namespace QueryFilterComplete
{
    public class QueryFilter
    {

        /// <summary>
        /// 查询条件过滤
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="t"></param>
        /// <param name="valNames">需要过滤的字段</param>
        /// <param name="vagueNames">需要模糊查询的字段</param>
        /// <param name="isIgnoreZero">true：忽略0</param>
        /// <returns></returns>
        public static Expression<Func<T, Boolean>> Filter<T,Twhere>(Twhere t, IEnumerable<string> valNames, IEnumerable<string> vagueNames, bool isIgnoreZero = true) where T : class where Twhere:class
        {
            Expression<Func<T, Boolean>> e = r => true;
            foreach (var item in valNames)
            {
                var result = GetFilterType(item, vagueNames);
                if (result.Item1 == QFilterType.None) continue;
                PropertyInfo property = typeof(Twhere).GetProperty(item);
                var value = property.GetValue(t);
                if (!Validate(property.PropertyType, value, isIgnoreZero)) continue;

                var rE = Expression.Parameter(typeof(T), "r");
                var propertyE = Expression.Property(rE, result.Item2);
                var valueE = Expression.Constant(value);
                var lambda = Expression.Lambda<Func<T, Boolean>>(ComputeExpression(result.Item1, t, property, propertyE, valueE), rE);
                var invoke = Expression.Invoke(lambda, e.Parameters);
                e = Expression.Lambda<Func<T, Boolean>>(Expression.AndAlso(e.Body, invoke), e.Parameters);
            }
            return e;
        }
        private static bool Validate(Type t,object value, bool isIgnoreZero)
        {
            if (value == null) return false;
            if (t.IsValueType)
            {
                if (t == typeof(DateTime)) return true;
                if (t == typeof(bool)) return true;
                if (Convert.ToDouble(value) == 0 && isIgnoreZero) return false;
            }
            return true;
        }

        //获取过滤类型
        private static Tuple<QFilterType, string> GetFilterType(string valName, IEnumerable<string> vagueNames)
        {
            QFilterType type = QFilterType.None;
            string propertyName = "";
            if (string.IsNullOrEmpty(valName)) {
                return Tuple.Create(type, propertyName);
            }
            type = QFilterType.Equal;
            propertyName = valName;
            if (valName.EndsWith("_ge"))
            {
                type = QFilterType.ge;
                propertyName = valName.TrimEnd('_', 'g', 'e');
            }
            if (valName.EndsWith("_gt"))
            {
                type = QFilterType.gt;
                propertyName = valName.TrimEnd('_', 'g', 't');
            }
            if (valName.EndsWith("_le"))
            {
                type = QFilterType.le;
                propertyName = valName.TrimEnd('_', 'l', 'e');
            }
            if (valName.EndsWith("_lt"))
            {
                type = QFilterType.lt;
                propertyName = valName.TrimEnd('_', 'l', 't');
            }
            if (valName.EndsWith("_ne"))
            {
                type = QFilterType.ne;
                propertyName = valName.TrimEnd('_', 'n', 'e');
            }
            if (valName.EndsWith("_csv"))
            {
                type = QFilterType.csv;
                propertyName = valName.TrimEnd('_', 'c', 's', 'v');
            }
            if (vagueNames!=null&&vagueNames.Contains(valName))
            {
                type = QFilterType.VaguesEqual;
                propertyName = valName;
            }
            return Tuple.Create(type, propertyName);
        }
        private static Expression ComputeExpression<T>(QFilterType type,T t, PropertyInfo pInfo, Expression propertyE, Expression valueE)
        {
            if (type == QFilterType.Equal)
            {
                return Expression.Equal(propertyE, valueE);
            }
            if (type == QFilterType.VaguesEqual)
            {
                //Console.WriteLine(Expression.Call(typeof(Program), "VaguesEqual", null, p, value));
                return Expression.Call(typeof(QueryFilter), "VaguesEqual", null, propertyE, valueE);
            }
            if (type == QFilterType.ge)
            {
                return Expression.GreaterThanOrEqual(propertyE, valueE);
            }
            if (type == QFilterType.gt)
            {
                return Expression.GreaterThan(propertyE, valueE);
            }
            if (type == QFilterType.le)
            {
                return Expression.LessThanOrEqual(propertyE, valueE);
            }
            if (type == QFilterType.lt)
            {
                return Expression.LessThan(propertyE, valueE);
            }
            if (type == QFilterType.ne)
            {
                return Expression.NotEqual(propertyE, valueE);
            }
            if (type == QFilterType.csv)
            {
                if (pInfo.PropertyType.GetGenericTypeDefinition()==typeof(IEnumerable<>) || pInfo.PropertyType.IsSubclassOf(typeof(IEnumerable<>)))
                {
                    return Expression.Call(typeof(QueryFilter), "VaguesEqual", new Type[] { pInfo.PropertyType.GenericTypeArguments[0] },Expression.Constant(pInfo.GetValue(t)), propertyE);
                }
            }
            return null;
        }

        private static bool VaguesEqual<T>(IEnumerable<T> t, T value)
        {
            return t.Contains(value);
        }
        //模糊匹配
        private static bool VaguesEqual(string t, string value)
        {
            return t.Contains(value);
        }

    }
}

复制代码

下载地址v1：http://pan.baidu.com/s/1jI1I2MU

 

C# 高级编程：Expression表达式
hy_4377的博客
05-13 1214
在 C# 中，表达式是由操作数、运算符和方法调用组成的代码片段，其目的是计算出一个值。简单来说，它是一种专门用来求值的语法实体。例如：​这里的3 + 5就是一个表达式，它通过加法运算符+对两个操作数3和5进行运算，最终得到一个整数值8，并赋值给变量result。​通过实现自定义 LINQ 提供程序，可以以特定的方式解释表达式树，并将其转换为不同的查询语言，如 SQL、NoSQL 甚至 REST API。
EF Core表达式树
Anoxia_li的博客
01-23 367
表达式树(Expression Tree)：树形数据结构表示代码，以表示逻辑运算，以便可以在运行时访问逻辑运算的结构。Expression<TDelegate>类型从Lambda表达式来生成表达式树：Expression<Func<Book, bool>> e1 = b =>b.Price > 5;
Expression表达式树缓存 Expression表达式树序列化
06-15
Expression表达式树缓存 Expression表达式树序列化
表达式 Expression
09-30
用于表达式计算，如果用户自己添加界面，可以模仿微软计算器，另外，用户可进一步扩展，以支持程序中的变量-
Expression表达式树
10-25 177
表达式树表示树状数据结构的代码，树状结构中的每个节点都是一个表达式，例如一个方法调用或类似 x < y 的二元运算 1.利用 Lambda 表达式创建表达式树 Expression<Func<int, int, int, int>> expr = (x, y, z) => (x + y) / z; 2.编译表达式树，该方法将表达式树表示的...
Expression表达式树(C#)
weixin_30892987的博客
11-08 326
Lambda表达式: 1.下面举例通过Lambda表达式创建了一个用于验证Name的Func委托。 //通过Lambda表达式创建一个对象的Name属性验证委托 Func<SearchInfo, bool> func = x => x.Name.Equals("5"); /// <summary> /// 测试...
C#构造Expression表达式调用字符串Contains
网络大杂烩
04-22 2187
如果你是一个C#开发人员，学会用Expression，会对编写一些功能带来一些好处，例如我们在开发一个分页功能时，会拥有很多的查询条件，对于新手来说这些查询条件的代码他们可能会通过拼接 sql的where条件方式来处理，当你学会用表达式，这将是非常简单的一个功能。 这个贴子中的示例代码，是来源于我在基于 asp.net 实现服务器端对提交的表单数据自动进行合法性验证时提取出的代码，因为其中有一个功能就是根据表单控件添加的自定义属性进行”>”, “<“, “=”, “>=”, “<=
15、深入解析C中的表达式树与Lambda表达式
info6的博客
06-09 250
本文深入解析了C#中的表达式树与Lambda表达式的概念、工作原理及应用场景，包括如何创建简单的表达式树、使用Lambda表达式简化代码，以及两者结合实现动态查询等高级应用。同时探讨了表达式树的性能优化技巧和实际案例分析，帮助开发者更好地掌握这些工具，提升开发效率和代码质量。
7、代码即数据：C中的表达式树及其应用
最新发布
keras9composer的博客
06-16 31
本文深入探讨了C#中表达式树的概念、创建与编译方法，以及其在动态代码生成、查询优化和表达式解析中的应用。通过实例分析和代码示例，展示了如何利用表达式树将代码表示为数据，并在运行时进行分析、转换和优化，从而提升程序的灵活性、安全性和性能。适合希望深入了解C#高级编程技巧和LINQ底层机制的开发者阅读。
LINQ表达式解析案例学习
因此，本案例可能不仅展示了基本的 LINQ 查询语法，还可能涉及对表达式树的解析过程，例如如何通过 `Expression<TDelegate>` 类型捕获 lambda 表达式，并使用自定义访问器（继承自 `ExpressionVisitor`）来遍历...
C# - LINQ 表达式树
weixin_33785972的博客
10-06 808
表达式树（Expression Tree） 表达式树是不可执行的代码，它只是用于表示一种树状的数据结构，树上的每一个节点都表示为某种表达式类型，大概有25种表达式类型，它们都派生自Expression类。创建表达式树具体有两个优势： 1.对表达式树的代码进行编辑修改，使表达式树中的代码变成动态代码，根据不同的数据库修改树上的代码逻辑从而达到动态切换数据库查询语句的目的，用表达式树可以动态构建针...
[翻译]表达式树（Expression Trees）
极客神殿
10-06 412
表达式树展示的是代码的树形结构，每一个节点都是一个表达式，例如：调用一个方法或是调用一个二元运算表达式比如x < y你可以通过表达式树来编译和运行代码。这意味着能动态修改运行的代码，就好比在数据库中运行LINQ以一个变量的形式查询数据和创建一个动态的查询语句。关于表达式树在LINQ的更多使用信息详见.表达式树也被用于DLR（动态语言运行时），提供DLR与.NET Framework之间的互操作性，使编译器解析(Emit)表达式树，而不是MSIL。关于DLR更多信息详细详见.
Expressions-表达式树（Lambda）简介
代码屋
03-29 766
前言 我最早接触表达式树是在初学Linq时用于编写查数据的条件，当时由于对表达式树没有较深入的研究，所以仅仅只会用于查数据。本篇开始将会把我对于表达式树的理解和一些进阶用法分享给大家，希望能让大家更加深入的理解表达式树。 什么是表达式树 话不多说，先上代码 public class Student { public int Id { get; set; } ...
C# .Net学习笔记—— Expression 表达式目录树
weixin_46711336的博客
12-20 2205
C#学习，表达式目录树
动态构建Expression表达式树
wyf
04-01 650
动态构建Expression表达式树 话说.Net已经发展到4.5了，大家对Lambda和Linq应该比较熟悉了。比如我们要取出产品集合里面SKU以"123"开头的产品集，就可以这么写：Products=Products.Where(p=&gt;p.SKUCode.StartWith("123"));   现下有这么个需求，用户输入以逗号分隔的字符串，求取SKU以分隔的字符串开头的产品集，...
转载：Expression 表达式树学习整理
真爱无限的优快云博客
08-24 1404
http://www.cnblogs.com/li-peng/p/3154381.html
表达式（Expression）
2301_77113152的博客
08-04 438
2.运算符作为函数，操作数值作为参数，将作为运算符值的函数应用于作为操作数值的参数。表达式由运算符(Operator)和操作数(Operand)构成。该图称为表达式树，它说明了计算机在计算此嵌套表达式时发生的所有情况。运算符、括号、用逗号分隔一些操作数（也可以没有操作数）。嵌套的调用表达式：操作数也可以是调用表达式。1.先识别运算符，再对操作数子表达式求值。运算符与操作数也是表达式。数字、名称、字符串。
spring-expression表达式
懒猫的脚印
12-12 7147
Spring Expression Language（简称 SpEL）
Expression表达式资料
wumingwuxin的博客
06-24 419
Expression创建对象 http://www.cnblogs.com/coolcode/archive/2009/12/09/ExpressionCreateInstance.html Expression http://www.tuicool.com/articles/AZR3ua2 MemberInitE
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值