1. 温习访问者模式，简单的说就是，按照既定的路线去一步一步访问，在访问中间步骤做点其他扩展！

    2. expression应用： ```csharp //为什么要使用表达式目录树来拼装解析呢； //可以提高重用性； //如果封装好一个方法，接受一个表达式目录树，在解析的时候，其实就是不断的访问，访问有规则； //任何一个表达式目录树我都可以调用当前方法来解析； //表达式目录树可以支持泛型；封装的时候个人认为好封装一些；

      //应用1：把表达式拼装成sql {

      1.  Expression<Func<People, bool>> lambda = x => x.Age > 5 && x.Id > 5
      2.                                          && x.Name.StartsWith("1") //  like '1%'
      3.                                          && x.Name.EndsWith("1") //  like '%1'
      4.                                          && x.Name.Contains("1");//  like '%1%'
    1.     ConditionBuilderVisitor vistor = new ConditionBuilderVisitor();
    2.     vistor.Visit(lambda);
    3.     Console.WriteLine(vistor.Condition());
    4. }
    8.  /// <summary>
    9. /// 表达式树转化成Sql，首先继承 ExpressionVisitor，该类的Visit方法就是自动识别该表达式的形式，分配给适合的方法做解析
    10. /// </summary>
    11. public class ConditionBuilderVisitor : ExpressionVisitor
    12. {
    13.     private Stack<string> _StringStack = new Stack<string>();
    15.     public string Condition()
    16.     {
    17.         string condition = string.Concat(this._StringStack.ToArray());
    18.         this._StringStack.Clear();
    19.         return condition;
    20.     }
    22.     /// <summary>
    23.     /// 如果是二元表达式
    24.     /// </summary>
    25.     /// <param name="node"></param>
    26.     /// <returns></returns>
    27.     protected override Expression VisitBinary(BinaryExpression node)
    28.     {
    29.         if (node == null) throw new ArgumentNullException("BinaryExpression");
    31.         this._StringStack.Push(")");
    32.         base.Visit(node.Right);//解析右边
    33.         this._StringStack.Push(" " + node.NodeType.ToSqlOperator() + " ");
    34.         base.Visit(node.Left);//解析左边
    35.         this._StringStack.Push("(");
    37.         return node;
    38.     }
    40.     /// <summary>
    41.     /// 解析属性
    42.     /// </summary>
    43.     /// <param name="node"></param>
    44.     /// <returns></returns>
    45.     protected override Expression VisitMember(MemberExpression node)
    46.     {
    47.         if (node == null) throw new ArgumentNullException("MemberExpression");
    48.         //this._StringStack.Push(" [" + node.Member.Name + "] ");
    49.         ////return node; 
    50.         if (node.Expression is ConstantExpression)
    51.         {
    52.             var value1 = this.InvokeValue(node);
    53.             var value2 = this.ReflectionValue(node);
    54.             //this.ConditionStack.Push($"'{value1}'");
    55.             this._StringStack.Push("'" + value2 + "'");
    56.         }
    57.         else
    58.         {
    59.             this._StringStack.Push(" [" + node.Member.Name + "] ");
    60.         }
    61.         return node;
    62.     }
    65.     private object InvokeValue(MemberExpression member)
    66.     {
    67.         var objExp = Expression.Convert(member, typeof(object));//struct需要
    68.         return Expression.Lambda<Func<object>>(objExp).Compile().Invoke();
    69.     }
    71.     private object ReflectionValue(MemberExpression member)
    72.     {
    73.         var obj = (member.Expression as ConstantExpression).Value;
    74.         return (member.Member as FieldInfo).GetValue(obj);
    75.     }
    77.     /// <summary>
    78.     /// 常量表达式
    79.     /// </summary>
    80.     /// <param name="node"></param>
    81.     /// <returns></returns>
    82.     protected override Expression VisitConstant(ConstantExpression node)
    83.     {
    84.         if (node == null) throw new ArgumentNullException("ConstantExpression");
    85.         this._StringStack.Push(" '" + node.Value + "' ");
    86.         return node;
    87.     }
    88.     /// <summary>
    89.     /// 方法表达式
    90.     /// </summary>
    91.     /// <param name="m"></param>
    92.     /// <returns></returns>
    93.     protected override Expression VisitMethodCall(MethodCallExpression m)
    94.     {
    95.         if (m == null) throw new ArgumentNullException("MethodCallExpression");
    97.         string format;
    98.         switch (m.Method.Name)
    99.         {
    100.             case "StartsWith":
    101.                 format = "({0} LIKE {1}+'%')";
    102.                 break;
    104.             case "Contains":
    105.                 format = "({0} LIKE '%'+{1}+'%')";
    106.                 break;
    108.             case "EndsWith":
    109.                 format = "({0} LIKE '%'+{1})";
    110.                 break;
    112.             default:
    113.                 throw new NotSupportedException(m.NodeType + " is not supported!");
    114.         }
    115.         this.Visit(m.Object);
    116.         this.Visit(m.Arguments[0]);
    117.         string right = this._StringStack.Pop();
    118.         string left = this._StringStack.Pop();
    119.         this._StringStack.Push(String.Format(format, left, right));
    121.         return m;
    122.     }
    123. }
    2. ```csharp
    3.  先插入一个场景：根据条件搜索
    4.               {
    5.                         //现在是Linq to SQL
    6.                         var dbSet = new List<People>().AsQueryable();//EF DbSet 
    7.                         dbSet.Where(p => p.Age == 25 & p.Name.Contains("李四"));
    9.                         Expression<Func<People, bool>> exp = null;
    10.                         Console.WriteLine("用户输入个名称，为空就跳过");
    11.                         string name = Console.ReadLine();
    12.                         if (!string.IsNullOrWhiteSpace(name))
    13.                         {
    14.                             exp = p => p.Name.Contains(name);
    15.                         }
    16.                         Console.WriteLine("用户输入个最小年纪，为空就跳过");
    17.                         string age = Console.ReadLine();
    18.                         if (!string.IsNullOrWhiteSpace(age) && int.TryParse(age, out int iAge))
    19.                         {
    20.                             exp = p => p.Age > iAge;
    21.                         }
    23.                     }
    25.            }
    27.   //提问：
    28.   //上面的玩法是不是只有最后一个条件才生效？
    29.   //如果需要两个条件都满足呢？  怎么解决，可以做到表达式目录树的合并（且）  或   非
    31.   //解答：
    32.     当然是拼装啊；拼装可以从最小粒度来组装表达式目录树~~
    33.     如果有一个封装，你把各种条件给我，我从最小粒度开始一个一个的拼装起来，不就是一个长的表达式目录树了吗？
    1.   //应用2： 表达式链接
    2.         Expression<Func<People, bool>> lambda1 = x => x.Age > 5;  
    3.         Expression<Func<People, bool>> lambda2 = x => x.Id > 5;
    5.         //现有表达式数lambda1，lambda2如何有目的把他们连接起来
    6.         //Expression<Func<People, bool>> newExpress = x => x.Age > 5 && x.Id > 5;
    8.          Expression<Func<People, bool>> lambda3 = lambda1.And(lambda2); //且
    9.          Expression<Func<People, bool>> lambda4 = lambda1.Or(lambda2);//或
    10.          Expression<Func<People, bool>> lambda5 = lambda1.Not();//非
    11.          Do1(lambda3);
    12.          Do1(lambda4);
    13.          Do1(lambda5);
    15.         //验证方法
    16.          private static void Do1(Expression<Func<People, bool>> func)
    17.         {
    18.             List<People> people = new List<People>()
    19.             {
    20.                 new People(){Id=4,Name="123",Age=4},
    21.                 new People(){Id=5,Name="234",Age=5},
    22.                 new People(){Id=6,Name="345",Age=6},
    23.             };
    25.             List<People> peopleList = people.Where(func.Compile()).ToList();
    26.         }
    28.     /// <summary>
    29.     /// 合并表达式 And Or  Not扩展
    30.     /// </summary>
    31.     public static class ExpressionExtend
    32.     {
    33.         /// <summary>
    34.         /// 合并表达式 expr1 AND expr2
    35.         /// </summary>
    36.         /// <typeparam name="T"></typeparam>
    37.         /// <param name="expr1"></param>
    38.         /// <param name="expr2"></param>
    39.         /// <returns></returns>
    40.         public static Expression<Func<T, bool>> And<T>(this Expression<Func<T, bool>> expr1, Expression<Func<T, bool>> expr2)
    41.         {
    42.             //return Expression.Lambda<Func<T, bool>>(Expression.AndAlso(expr1.Body, expr2.Body), expr1.Parameters);
    44.             ParameterExpression newParameter = Expression.Parameter(typeof(T), "c");
    45.             NewExpressionVisitor visitor = new NewExpressionVisitor(newParameter);
    46.             var left = visitor.Replace(expr1.Body);
    47.             var right = visitor.Replace(expr2.Body); //为了能够生成一个新的表达式目录树
    48.             var body = Expression.And(left, right);
    49.              return Expression.Lambda<Func<T, bool>>(body, newParameter);
    51.         }
    52.         /// <summary>
    53.         /// 合并表达式 expr1 or expr2
    54.         /// </summary>
    55.         /// <typeparam name="T"></typeparam>
    56.         /// <param name="expr1"></param>
    57.         /// <param name="expr2"></param>
    58.         /// <returns></returns>
    59.         public static Expression<Func<T, bool>> Or<T>(this Expression<Func<T, bool>> expr1, Expression<Func<T, bool>> expr2)
    60.         {
    62.             ParameterExpression newParameter = Expression.Parameter(typeof(T), "c");
    63.             NewExpressionVisitor visitor = new NewExpressionVisitor(newParameter);
    65.             var left = visitor.Replace(expr1.Body);
    66.             var right = visitor.Replace(expr2.Body);
    67.             var body = Expression.Or(left, right);
    68.             return Expression.Lambda<Func<T, bool>>(body, newParameter);
    69.         }
    71.         public static Expression<Func<T, bool>> Not<T>(this Expression<Func<T, bool>> expr)
    72.         {
    73.             var candidateExpr = expr.Parameters[0];
    74.             var body = Expression.Not(expr.Body);
    76.             return Expression.Lambda<Func<T, bool>>(body, candidateExpr);
    77.         }
    78.     }
    80.     /// <summary>
    81.     /// 建立新表达式
    82.     /// </summary>
    83.     internal class NewExpressionVisitor : ExpressionVisitor
    84.     {
    85.         public ParameterExpression _NewParameter { get; private set; }
    86.         public NewExpressionVisitor(ParameterExpression param)
    87.         {
    88.             this._NewParameter = param;
    89.         }
    90.         public Expression Replace(Expression exp)
    91.         {
    92.             return this.Visit(exp);
    93.         }
    94.         protected override Expression VisitParameter(ParameterExpression node)
    95.         {
    96.             return this._NewParameter;
    97.         }
    98.     }