C#基础之委托

通过以下头脑导图，学习委托的根本概念，背面着重讲授委托的运用，盼望通过最简单的方式劳绩更多的知识。

1.委托的各种写法

1、委托 委托名=new 委托（会调用的方法名); 委托名（参数）;

2、委托 委托名 =会调用的方法名; 委托名（参数）；

3、匿名方法：委托 委托名=delegate(参数）{会调用的方法体};委托名（参数）；

4、拉姆达表达式：委托 委托名=（（参数1，。。参数n）=>{会调用的方法体}）；委托名（参数）；

5、用Action和Func

Action<参数1, 参数2,> 委托名= ((参数1，参数2) => {不带返回值的方法体 });委托名（参数1，参数2）；

Func<参数1, 参数2, 返回值> 委托名= ((参数1，参数2) => {带返回值的方法体 });返回值=委托名（参数1，参数2）；

示例：

1. public delegate int Call(int num1, int num2);
2. class SimpleMath
3. {
4. // 乘法方法
5. public static int Multiply(int num1, int num2)
6. {
7. return num1 * num2;
8. }
10. // 除法方法
11. public int Divide(int num1, int num2)
12. {
13. return num1 / num2;
14. }
15. }
18. class Test
19. {
20. static void Main(string[] args)
21. {
22. //--------------------第一种写法------------------------//
23. Call objCall = new Call(SimpleMath.Multiply);
24. Call objCall1 = new Call(new SimpleMath().Divide);
26. //--------------------第二种写法------------------------//
27. Call objCall = SimpleMath.Multiply;
28. Call objCall1 = new SimpleMath().Divide;
30. //--------------------第三种写法------------------------//
31. Call objCall = delegate(int a, int b)
32. {
33. return a * b;
34. };
35. Call objCall1 = delegate(int a, int b)
36. {
37. return a / b;
38. };
40. //--------------------第四种写法------------------------//
41. Call objCall =((int a,int b)=> { return a*b;});
42. Call objCall1 = ((int a, int b) => { return a / b; });
44. //--------------------第五种写法------------------------//
45. Func<int, int, int> objCall = ((a, b) => { return a * b; });
46. Func<int, int, int> objCall1 = ((a, b) => { return a / b; });
47. Action<int, int> ob = ((a, b) => { Console.WriteLine(a * b); });
48. ob(5, 3);
49. //----------------------------------------------------//
51. int result = objCall(5, 3);
52. int result1 = objCall1(5, 3);
53. System.Console.WriteLine("结果1为 {0},结果2为{1}", result,result1);
54. Console.ReadKey();
55. }
56. }

复制代码

2.委托的运用

委托的运用记着两点：

1.将方法看成参数实例化委托对象；

2.将方法的参数通报给委托对象，以实实际际的方法调用。

委托常用场景：

1.模板方法：

如以下定义类CalculateFactory，用于定义各种计算方法，然后通过Calculate方法袒露出来给外界使用，而Calculate方法通过传入委托对象new Calculate(x1.Add)来实现对Add方法的调用。这是委托模板方法使用较简单的一种形式，它还可以有许多变种。

下面这段程序不消委托完全可以实现同样的逻辑，为什么要“故弄玄虚”呢？因为示例是为了阐明委托作为模板方法的用法，故而用了最简单的一种，实际运用过程中，通常与计划模式相团结，以实现代码的高复用低耦合。进一步延伸，实际计划模式中也较少用委托，而用接口、抽象类来实现“模板方法”的功能，具体要怎么用是看个人风俗和便捷程度。委托用的最多的场景是下面要先容的回调方法。

1. class Program
2. {
3. static void Main(string[] args)
4. {
5. CalculateFactory x1 = new CalculateFactory();
6. CalculateFactory x2 = new CalculateFactory();
7. x1.Calculate(10, 9, new Calculate(x1.Add));
8. x2.Calculate(10, 9, new Calculate(x2.Reduce));
9. Console.ReadKey();
10. }
11. }
14. public delegate void Calculate(int a, int b);
15. public class CalculateFactory
16. {
17. public void Calculate(int a, int b, Calculate calculateDelegae)
18. {
19. calculateDelegae(a, b);
20. }
22. public void Add(int a, int b)
23. {
24. Console.WriteLine(string.Format("This is a+b={0}", a + b));
25. }
27. public void Reduce(int a, int b)
28. {
29. Console.WriteLine(string.Format("This is a-b={0}", a - b));
30. }
32. }

复制代码

2.回调方法：

回调方法与模板方法并不是并列的两种范例，其本质都是一样的，即将方法当成参数通报并调用，是通过应用场景来分类的。主调方法（调用回调方法的方法体）在满足某种条件或完成某种逻辑后去调用的方法，称为回调方法。将上面示例改造成含有回调方法的程序。

示例：这里既用到了模板方法，也用到了回调方法。示例代码泉源于刘铁猛大师的示例，在此表示感谢。

1. class Program
2. {
3. static void Main(string[] args)
4. {
5. ProductFactory productFactory = new ProductFactory();
6. WrapFactory wrapFactory = new WrapFactory();
8. Func<Product> func1 = new Func<Product>(productFactory.MakePizza);
9. Func<Product> func2 = new Func<Product>(productFactory.MakeToyCar);
11. Logger logger = new Logger();
12. Action<Product> log = new Action<Product>(logger.Log); //Log的委托;
14. Box box1 = wrapFactory.WrapProduct(func1, log);
15. Box box2 = wrapFactory.WrapProduct(func2, log);
17. Console.WriteLine(box1.Product.Name);
19. }
20. class Product //产物类
21. {
22. public string Name { get; set; }
23. public double Price { get; set; }
24. }
25. class Box //盒子类
26. {
27. public Product Product { get; set; }
28. }
29. class Logger
30. {
31. public void Log(Product product)
32. {
33. Console.WriteLine(product.Price);
34. }
35. }
36. class WrapFactory //包装工厂
37. {
38. public Box WrapProduct(Func<Product> getProduct, Action<Product> logCallback)
39. {
40. Box box = new Box();
41. Product product = getProduct.Invoke();//此处使用的是间接的同步调用，如果使用间接异步调用用BeginInvoke();
42. if (product.Price > 50) //如果产物代价大于50，就执行回调方法;
43. {
44. logCallback(product);
45. }
46. box.Product = product;
47. return box;
48. }
49. }
50. class ProductFactory //产物工厂
51. {
52. public Product MakePizza()
53. {
54. Product product = new Product();
55. product.Name = "Pizza";
56. product.Price = 30;
57. return product;
58. }
59. public Product MakeToyCar()
60. {
61. Product product = new Product();
62. product.Name = "ToyCar";
63. product.Price = 100;
64. return product;
65. }
66. }
67. }

复制代码

3.总结

委托底子内容根本就是这些，回调方法在实际使用中也是最多的，上面回调方法的示例是有实用代价的，必要好好了解。委托尚有多播委托等进阶应用，在此不作先容，但必要相识其概念，以便碰到相应场景时翻翻资料能找到办理方案。

来源：https://www.cnblogs.com/qcst123/archive/2019/09/24/11575557.html