委托、事件--委托实例篇

实例一、

1. using System;
2. namespace SimpleDelegate
3. {
4.     //定义委托
5.     delegate double DoubleOp(double x);
6.  
7.     class MainEntryPoint
8.     {
9.         static void Main()
10.         {
11.             //实例化
12.             DoubleOp[] operations =
13.                 {
14.                     new DoubleOp(MathsOperations.MultiplyByTwo),
15.                     new DoubleOp(MathsOperations.Square)
16.                 };
17.             /* 使用匿名方法
18.             DoubleOp first = delegate(double value){return value * 2;};
19.             DoubleOp second = delegate(double value) { return value * value; };
20.             DoubleOp[] operations = { first, second };
21.             */
22.  
23.             //使用委托
24.             for (int i = 0; i < operations.Length; i++)
25.             {
26.                 Console.WriteLine("Using operations[{0}]:", i);
27.                 ProcessAndDisplayNumber(operations[i], 2.0);
28.                 ProcessAndDisplayNumber(operations[i], 7.94);
29.                 ProcessAndDisplayNumber(operations[i], 1.414);
30.                 Console.WriteLine();
31.             }
32.             Console.ReadLine();
33.         }
34.  
35.         static void ProcessAndDisplayNumber(DoubleOp action, double value)
36.         {
37.             double result = action(value);
38.             Console.WriteLine("Value is {0}, result of operation is {1}", value, result);
39.         }
40.     }
41.  
42.     class MathsOperations
43.     {
44.         public static double MultiplyByTwo(double value)
45.         {
46.             return value * 2;
47.         }
48.  
49.         public static double Square(double value)
50.         {
51.             return value * value;
52.         }
53.    }
54. }

      这段代码的关键一行是把委托传递给ProcessAndDisplayNumber()方法，例如：ProcessAndDisplayNumber(operations[i], 2.0);

      其中传递了委托名，但不带任何参数，假定operations[i]是一个委托，其语法是：

      1、operations[i]表示“这个委托”。换言之，就是委托代表的方法。

      2、operations[i](2.0)表示“调用这个方法，参数放在括号中”。

实例二、

1. using System;

2.  

3. namespace BubbleSorter

4. {

5.     //定义委托

6.     delegate bool CompareOp(object lhs, object rhs);

7.  

8.     class MainEntryPoint

9.     {

10.         static void Main()

11.         {

12.             Employee[] employees =

13.             {

14.                 new Employee("Bugs Bunny", 20000),

15.                 new Employee("Elmer Fudd", 10000),

16.                 new Employee("Daffy Duck", 25000),

17.                 new Employee("Wiley Coyote", (decimal)1000000.38),

18.                 new Employee("Foghorn Leghorn", 23000),

19.                 new Employee("RoadRunner'", 50000)};

20.             //实例化

21.             CompareOp employeeCompareOp = new CompareOp(Employee.RhsIsGreater);

22.             BubbleSorter.Sort(employees, employeeCompareOp);

23.  

24.             for (int i = 0; i < employees.Length; i++)

25.                 Console.WriteLine(employees[i].ToString());

26.             Console.ReadLine();

27.         }

28.     }

29.  

30.     class Employee

31.     {

32.         private string name;

33.         private decimal salary;

34.  

35.         public Employee(string name, decimal salary)

36.         {

37.             this.name = name;

38.             this.salary = salary;

39.         }

40.  

41.         public override string ToString()

42.         {

43.             return string.Format(name + ", {0:C}", salary);

44.         }

45.  

46.         //委托调用的方法

47.         public static bool RhsIsGreater(object lhs, object rhs)

48.         {

49.             Employee empLhs = (Employee)lhs;

50.             Employee empRhs = (Employee)rhs;

51.             return (empRhs.salary > empLhs.salary) ? true : false;

52.         }

53.     }

54.  

55.     class BubbleSorter

56.     {

57.         static public void Sort(object[] sortArray, CompareOp gtMethod)

58.         {

59.             for (int i = 0; i < sortArray.Length; i++)

60.             {

61.                 for (int j = i + 1; j < sortArray.Length; j++)

62.                 {

63.                     //使用委托中的方法比较

64.                     if (gtMethod(sortArray[j], sortArray[i]))

65.                     {

66.                         object temp = sortArray[i];

67.                         sortArray[i] = sortArray[j];

68.                         sortArray[j] = temp;

69.                     }

70.                 }

71.             }

72.         }

73.     }

74. }