{
     //  
     //  定义Expression
     //  @return  int
     //  @params  int(a),int(b)
     //
     Expression<Func<int, int, int>> expression = (a, b) => a + b;
     //编译创建委托
     Func<int, int, int> func = expression.Compile();
     //入参执行
     Console.WriteLine(func(1, 2));
     Console.WriteLine(func.Invoke(1, 2));
     Console.WriteLine(func.DynamicInvoke(1, 2));
 }


 {
     //  
     //  创建Expression
     //  @return  int
     //  @params  UserInfo(user)
     //
     //入参表达式
     var param = Expression.Parameter(typeof(UserInfo), "user");
     //参数属性访问器表达式
     var member = Expression.MakeMemberAccess(param, typeof(UserInfo).GetMember("Age").FirstOrDefault()!);
     //常量表达式
     var constant = Expression.Constant(999);
     //二进制计算表达式
     var body = Expression.Add(member, constant);
     //Lambda表达式
     var lambda = Expression.Lambda(body, param);
     Console.WriteLine(lambda.Compile().DynamicInvoke(new UserInfo() { Age = 1 }));
     //Console.WriteLine(((Func<UserInfo, int>)lambda.Compile()).DynamicInvoke(new UserInfo() { Age = 1 }));
 }

 public class Resource : IDisposable
 {
     private bool _isDisposed = false;
     public int Argument
     {
         get
         {
             if (!_isDisposed)
                 return 5;
             else throw new ObjectDisposedException("资源已被释放");
         }
     }

     public void Dispose()
     {
         _isDisposed = true;
     }
 }

 {
     var constant = new Resource();
     Expression<Func<int, int>> expression = (b) => constant.Argument + b;
     var func = expression.Compile();
     try
     {
         //  释放后入参执行
         constant.Dispose();
         Console.WriteLine(func(1));
     }
     catch (Exception ex)
     {
         Console.WriteLine(ex);
     // 异常
     //System.ObjectDisposedException: Cannot access a disposed object.Object     name: '资源已被释放'
     }
 }

  Expression<Func<int, int, int>> addition = (a, b) => a + b;
  Console.WriteLine($"This expression is a {addition.NodeType} expression type");
  Console.WriteLine($"The name of the lambda is {((addition.Name == null) ? "<null>" : addition.Name)}");
  Console.WriteLine($"The return type is {addition.ReturnType.ToString()}");
  Console.WriteLine($"The expression has {addition.Parameters.Count} arguments. They are:");
  foreach (var argumentExpression in addition.Parameters)
  {
      Console.WriteLine($"\tParameter Type: {argumentExpression.Type.ToString()}, Name: {argumentExpression.Name}");
  }
  var additionBody = (BinaryExpression)addition.Body;
  Console.WriteLine($"The body is a {additionBody.NodeType} expression");
  Console.WriteLine($"The left side is a {additionBody.Left.NodeType} expression");
  var left = (ParameterExpression)additionBody.Left;
  Console.WriteLine($"\tParameter Type: {left.Type.ToString()}, Name: {left.Name}");
  Console.WriteLine($"The right side is a {additionBody.Right.NodeType} expression");
  var right = (ParameterExpression)additionBody.Right;
  Console.WriteLine($"\tParameter Type: {right.Type.ToString()}, Name: {right.Name}");

  public class TestMonths
  {
      public  int Conver32(int a)
      {
          return Convert.ToInt32(a);
      }
  }

   TestMonths testMonths = new TestMonths();
   var gg = 99;
   Expression<Func<UserInfo, int, int, double>> exception = (user, a, b) => user.Age + (a / b) * a - b + a - (b + b) + (a % b) + (a > b ? a : b) / user.Level * gg + testMonths.Conver32(user.Level);
   LambdaVisitor visitor = new LambdaVisitor(exception);
   visitor.Visit("解析二进制运算:");
   Console.WriteLine("\t");

 Expression<Func<UserInfo, UserInfoModel>> lambda = (user) => new UserInfoModel
 {
     Age = user.Age,
     Level = EF.Functions.DataLength(user.Name) ?? 0,
     Name = user.Name
 };
 LambdaVisitor visitor3 = new LambdaVisitor(lambda);
 visitor3.Visit("解析查询表达式:");

  //属性访问器
  {
      //需要构建的表达式
      Expression<Func<UserInfo, int>> left = (user) => user.Age;

      //1.创建访问对象表达式  =>(user)
      var param = Expression.Parameter(typeof(UserInfo), "user");

      //
      //2.创建访问属性表达式 =>(user.Age)
      //      @expression 我们需要访问成员的归属对象
      //      @member     成员访问器
      var member = Expression.MakeMemberAccess(param, typeof(UserInfo).GetMember("Age").FirstOrDefault()!);

      //3.创建Lambda表达式
      var lambda = Expression.Lambda(member, param);

      //测试编译输出 18
      Console.WriteLine(lambda.Compile().DynamicInvoke(new UserInfo { Age = 18 }));

  }

  //条件判断表达式
  {
      //需要构建的表达式
      Expression<Func<UserInfo, bool>> left = (user) => user.Age > 9;

      //1.创建访问对象表达式   =>(user)
      var param = Expression.Parameter(typeof(UserInfo), "user");

      //
      //2.创建访问属性表达式   =>(user.Age)
      //      @expression 我们需要访问成员的归属对象
      //      @member     成员访问器
      var member = Expression.MakeMemberAccess(param, typeof(UserInfo).GetMember("Age").FirstOrDefault()!);

      //
      //3.创建常量表达式    =>(9)
      var constant = Expression.Constant(9);

      //
      //4.创建条件判断表达式    =>(>)
      var greaterThan = Expression.GreaterThan(member, constant);

      //5.创建Lambda表达式
      var lambda = Expression.Lambda(greaterThan, param);

      //测试编译输出 True
      Console.WriteLine(lambda.Compile().DynamicInvoke(new UserInfo { Age = 18 }));
  }