ExpressionTree 的函数或谓词

Question

可以说我有：

 Func<Customer,bool > a = (c) => c.fullName == "John";

现在我想转换为表达式树，有什么方法可以做到这一点？

我知道我可以从一开始就将它定义为表达式树，但我的情况有所不同，因为我必须首先连接一些 lambda 表达式，然后将其传递给采用表达式树的方法，这样做会导致编译时错误！

示例：

        Func<Customer, bool> a = (c) => c.fullName == "John";
        Func<Customer, bool> b = (c) => c.LastName == "Smith";
        Func<Customer, bool> final = c => a(c) && b(c); 

现在我想将 Final 传递给一个方法，该

ExpressionTree<Func<Customer,bool >>

方法会给出编译时错误，

提前致谢

Answer 1

你不能那样做。 Func<...> 类型的变量是一个委托，它基本上就像一个指向包含编译代码的内存位置的指针> 为 lambda 表达式。 .NET 中没有将已编译的代码转回表达式树的功能。

根据您尝试执行的操作，也许您可​​以应对不完整的解决方案：创建一个调用委托的表达式树。由于我对您想要将表达式树传递到的方法一无所知，因此我不知道这对您来说是否是一个可行的解决方案。

摘要：如果您想要所有表达式的完整表达式树，则需要确保它们从一开始就是表达式树。一旦将其编译为委托，表达式树就会丢失。

一旦您确定它们是表达式树，您就可以使用如下所示的方式组合它们：

Expression<Func<Customer, bool>> a = c => c.FullName == "John";
Expression<Func<Customer, bool>> b = c => c.LastName == "Smith";

var cp = Expression.Parameter(typeof(Customer), "c");

var ai = Expression.Invoke(a, cp);
var bi = Expression.Invoke(b, cp);

var final = Expression.Lambda<Func<Customer, bool>>(
    Expression.AndAlso(ai, bi), cp);

当然，这使用 AndAlso 运算符 (&&) ;您还可以使用 OrElse 来表示 || 等。

Answer 2

您可以从表达式转到函数，但反之则不行。

你可以这样做：

Expression<Func<Customer, bool>> exprA = (c) => c.fullName == "John";
Func<Customer, bool> funcA = exprA.Compile();

但没有办法走其他路。

Answer 3

关于您修改后的问题，我认为这会起作用：

Expression<Func<Customer, bool>> a = (c) => c.FullName == "John";
Expression<Func<Customer, bool>> b = (c) => c.LastName == "Smith";

var cp = Expression.Parameter(typeof(Customer), "c");

var ai = Expression.Invoke(a, cp);
var bi = Expression.Invoke(b, cp);

var final = Expression.Lambda<Func<Customer, bool>>(Expression.And(ai, bi), cp);

Answer 4

这是我认为适合您的解决方案。我将 Func 转换为 Expression>。

它基于 这篇文章 ElegantCode

在这个例子中我使用了一个 Func：

using System;
using System.Linq;
using System.Linq.Expressions;
using System.Reflection;

namespace ConsoleApplication1
{
    class Program
    {
        public static bool Method(Expression<Func<int, bool>> predicate, int value)
        {
            return predicate.Compile()(value);
        }

        static void Main(string[] args)
        {
            Func<int, bool> testPredicate = n => n == 1;
            var output = ConvertFuncToExpression(testPredicate);
            Console.WriteLine(Method(output, 3));
            Console.WriteLine(Method(output, 1));
        }

        private static Expression<TDelegate> CreateExpression<TDelegate>(MethodBase method)
        {
            var delegateArguments = typeof(TDelegate).GetMethod("Invoke").GetParameters().Select((parameter, index) => Expression.Parameter(parameter.ParameterType, "param_" + index)).ToArray();
            if (delegateArguments.Count() != method.GetParameters().Count()) throw new InvalidOperationException("The number of parameters of the requested delegate does not match the number parameters of the specified method.");

            var argumentsTypes = method.GetGenericArguments();
            argumentsTypes = (argumentsTypes.Length > 0) ? argumentsTypes : null;
            var convertedArguments = method.GetParameters().Select((parameter, index) => Expression.Convert(delegateArguments[index], parameter.ParameterType)).ToArray();
            var call = Expression.Call(method.DeclaringType, method.Name, argumentsTypes, convertedArguments);

            var lambda = Expression.Lambda<TDelegate>(call, delegateArguments);
            return lambda;
        }

        private static Expression<Func<TIn1, TOut>> ConvertFuncToExpression<TIn1, TOut>(Func<TIn1, TOut> input)
        {
            MethodInfo method = input.Method;
            return CreateExpression<Func<TIn1, TOut>>(method);
        }
    }
}