委托的使用 - 浅谈
一,声明委托
对于委托,定义它就是要告诉编译器,这种类型的委托表示哪种类型的方法.然后,必须创建该委托的一个或多个委托实例,编译器将在后台创建表示该委托的一个类.
因为定义委托基本上是定义一个新类,所以可以在定义类的任何相同地方定义委托.
在术语方面,和"类,对象"不同."类"表示的是较为广义的定义,"对象"表示类的实例.但是委托只有一个术语,在创建委托实例时,所创建的委托的实例仍然称为委托.
如下显示委托的声明方式:
|
1
2
|
//声明委托.private delegate string GetAString(); |
二,使用委托
如下例子:
1 int x = 5; 2 //通过委托的方式. 3 GetAString stringMethod = new GetAString(x.ToString); 4 Console.WriteLine(stringMethod());
也可以使用委托推断,只需将地址传递给委托类型的变量(在后台,C#编译器会做同样的处理,即会在后台创建一个委托实例 "newGetAString(x.ToString)"):
1 //使用委托推断,只需将地址传递给委托实例. 2 GetAString secondMethod = x.ToString;
实际上,调用委托时,给委托实例提供圆括号与调用委托的Invoke()方法,是完全相同的:
1 Console.WriteLine(stringMethod()); //委托方式1(使用圆括号的方式). 2 Console.WriteLine(stringMethod.Invoke()); //委托方式2(使用调用Invoke()方法的方式).
原因是对于委托变量stringMethod,C#编译器会调用stringMethod.Invoke()代替stringMethod().
值得注意的是,在给一个委托类型的变量赋值的时候,方法的名称不能带有"()"括号,上述例子,调用 x.ToString()方法,会返回一个不能赋予委托变量的字符串对象(而不是方法的地址).
委托的一个特征是,它们是类型安全的,可以确定被调用的方法的签名是正确的.但是委托不关心在什么类型上调用改方法,甚至不考虑方法是静态的,还是实例方法.
如下例子演示了委托可以使用实例方法,也可以使用静态方法:
Currency结构的声明:
1 namespace Wrox.ProCSharp.Delegates {
2 struct Currency {
3 public uint Dollars;
4 public ushort Cents;
5
6 public Currency(uint dollars, ushort cents) {
7 this.Dollars = dollars;
8 this.Cents = cents;
9 }
10
11 public override string ToString() {
12 return string.Format("${0}.{1,-2:00}", Dollars, Cents);
13 }
14
15 public static string GetCurrencyUnit() {
16 return "Dollar";
17 }
18
19 public static explicit operator Currency(float value) {
20 checked {
21 uint dollars = (uint)value;
22 ushort cents = (ushort)((value - dollars) * 100);
23 return new Currency(dollars, cents);
24 }
25 }
26
27 public static implicit operator float(Currency value) {
28 return value.Dollars + (value.Cents / 100.0f);
29 }
30
31 public static implicit operator Currency(uint value) {
32 return new Currency(value, 0);
33 }
34
35 public static implicit operator uint(Currency value) {
36 return value.Dollars;
37 }
38 }
39
40 }
在住函数中调用:
1 using System;
2
3 namespace Wrox.ProCSharp.Delegates
4 {
5 class Program
6 {
7 private delegate string GetAString();
8
9 static void Main()
10 {
11 int x = 40;
12 GetAString firstStringMethod = x.ToString;
13 Console.WriteLine("String is {0}", firstStringMethod());
14
15 Currency balance = new Currency(34, 50);
16
17 // firstStringMethod references an instance method
18 firstStringMethod = balance.ToString;
19 Console.WriteLine("String is {0}", firstStringMethod());
20
21 // firstStringMethod references a static method
22 firstStringMethod = new GetAString(Currency.GetCurrencyUnit);
23 Console.WriteLine("String is {0}", firstStringMethod());
24
25 }
26 }
27 }
输出:
String is 40 String is $34.50 String is Dollar
再来看一个委托使用:
定义操作的方法的类:
1 namespace SimpleDelegates_Demo {
2 class MathOperations {
3 public static double MultiplyByTwo(double value) {
4 return value * 2;
5 }
6
7 public static double Square(double value) {
8 return value * value;
9 }
10 }
11
12 }
在主函数中使用:
1 using System;
2
3 namespace SimpleDelegates_Demo {
4 delegate double Operate(double input);
5 class Program {
6 static void Main(string[] args) {
7 Operate[] actions = { MathOperations.MultiplyByTwo, MathOperations.Square };
8 //遍历每个委托实例.
9 foreach (Operate action in actions) {
10 ProcessAndDisplayResult(action, 2);
11 ProcessAndDisplayResult(action, 2.5);
12 ProcessAndDisplayResult(action, 5.2);
13 Console.WriteLine();
14 }
15 }
16
17 static void ProcessAndDisplayResult(Operate action, double inputVal) {
18 Console.WriteLine("Input is [{0}],Result is [{1}]", inputVal, action(inputVal));
19 }
20 }
21 }
output:
1 Input is [2],Result is [4] 2 Input is [2.5],Result is [5] 3 Input is [5.2],Result is [10.4] 4 5 Input is [2],Result is [4] 6 Input is [2.5],Result is [6.25] 7 Input is [5.2],Result is [27.04]
在这个例子中,我们将委托实例封装到一个数组中,然后遍历每个委托实例,然后传递遍历到特定的方法中调用,这说明使用委托的一种方式 - 即把方法组合到一个数组中来使用,这样就可以在循环中调用不同的方法了.
值得注意的是,这里 ProcessAndDisplayResult(Operate action, double inputVal) 不是多余的.
当我们在主函数的第10~12行中传递action委托实例到 ProcessAndDisplayResult(Operate action, double inputVal) 方法的时候,action就是委托表示的方法.
而在ProcessAndDisplayResult(Operate action, double inputVal)方法体中,也就是上面Program类中的第18行中的action(inputVal),或action(2)实际上调用这个方法,参数放在圆括号中.也就是说,action(inputVal),或action(2)实际上是调用action委托实例封装的方法.
