1     public class 计算器类

 2     {

 3         //声明一个具体的委托类型mydelegate，它规定绑定到它这种类型的变量的方法的返回值是一个decimal类型

 4         //同时它也规定绑定到它这种类型的变量的方法的返回值是两个decimal类型

 5         public delegate decimal mydelegate(decimal m, decimal n);

 6         //接下来有两个方法符合上面的返回值和入参的规范：

 7         static decimal Operation1(decimal x, decimal y)

 8         { return x + y; }

 9         static decimal Operation2(decimal x, decimal y)

10         { return x * y; }

11         public mydelegate 算法;

12         void XX()

13         {

14             //接下来是实例化一个委托，也就是把方法绑定到具体委托类型（mydelegate）的变量（算法）

15             算法 = new mydelegate(Operation1);

16             //使用+=操作符把多个方法绑定给一个委托类型（mydelegate）的变量

17             算法 += new mydelegate(Operation2);

18         }

19         public decimal ExecuteOperation(decimal a, decimal b)

20         {

21             return 算法.Invoke(a, b);

22         }

23     }

24     //2.委托对面向对象多态的体现：在下面 客户端运算类中 我们只需要传给计算器类的委托实例【算法】一个具体的算法（相减），

25     //则计算器类就能在不改动的情况下拥有新的算法能力

26     public class 客户端运算

27     {

28         计算器类 jsq1 = new 计算器类();

29         //在计算器类中并没有的新的算法：相减

30         public decimal 相减(decimal x, decimal y)

31         { return x - y; }

32         void 指示计算器做减法()

33         {

34             //把方法绑定给委托实例

35             jsq1.算法 += 相减;

36             Console.WriteLine(jsq1.算法.Invoke(5, 6));

37         }

38

39

40         //我们还可以这样做，调用外部封装好的算法方法，然后把这个方法成员绑定给委托实例，比如

41         void 指示计算器做除法()

42         {

43             //把单独类中的方法成员绑定给委托实例

44             jsq1.算法 += new 除法算法类().相除;

45             Console.WriteLine(jsq1.算法.Invoke(20, 5));

46         }

47     }

48     //把除法封装在一个单独的类中的方法成员：相除

49     public class 除法算法类

50     {

51         public decimal 相除(decimal x, decimal y)

52         { return x / y; }

53     }