表达式目录树Expression

委托

// 定义两个输入参数，一个输出参数
 Func<int, int, int> func = (m, n) => (m + n);
 Console.WriteLine(func.Invoke(3,5));

 

调用表达式目录树

 Expression<Func<int, int>> addFive = (num)=> num + 5;
            if(addFive.NodeType == ExpressionType.Lambda)
            {
                var lambdaExp = (LambdaExpression)addFive;
                var parameter = lambdaExp.Parameters.First();
                Console.WriteLine(parameter.Type);
                Console.WriteLine(parameter.Name);
            }
            Console.WriteLine(addFive.Compile().Invoke(5));

 

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

namespace ExpressionDemo
{
    class People
    {
        public int Id { get; set; }
        public string Name { get; set; }
        public int Age { get; set; }
    }
    class Program
    {
        static void Main(string[] args)
        {
            Expression<Func<People, bool>> lambda = x => x.Id.ToString().Equals("5");
            var iResult = lambda.Compile().Invoke(new People
            {
                Id = 5,
                Age = 10,
                Name = "我"
            }) ;
            Console.WriteLine(iResult.ToString());
        }
 
    }
}

　　

手动拼装表达式目录树

var one = Expression.Constant(1, typeof(int));
var two = Expression.Constant(2,typeof(int));
BinaryExpression addtion = Expression.Add(one, two);
Expression<Func<int>> expression = Expression.Lambda<Func<int>>(addtion,new ParameterExpression[] { });
Console.WriteLine(expression.Compile().Invoke());

 

            //Expression<Func<int, int, int>> expression = (m, n) => m * n + m + n + 10;
            //int iResult = expression.Compile().Invoke(10,20);

            // 拼接方式
            ParameterExpression m = Expression.Parameter(typeof(int), "m");
            ParameterExpression n = Expression.Parameter(typeof(int),"n");
            var mutiply = Expression.Multiply(m,n);
            var constant = Expression.Constant(2);
            var plus1 = Expression.Add(mutiply, m);
            var plus2 = Expression.Add(plus1,n);
            var plus3 = Expression.Add(plus2, constant);
            Expression<Func<int, int, int>> expression = Expression.Lambda<Func<int, int, int>>(plus3,new ParameterExpression[] { m, n });
            int iResult = expression.Compile().Invoke(10,20);
            Console.WriteLine(iResult);

 

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

namespace ExpressionDemo
{
    class People
    {
        public int Id;
        public string Name { get; set; }
        public int Age { get; set; }
    }
    class Program
    {
        static void Main(string[] args)
        {
            ParameterExpression parameterExpression = Expression.Parameter(typeof(People),"x");
            Expression field = Expression.Field(parameterExpression,typeof(People).GetField("Id"));
            MethodCallExpression toString = Expression.Call(field,typeof(People).GetMethod("ToString"));
            ConstantExpression constantExpression = Expression.Constant("5",typeof(string));
            MethodCallExpression equals = Expression.Call(toString, typeof(People).GetMethod("Equals"), new Expression[] { constantExpression });
            Expression<Func<People, bool>> lambda = Expression.Lambda<Func<People, bool> >(equals, new ParameterExpression[] {
                parameterExpression
             });
            var iResult = lambda.Compile().Invoke(new People()
            {
                Id = 5,
                Name = "",
                Age = 10
            }) ;
            Console.WriteLine(iResult.ToString());
        }
 
    }
}