2.1 委托的使用

能够解耦&代码重用

  1. public void SayHi(string name,SayHiDelegate method){
  2.     //公共方法.....
  3.     method.Invoke(name);
  4.     //公共方法....
  5. }

多波委托拆解后的异步调用

  1.   public delegate void TestFun();
  2.         static void Main(string[] args) {
  3.             //多播委托
  4.             TestFun testFun = new TestFun(() => Console.WriteLine("Hello World"));
  5.             testFun += new TestFun(() => Console.WriteLine("Hello World"));
  6.             testFun+= new TestFun(() => Console.WriteLine("Hello World"));
  7.             testFun.Invoke();
  8.             //多播委托无法进行异步调用，可通过此方法进行拆解
  9.             foreach (TestFun item in testFun.GetInvocationList()) {
  10.                 item.BeginInvoke(null,null); 
  11.             }
  12.         }
  13. }

2.2 Lambda

参数列表=>方法体，Lambda表达式就是一个匿名方法，就是一个方法。
基于lambda表达式注册的多播委托是无法移除的。

2.2.1 发展过程

  1. public void delegate SayHiDelegate(string name);
  2. public void SayHi(string name){
  3.     Console.WriteLine($"Say Hi,{name}");
  4. }
  5. //.NET Framework1.0
  6. SayHiDelegate sayHi = new SayHiDelegate(this.SayHi);
  7. sayHi.Invoke("Albert");
  8. //.NET Framework2.0 匿名方法
  9. SayHiDelegate sayHi = new SayHiDelegate(delegate (string name){
  10.  Console.WriteLine($"Say Hi,{name}");
  11. });
  12. sayHi.Invoke("Albert");
  14. //.NET Framework3.0 delegate变为=>   
  15. //lambda参数类型可以推断出来，可省略。根据委托的约束来推断出的。 语法糖
  16. SayHiDelegate sayHi = new SayHiDelegate(name =>{
  17.  Console.WriteLine($"Say Hi,{name}");
  18. });
  19. sayHi.Invoke("Albert");
  21. //如果方法体只有一行，可以省略大括号+分号 语法糖
  22. SayHiDelegate sayHi = new SayHiDelegate(name =>
  23.  Console.WriteLine($"Say Hi,{name}")
  24. );
  25. sayHi.Invoke("Albert");
  27. //实例化委托时，可以省略new SayHiDelegate 语法糖
  28. SayHiDelegate sayHi = name =>
  29.  Console.WriteLine($"Say Hi,{name}");
  30. sayHi.Invoke("Albert");

2.2.2 对Lambda用于表达式目录树进行解析

解析类
ConditionBuilderVistor.cs ConditionBuilderVisitor.cs
SqlOperator.csSqlOperator.cs

  1. using System;
  2. using System.Collections.Generic;
  3. using System.Linq;
  4. using System.Linq.Expressions;
  5. using System.Text;
  6. using System.Threading.Tasks;
  8. namespace MyDelegateEvent.ExpressionTest
  9. {
  10.     public class ConditionBuilderVisitor : ExpressionVisitor
  11.     {
  12.         private Stack<string> _StringStack = new Stack<string>();
  14.         public string Condition()
  15.         {
  16.             string condition = string.Concat(this._StringStack.ToArray());
  17.             this._StringStack.Clear();
  18.             return condition;
  19.         }
  21.         /// <summary>
  22.         /// 二元表达式
  23.         /// </summary>
  24.         /// <param name="node"></param>
  25.         /// <returns></returns>
  26.         protected override Expression VisitBinary(BinaryExpression node)
  27.         {
  28.             if (node == null) throw new ArgumentNullException("BinaryExpression");
  30.             this._StringStack.Push(")");
  31.             base.Visit(node.Right);//解析右边
  32.             this._StringStack.Push(" " + node.NodeType.ToSqlOperator() + " ");
  33.             base.Visit(node.Left);//解析左边
  34.             this._StringStack.Push("(");
  36.             return node;
  37.         }
  39.         /// <summary>
  40.         /// 
  41.         /// </summary>
  42.         /// <param name="node"></param>
  43.         /// <returns></returns>
  44.         protected override Expression VisitMember(MemberExpression node)
  45.         {
  46.             if (node == null) throw new ArgumentNullException("MemberExpression");
  47.             this._StringStack.Push(" [" + node.Member.Name + "] ");
  48.             return node;
  49.         }
  51.         /// <summary>
  52.         /// 常量表达式
  53.         /// </summary>
  54.         /// <param name="node"></param>
  55.         /// <returns></returns>
  56.         protected override Expression VisitConstant(ConstantExpression node)
  57.         {
  58.             if (node == null) throw new ArgumentNullException("ConstantExpression");
  59.             this._StringStack.Push(" '" + node.Value + "' ");
  60.             return node;
  61.         }
  64.         /// <summary>
  65.         /// 方法表达式
  66.         /// </summary>
  67.         /// <param name="m"></param>
  68.         /// <returns></returns>
  69.         protected override Expression VisitMethodCall(MethodCallExpression m)
  70.         {
  71.             if (m == null) throw new ArgumentNullException("MethodCallExpression");
  73.             string format;
  74.             switch (m.Method.Name)
  75.             {
  76.                 case "StartsWith":
  77.                     format = "({0} LIKE {1}+'%')";
  78.                     break;
  80.                 case "Contains":
  81.                     format = "({0} LIKE '%'+{1}+'%')";
  82.                     break;
  84.                 case "EndsWith":
  85.                     format = "({0} LIKE '%'+{1})";
  86.                     break;
  88.                 default:
  89.                     throw new NotSupportedException(m.NodeType + " is not supported!");
  90.             }
  91.             this.Visit(m.Object);
  92.             this.Visit(m.Arguments[0]);
  93.             string right = this._StringStack.Pop();
  94.             string left = this._StringStack.Pop();
  95.             this._StringStack.Push(String.Format(format, left, right));
  97.             return m;
  98.         }
  99.     }
  100. }
  102. using System;
  103. using System.Collections.Generic;
  104. using System.Linq;
  105. using System.Linq.Expressions;
  106. using System.Text;
  107. using System.Threading.Tasks;
  109. namespace MyDelegateEvent.ExpressionTest
  110. {
  111.     internal static class SqlOperator
  112.     {
  113.         internal static string ToSqlOperator(this ExpressionType type)
  114.         {
  115.             switch (type)
  116.             {
  117.                 case (ExpressionType.AndAlso):
  118.                 case (ExpressionType.And):
  119.                     return "AND";
  120.                 case (ExpressionType.OrElse):
  121.                 case (ExpressionType.Or):
  122.                     return "OR";
  123.                 case (ExpressionType.Not):
  124.                     return "NOT";
  125.                 case (ExpressionType.NotEqual):
  126.                     return "<>";
  127.                 case ExpressionType.GreaterThan:
  128.                     return ">";
  129.                 case ExpressionType.GreaterThanOrEqual:
  130.                     return ">=";
  131.                 case ExpressionType.LessThan:
  132.                     return "<";
  133.                 case ExpressionType.LessThanOrEqual:
  134.                     return "<=";
  135.                 case (ExpressionType.Equal):
  136.                     return "=";
  137.                 default:
  138.                     throw new Exception("不支持该方法");
  139.             }
  141.         }
  142.     }
  143. }

使用：

  1.  {
  2.       var userDbSet = new List<Student>().AsQueryable();
  3.             var userList = userDbSet.Where(s => s.Id > 100 && s.Name.Contains("1"));
  5.             Expression<Func<Student, bool>> predicate = s => s.Id > 100
  6.             && s.Name.Contains("1")
  7.             && s.Name.StartsWith("2")
  8.             && s.Name.EndsWith("3")
  9.             && s.QQ > 57265177
  10.             && s.QQ < 999999999;
  11.      {
  12.          //把predicate转成一个where 子句
  13.                 ConditionBuilderVisitor visitor = new ConditionBuilderVisitor();
  14.                 visitor.Visit(predicate);
  15.                 string where = visitor.Condition();
  16.      }               
  17. }

2.3 LINQ的代码实现

Linq to object(Enumerable)：数据源是内存里面的集合—传递的委托判断
Linq to sql(Queryable)：数据源在SqlServer—需要Sql语句—从表达式目录树而来的（2.2.2有从表达式目录树转为Sql语句）
自我实现1，通过委托来传递逻辑，来实现List全遍历。
查看源码发现，LINQ的Where是通过迭代器来实现的，重新优化实现逻辑，实现方式通过IEnumerable来进行yield迭代输出：按需获取、延时加载。（发生迭代）需要才进入检查。

  1. 迭代器方法的内部使用状态机实现，但可以使用yield关键字快速实现迭代器方法，使用yield return语句添加需要迭代的元素，在首次迭代时，会一直执行到第一个yield return语句并保存当前迭代状态，在接下来的每次迭代过程中都会从暂停的位置继续执行到下一个yield return语句并保存迭代状态（MoveNext()方法返回true并将当前迭代的值赋值给Current），直到到达迭代器的结尾（MoveNext()方法返回false）完成本次迭代；也可以在迭代过程中使用yield break语句立刻结束本次迭代

image.png
image.png

  1. using System;
  2. using System.Collections.Generic;
  3. using System.Linq;
  4. using System.Text;
  5. using System.Threading;
  6. using System.Threading.Tasks;
  8. namespace LINQComple {
  9.     class Program {
  10.         static void Main(string[] args) {
  11.             List<Student> students = new List<Student>();
  12.             for (int i = 0; i < 30; i++) {
  13.                 students.Add(new Student() { Age = 28 + i, Name = "Albert_" + i.ToString() });
  14.             }
  15.             Console.WriteLine("***************Start 这是系统方法*************");
  16.             var list = students.Where(s => {
  17.                 Thread.Sleep(100);
  18.                 return s.Age > 29;
  19.                 }); //LINQ
  20.             foreach (var item in list) {
  21.                 Console.WriteLine(item.Name);
  22.             }
  23.             Console.WriteLine("***************End 这是系统方法*************");
  25.             Console.WriteLine("***************Start 这是自定义方法1*************");
  26.             var list2 = students.AlbertWhere(s => {
  27.                 Thread.Sleep(100);
  28.                 return s.Age > 29;
  29.                 });
  30.             foreach (var item in list2) {
  31.                 Console.WriteLine(item.Name);
  32.             }
  33.             Console.WriteLine("***************End 这是自定义方法*************");
  35.             Console.WriteLine("***************Start 这是自定义方法2*************");
  36.             var ienm = students.AlbertWhereIEnumber(s => {
  37.                 Thread.Sleep(100);
  38.                 return s.Age > 29;
  39.                 });
  40.             foreach (var item in ienm) {
  41.                 Console.WriteLine(item.Name);
  42.             }
  43.             Console.WriteLine("***************End 这是自定义方法2*************");
  45.         }
  46.     }
  49.     /// <summary>
  50.     /// 自己通过委托实现Linq查询
  51.     /// if中不同的逻辑需要传递，相当于告诉你要使用委托
  52.     /// 1.基于委托封装，完成代码复用
  53.     /// </summary>
  54.     public static class LinqExtend {
  55.         public static List<T> AlbertWhere<T>(this List<T> ts,Func<T, bool> func) {
  56.             List<T> ts1 = new List<T>();
  57.             foreach (var item in ts) {
  58.                 if (func.Invoke(item)) {
  59.                     ts1.Add(item);
  60.                 }
  61.             }
  62.             return ts1;
  63.         }
  65.         /// <summary>
  66.         /// 通过枚举迭代,和LINQ原理相同，不会一直在等待查询全部完毕
  67.         /// 迭代器升级：按需获取、延时加载。（发生迭代）需要才进入检查
  68.         /// </summary>
  69.         /// <typeparam name="T"></typeparam>
  70.         /// <param name="ts"></param>
  71.         /// <param name="func"></param>
  72.         /// <returns></returns>
  73.         public static IEnumerable<T> AlbertWhereIEnumber<T>(this IEnumerable<T> ts,Func<T,bool> func) {
  74.             foreach (var item in ts) {
  75.                 if (func.Invoke(item)) {
  76.                     yield return item;
  77.                 }
  78.             }
  79.         }
  80.     }
  82.     public class Student {
  83.         public int Age { get; set; }
  84.         public string Name { get; set; }
  85.     }
  86. }