Expression<Func<T>>和Func<T>

👈🏻 Select language

以前用EF的时候,由于where的时候有Expression<Func>和Func两种查询条件,误用了Func那个重载,后来还想通过func创建查询来着,不过失败了,导致了全表查询,真是无语.国内的人答的比较言简意赅(其实我觉得讲的不好).还是老外讲的明白点.

翻译过来吧,就是说Func是方法的委托,而Expression<Func>是拉姆达表达式树.这个树状结构描述了各种各样恶心的参数(如下图所示).我们可以用Expression.Compile做成一个委托或者编译成sql(EF).

Expression<Func<int>> myExpression = () => 10;

其实吧, 多用一下你就知道了.Func用的还蛮多的,当时就是用来运行泛化的方法的,而Expression<Func>用在动态查询拼接的时候比较多,比如 (And和or,拼接多条表达式树).

public static class PredicateBuilder
{
    public static Expression<Func<T, bool>> And<T>(this Expression<Func<T, bool>> first, Expression<Func<T, bool>> second)
    {
        return first.Compose<T>(second, new Func<Expression, Expression, Expression>(Expression.And));
    }

    private static Expression<Func<T, bool>> Compose<T>(this Expression<Func<T, bool>> first, Expression<Func<T, bool>> second, Func<Expression, Expression, Expression> merge)
    {
        Expression expression = new ParameterRebinder(second.Parameters[0], first.Parameters[0]).Visit(second.Body);
        return Expression.Lambda<Func<T, bool>>(merge(first.Body, expression), first.Parameters);
    }

    public static Expression<Func<T, bool>> False<T>()
    {
        return item => false;
    }

    public static Expression<Func<T, bool>> Not<T>(this Expression<Func<T, bool>> predicate)
    {
        return Expression.Lambda<Func<T, bool>>(Expression.Not(predicate.Body), predicate.Parameters);
    }

    public static Expression<Func<T, bool>> Or<T>(this Expression<Func<T, bool>> first, Expression<Func<T, bool>> second)
    {
        return first.Compose<T>(second, new Func<Expression, Expression, Expression>(Expression.Or));
    }

    public static Expression<Func<T, bool>> True<T>()
    {
        return item => true;
    }

    private sealed class ParameterRebinder : ExpressionVisitor
    {
        private readonly ParameterExpression m_From;
        private readonly ParameterExpression m_To;

        public ParameterRebinder(ParameterExpression from, ParameterExpression to)
        {
            this.m_From = from;
            this.m_To = to;
        }

        protected override Expression VisitParameter(ParameterExpression node)
        {
            if (node == this.m_From)
            {
                node = this.m_To;
            }
            return base.VisitParameter(node);
        }
    }
}

表达式树恶心的地方,我写一个orderby给你看看.

public static IQueryable<TEntity> OrderBy<TEntity>(this IQueryable<TEntity> source, string orderByProperty, bool desc)
{
    string command = desc ? "OrderByDescending" : "OrderBy";
    var type = typeof(TEntity);//实体的类型
    var property = type.GetProperty(orderByProperty);
    var parameter = Expression.Parameter(type, "o");
    var propertyAccess = Expression.MakeMemberAccess(parameter, property);
    var orderByExpression = Expression.Lambda(propertyAccess, parameter);
    var resultExpression = Expression.Call(typeof(Queryable), command, new Type[] { type, property.PropertyType },
                                  source.Expression, Expression.Quote(orderByExpression));
    return source.Provider.CreateQuery<TEntity>(resultExpression);
}

动态linq是需要反射的.而且这种写法不利于调试.因为你特么完全不知道生成的什么鬼,除非你对这玩意真的很熟.好吧,你赢了.

参考链接:

[Why would you use Expression<Func> rather than Func?](https://stackoverflow.com/questions/793571/why-would-you-use-expressionfunct-rather-than-funct)
Entity Framework - Func引起的数据库全表查询
通过已有Func构造Expression表达式问题

When I was using EF (Entity Framework), there were two types of query conditions for where: Expression<Func> and Func. I mistakenly used the Func overload, and later tried to create queries through func, but it failed, resulting in a full table query. It was really frustrating. People in China answered quite concisely (I actually think they didn't explain it well). Foreigners explained it more clearly.

To translate: Func is a method delegate, while Expression<Func> is a lambda expression tree. This tree structure describes various parameters (as shown in the figure below). We can use Expression.Compile to create a delegate or compile it into SQL (EF).

Expression<Func<int>> myExpression = () => 10;

Actually, you’ll understand once you use it more. Func is used quite a lot, mainly for running generalized methods, while Expression<Func> is used more for dynamic query concatenation, such as (And and Or, concatenating multiple expression trees).

public static class PredicateBuilder
{
    public static Expression<Func<T, bool>> And<T>(this Expression<Func<T, bool>> first, Expression<Func<T, bool>> second)
    {
        return first.Compose<T>(second, new Func<Expression, Expression, Expression>(Expression.And));
    }

    private static Expression<Func<T, bool>> Compose<T>(this Expression<Func<T, bool>> first, Expression<Func<T, bool>> second, Func<Expression, Expression, Expression> merge)
    {
        Expression expression = new ParameterRebinder(second.Parameters[0], first.Parameters[0]).Visit(second.Body);
        return Expression.Lambda<Func<T, bool>>(merge(first.Body, expression), first.Parameters);
    }

    public static Expression<Func<T, bool>> False<T>()
    {
        return item => false;
    }

    public static Expression<Func<T, bool>> Not<T>(this Expression<Func<T, bool>> predicate)
    {
        return Expression.Lambda<Func<T, bool>>(Expression.Not(predicate.Body), predicate.Parameters);
    }

    public static Expression<Func<T, bool>> Or<T>(this Expression<Func<T, bool>> first, Expression<Func<T, bool>> second)
    {
        return first.Compose<T>(second, new Func<Expression, Expression, Expression>(Expression.Or));
    }

    public static Expression<Func<T, bool>> True<T>()
    {
        return item => true;
    }

    private sealed class ParameterRebinder : ExpressionVisitor
    {
        private readonly ParameterExpression m_From;
        private readonly ParameterExpression m_To;

        public ParameterRebinder(ParameterExpression from, ParameterExpression to)
        {
            this.m_From = from;
            this.m_To = to;
        }

        protected override Expression VisitParameter(ParameterExpression node)
        {
            if (node == this.m_From)
            {
                node = this.m_To;
            }
            return base.VisitParameter(node);
        }
    }
}

The annoying part about expression trees, let me show you an orderby example:

public static IQueryable<TEntity> OrderBy<TEntity>(this IQueryable<TEntity> source, string orderByProperty, bool desc)
{
    string command = desc ? "OrderByDescending" : "OrderBy";
    var type = typeof(TEntity);//Entity type
    var property = type.GetProperty(orderByProperty);
    var parameter = Expression.Parameter(type, "o");
    var propertyAccess = Expression.MakeMemberAccess(parameter, property);
    var orderByExpression = Expression.Lambda(propertyAccess, parameter);
    var resultExpression = Expression.Call(typeof(Queryable), command, new Type[] { type, property.PropertyType },
                                  source.Expression, Expression.Quote(orderByExpression));
    return source.Provider.CreateQuery<TEntity>(resultExpression);
}

Dynamic LINQ requires reflection. And this writing style is not conducive to debugging. Because you have no idea what the hell is being generated, unless you’re really familiar with this stuff. Well, you win.

Reference Links:

[Why would you use Expression<Func> rather than Func?](https://stackoverflow.com/questions/793571/why-would-you-use-expressionfunct-rather-than-funct)
Entity Framework - Func引起的数据库全表查询
通过已有Func构造Expression表达式问题

以前EFを使っていた時、whereにはExpression<Func>とFuncの2種類のクエリ条件がありました。Funcのオーバーロードを誤って使用し、後でfuncを通じてクエリを作成しようとしましたが、失敗し、全テーブルクエリが発生しました。本当に困りました。国内の人は簡潔に答えてくれましたが（実は説明が良くないと思います）、外国人はもっと明確に説明してくれました。

翻訳すると、Funcはメソッドのデリゲートであり、Expression<Func>はラムダ式ツリーです。このツリー構造は様々なパラメータを記述します（下図参照）。Expression.Compileを使用してデリゲートを作成するか、SQL（EF）にコンパイルできます。

Expression<Func<int>> myExpression = () => 10;

実際、もっと使えば分かります。Funcはかなり使われており、主に汎用メソッドを実行するために使用されますが、Expression<Func>は動的クエリの連結（AndとOr、複数の式ツリーの連結など）でより多く使用されます。

public static class PredicateBuilder
{
    public static Expression<Func<T, bool>> And<T>(this Expression<Func<T, bool>> first, Expression<Func<T, bool>> second)
    {
        return first.Compose<T>(second, new Func<Expression, Expression, Expression>(Expression.And));
    }

    private static Expression<Func<T, bool>> Compose<T>(this Expression<Func<T, bool>> first, Expression<Func<T, bool>> second, Func<Expression, Expression, Expression> merge)
    {
        Expression expression = new ParameterRebinder(second.Parameters[0], first.Parameters[0]).Visit(second.Body);
        return Expression.Lambda<Func<T, bool>>(merge(first.Body, expression), first.Parameters);
    }

    public static Expression<Func<T, bool>> False<T>()
    {
        return item => false;
    }

    public static Expression<Func<T, bool>> Not<T>(this Expression<Func<T, bool>> predicate)
    {
        return Expression.Lambda<Func<T, bool>>(Expression.Not(predicate.Body), predicate.Parameters);
    }

    public static Expression<Func<T, bool>> Or<T>(this Expression<Func<T, bool>> first, Expression<Func<T, bool>> second)
    {
        return first.Compose<T>(second, new Func<Expression, Expression, Expression>(Expression.Or));
    }

    public static Expression<Func<T, bool>> True<T>()
    {
        return item => true;
    }

    private sealed class ParameterRebinder : ExpressionVisitor
    {
        private readonly ParameterExpression m_From;
        private readonly ParameterExpression m_To;

        public ParameterRebinder(ParameterExpression from, ParameterExpression to)
        {
            this.m_From = from;
            this.m_To = to;
        }

        protected override Expression VisitParameter(ParameterExpression node)
        {
            if (node == this.m_From)
            {
                node = this.m_To;
            }
            return base.VisitParameter(node);
        }
    }
}

式ツリーの厄介な部分、orderbyの例を見せます：

public static IQueryable<TEntity> OrderBy<TEntity>(this IQueryable<TEntity> source, string orderByProperty, bool desc)
{
    string command = desc ? "OrderByDescending" : "OrderBy";
    var type = typeof(TEntity);//エンティティの型
    var property = type.GetProperty(orderByProperty);
    var parameter = Expression.Parameter(type, "o");
    var propertyAccess = Expression.MakeMemberAccess(parameter, property);
    var orderByExpression = Expression.Lambda(propertyAccess, parameter);
    var resultExpression = Expression.Call(typeof(Queryable), command, new Type[] { type, property.PropertyType },
                                  source.Expression, Expression.Quote(orderByExpression));
    return source.Provider.CreateQuery<TEntity>(resultExpression);
}

動的LINQにはリフレクションが必要です。そして、この書き方はデバッグに適していません。生成されるものが何なのか全く分からないからです。このことに本当に精通していない限り。まあ、あなたの勝ちです。

参考リンク:

[Why would you use Expression<Func> rather than Func?](https://stackoverflow.com/questions/793571/why-would-you-use-expressionfunct-rather-than-funct)
Entity Framework - Func引起的数据库全表查询
通过已有Func构造Expression表达式问题

Когда я использовал EF (Entity Framework), для where было два типа условий запроса: Expression<Func> и Func. Я ошибочно использовал перегрузку Func, а затем попытался создать запросы через func, но это не удалось, что привело к полному запросу таблицы. Это было действительно неприятно. Люди в Китае отвечали довольно кратко (на самом деле я думаю, что они объяснили это не очень хорошо). Иностранцы объяснили это более ясно.

Переводя: Func - это делегат метода, а Expression<Func> - это дерево лямбда-выражений. Эта древовидная структура описывает различные параметры (как показано на рисунке ниже). Мы можем использовать Expression.Compile для создания делегата или компиляции его в SQL (EF).

Expression<Func<int>> myExpression = () => 10;

На самом деле, вы поймете, как только будете использовать это больше. Func используется довольно часто, в основном для запуска обобщенных методов, в то время как Expression<Func> используется больше для динамической конкатенации запросов, например (And и Or, конкатенация нескольких деревьев выражений).

public static class PredicateBuilder
{
    public static Expression<Func<T, bool>> And<T>(this Expression<Func<T, bool>> first, Expression<Func<T, bool>> second)
    {
        return first.Compose<T>(second, new Func<Expression, Expression, Expression>(Expression.And));
    }

    private static Expression<Func<T, bool>> Compose<T>(this Expression<Func<T, bool>> first, Expression<Func<T, bool>> second, Func<Expression, Expression, Expression> merge)
    {
        Expression expression = new ParameterRebinder(second.Parameters[0], first.Parameters[0]).Visit(second.Body);
        return Expression.Lambda<Func<T, bool>>(merge(first.Body, expression), first.Parameters);
    }

    public static Expression<Func<T, bool>> False<T>()
    {
        return item => false;
    }

    public static Expression<Func<T, bool>> Not<T>(this Expression<Func<T, bool>> predicate)
    {
        return Expression.Lambda<Func<T, bool>>(Expression.Not(predicate.Body), predicate.Parameters);
    }

    public static Expression<Func<T, bool>> Or<T>(this Expression<Func<T, bool>> first, Expression<Func<T, bool>> second)
    {
        return first.Compose<T>(second, new Func<Expression, Expression, Expression>(Expression.Or));
    }

    public static Expression<Func<T, bool>> True<T>()
    {
        return item => true;
    }

    private sealed class ParameterRebinder : ExpressionVisitor
    {
        private readonly ParameterExpression m_From;
        private readonly ParameterExpression m_To;

        public ParameterRebinder(ParameterExpression from, ParameterExpression to)
        {
            this.m_From = from;
            this.m_To = to;
        }

        protected override Expression VisitParameter(ParameterExpression node)
        {
            if (node == this.m_From)
            {
                node = this.m_To;
            }
            return base.VisitParameter(node);
        }
    }
}

Раздражающая часть деревьев выражений, позвольте показать вам пример orderby:

public static IQueryable<TEntity> OrderBy<TEntity>(this IQueryable<TEntity> source, string orderByProperty, bool desc)
{
    string command = desc ? "OrderByDescending" : "OrderBy";
    var type = typeof(TEntity);//Тип сущности
    var property = type.GetProperty(orderByProperty);
    var parameter = Expression.Parameter(type, "o");
    var propertyAccess = Expression.MakeMemberAccess(parameter, property);
    var orderByExpression = Expression.Lambda(propertyAccess, parameter);
    var resultExpression = Expression.Call(typeof(Queryable), command, new Type[] { type, property.PropertyType },
                                  source.Expression, Expression.Quote(orderByExpression));
    return source.Provider.CreateQuery<TEntity>(resultExpression);
}

Динамический LINQ требует рефлексии. И этот стиль написания не способствует отладке. Потому что вы понятия не имеете, что черт возьми генерируется, если только вы не очень хорошо знакомы с этим. Ну, вы выиграли.

Ссылки:

[Why would you use Expression<Func> rather than Func?](https://stackoverflow.com/questions/793571/why-would-you-use-expressionfunct-rather-than-funct)
Entity Framework - Func引起的数据库全表查询
通过已有Func构造Expression表达式问题

Expression>和Func

Expression> vs Func

参考链接:

Reference Links:

参考リンク:

Ссылки:

CATALOG

FEATURED TAGS

FRIENDS