托付
1
2
3
4
5
6
7
8
9
|
public void GreetPeople( string name) { // 做某些额外的事情。比方初始化之类。此处略 EnglishGreeting(name); } public void EnglishGreeting( string name) { Console.WriteLine( "Morning, " + name); } |
1
2
3
4
|
public void ChineseGreeting( string name) { Console.WriteLine( "早上好, " + name); } |
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
|
public enum Language { English, Chinese } public void GreetPeople( string name, Language lang) { //做某些额外的事情,比方初始化之类,此处略 switch (lang) { case Language.English: EnglishGreeting(name); break ; case Language.Chinese: ChineseGreeting(name); break ; } } |
然后,我们能够在方法体内对这个name进行其它操作。哎。这简直是废话么,刚学程序就知道了。
我们将这个參数变量命名为 MakeGreeting,那么不是能够如同给name赋值时一样。在调用 GreetPeople()方法的时候。给这个MakeGreeting 參数也赋上值么(ChineseGreeting或者EnglishGreeting等)?然后,我们在方法体内。也能够像使用别的參数一样使用MakeGreeting。
可是,因为MakeGreeting代表着一个方法。它的使用方式应该和它被赋的方法(比方ChineseGreeting)是一样的。比方:
1
2
3
4
|
public void GreetPeople( string name, *** MakeGreeting) { MakeGreeting(name); } |
1
2
|
public void EnglishGreeting( string name) public void ChineseGreeting( string name) |
1
2
3
4
|
public void GreetPeople( string name, GreetingDelegate MakeGreeting) { MakeGreeting(name); } |
可是托付的声明方式和类却全然不同,这是怎么一回事?实际上。托付在编译的时候确实会编译成类。由于Delegate是一个类。所以在不论什么能够声明类的地方都能够声明托付。很多其它的内容将在以下讲述。请看看这个范例的完整代码:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
|
using System; using System.Collections.Generic; using System.Text; namespace Delegate { //定义托付。它定义了能够代表的方法的类型 public delegate void GreetingDelegate( string name); class Program { private static void EnglishGreeting( string name) { Console.WriteLine( "Morning, " + name); } private static void ChineseGreeting( string name) { Console.WriteLine( "早上好, " + name); } //注意此方法。它接受一个GreetingDelegate类型的參数。该參数是返回值为空,參数为string类型的方法 private static void GreetPeople( string name, GreetingDelegate MakeGreeting) { MakeGreeting(name); } static void Main( string [] args) { GreetPeople( "Jimmy Zhang" , EnglishGreeting); GreetPeople( "张子阳" , ChineseGreeting); Console.ReadKey(); } } } |
托付
编辑
1
2
3
4
5
6
7
8
|
static void Main( string [] args) { string name1, name2; name1 = "Jimmy Zhang" ; name2 = "张子阳" ; GreetPeople(name1, EnglishGreeting); GreetPeople(name2, ChineseGreeting); Console.ReadKey(); } |
1
2
3
4
5
6
7
8
|
static void Main( string [] args) { GreetingDelegate delegate1, delegate2; delegate1 = EnglishGreeting; delegate2 = ChineseGreeting; GreetPeople( "Jimmy Zhang" , delegate1); GreetPeople( "张子阳" , delegate2); Console.ReadKey(); } |
在这个样例中,语法例如以下:
1
2
3
4
5
6
7
8
|
static void Main( string [] args) { GreetingDelegate delegate1; delegate1 = EnglishGreeting; // 先给托付类型的变量赋值 delegate1 += ChineseGreeting; // 给此托付变量再绑定一个方法 // 将先后调用 EnglishGreeting 与 ChineseGreeting 方法 GreetPeople( "Jimmy Zhang" , delegate1); Console.ReadKey(); } |
1
2
3
4
5
6
7
8
|
static void Main( string [] args) { GreetingDelegate delegate1; delegate1 = EnglishGreeting; // 先给托付类型的变量赋值 delegate1 += ChineseGreeting; // 给此托付变量再绑定一个方法 // 将先后调用 EnglishGreeting 与 ChineseGreeting 方法 delegate1 ( "Jimmy Zhang" ); Console.ReadKey(); } |
虽然这种结果让我们认为有点沮丧,可是编译的提示:“没有0个參数的重载”再次让我们联想到了类的构造函数。
我知道你一定按捺不住想探个到底,但在此之前。我们须要先把基础知识和应用介绍完。
1
2
3
4
5
6
7
8
9
10
11
|
static void Main( string [] args) { GreetingDelegate delegate1 = new GreetingDelegate(EnglishGreeting); delegate1 += ChineseGreeting; // 给此托付变量再绑定一个方法 // 将先后调用 EnglishGreeting 与 ChineseGreeting 方法 GreetPeople( "Jimmy Zhang" , delegate1); Console.WriteLine(); delegate1 -= EnglishGreeting; //取消对EnglishGreeting方法的绑定 // 将仅调用 ChineseGreeting GreetPeople( "张子阳" , delegate1); Console.ReadKey(); } |
由来
编辑
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
|
namespace Delegate { //定义托付,它定义了能够代表的方法的类型 public delegate void GreetingDelegate( string name); //新建的GreetingManager类 public class GreetingManager{ public void GreetPeople( string name, GreetingDelegate MakeGreeting) { MakeGreeting(name); } } class Program { private static void EnglishGreeting( string name) { Console.WriteLine( "Morning, " + name); } private static void ChineseGreeting( string name) { Console.WriteLine( "早上好, " + name); } static void Main( string [] args) { // ... ... } } } |
1
2
3
4
5
|
static void Main( string [] args) { GreetingManager gm = new GreetingManager(); gm.GreetPeople( "Jimmy Zhang" , EnglishGreeting); gm.GreetPeople( "张子阳" , ChineseGreeting); } |
程序一如预料地那样输出了:
1
2
3
4
5
6
7
|
static void Main( string [] args) { GreetingManager gm = new GreetingManager(); GreetingDelegate delegate1; delegate1 = EnglishGreeting; delegate1 += ChineseGreeting; gm.GreetPeople( "Jimmy Zhang" , delegate1); } |
1
2
3
4
5
6
7
|
public class GreetingManager{ //在GreetingManager类的内部声明delegate1变量 public GreetingDelegate delegate1; public void GreetPeople( string name, GreetingDelegate MakeGreeting) { MakeGreeting(name); } } |
1
2
3
4
5
6
|
static void Main( string [] args) { GreetingManager gm = new GreetingManager(); gm.delegate1 = EnglishGreeting; gm.delegate1 += ChineseGreeting; gm.GreetPeople( "Jimmy Zhang" , gm.delegate1); } |
1
2
3
4
5
6
7
8
9
|
public class GreetingManager{ //在GreetingManager类的内部声明delegate1变量 public GreetingDelegate delegate1; public void GreetPeople( string name) { if (delegate1!= null ){ //假设有方法注冊托付变量 delegate1(name); //通过托付调用方法 } } } |
1
2
3
4
5
6
|
static void Main( string [] args) { GreetingManager gm = new GreetingManager(); gm.delegate1 = EnglishGreeting; gm.delegate1 += ChineseGreeting; gm.GreetPeople( "Jimmy Zhang" ); //注意,这次不须要再传递 delegate1变量 } |
在类的外部,注冊“+=”和注销“-=”的訪问限定符与你在声明事件时使用的訪问符同样。
1
2
3
4
5
6
7
|
public class GreetingManager{ //这一次我们在这里声明一个事件 public event GreetingDelegate MakeGreet; public void GreetPeople( string name) { MakeGreet(name); } } |
1
2
3
4
5
6
|
static void Main( string [] args) { GreetingManager gm = new GreetingManager(); gm.MakeGreet = EnglishGreeting; // 编译错误1 gm.MakeGreet += ChineseGreeting; gm.GreetPeople( "Jimmy Zhang" ); } |
编译代码
编辑
1
2
3
4
5
6
7
8
9
|
private GreetingDelegate MakeGreet; //对事件的声明 实际是 声明一个私有的托付变量 [MethodImpl(MethodImplOptions.Synchronized)] public void add_MakeGreet(GreetingDelegate value){ this .MakeGreet = (GreetingDelegate) Delegate.Combine( this .MakeGreet, value); } [MethodImpl(MethodImplOptions.Synchronized)] public void remove_MakeGreet(GreetingDelegate value){ this .MakeGreet = (GreetingDelegate) Delegate.Remove( this .MakeGreet, value); } |
另外。它还有两个方法,各自是add_MakeGreet和remove_MakeGreet。这两个方法分别用于注冊托付类型的方法和取消注冊。实际上也就是: “+= ”相应 add_MakeGreet。“-=”相应remove_MakeGreet。而这两个方法的訪问限制取决于声明事件时的訪问限制符。
1
2
3
4
5
6
7
8
|
public delegate void GreetingDelegate( string name); 当编译器遇到这段代码的时候,会生成以下这样一个完整的类: public sealed class GreetingDelegate:System.MulticastDelegate{ public GreetingDelegate( object @ object , IntPtr method); public virtual IAsyncResult BeginInvoke( string name, AsyncCallback callback, object @ object ); public virtual void EndInvoke(IAsyncResult result); public virtual void Invoke( string name); } |
设计模式
编辑
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
|
using System; using System.Collections.Generic; using System.Text; namespace Delegate { // 热水器 public class Heater { private int temperature; public delegate void BoilHandler( int param); //声明托付 public event BoilHandler BoilEvent; //声明事件 // 烧水 public void BoilWater() { for ( int i = 0; i <= 100; i++) { temperature = i; if (temperature > 95) { if (BoilEvent != null ) { //假设有对象注冊 BoilEvent(temperature); //调用全部注冊对象的方法 } } } } } // 警报器 public class Alarm { public void MakeAlert( int param) { Console.WriteLine( "Alarm:嘀嘀嘀。水已经 {0} 度了:" , param); } } // 显示器 public class Display { public static void ShowMsg( int param) { //静态方法 Console.WriteLine( "Display:水快烧开了,当前温度:{0}度。
} } class Program { static void Main() { Heater heater = new Heater(); Alarm alarm = new Alarm(); heater.BoilEvent += alarm.MakeAlert; //注冊方法 heater.BoilEvent += ( new Alarm()).MakeAlert; //给匿名对象注冊方法 heater.BoilEvent += Display.ShowMsg; //注冊静态方法 heater.BoilWater(); //烧水。会自己主动调用注冊过对象的方法 } } } |
范例说明
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
|
namespace Delegate { class Heater { private int temperature; // 水温 // 烧水 public void BoilWater() { for ( int i = 0; i <= 100; i++) { temperature = i; if (temperature > 95) { MakeAlert(temperature); ShowMsg(temperature); } } } // 发出语音警报 private void MakeAlert( int param) { Console.WriteLine( "Alarm:嘀嘀嘀,水已经 {0} 度了:" , param); } // 显示水温 private void ShowMsg( int param) { Console.WriteLine( "Display:水快开了,当前温度:{0}度。
} } class Program { static void Main() { Heater ht = new Heater(); ht.BoilWater(); } } } |
模式简单介绍
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
|
// 热水器 public class Heater { private int temperature; // 烧水 private void BoilWater() { for ( int i = 0; i <= 100; i++) { temperature = i; } } } // 警报器 public class Alarm{ private void MakeAlert( int param) { Console.WriteLine( "Alarm:嘀嘀嘀,水已经 {0} 度了:" , param); } } // 显示器 public class Display{ private void ShowMsg( int param) { Console.WriteLine( "Display:水已烧开,当前温度:{0}度。
} } |
Observer:监视者,它监视Subject,当Subject中的某件事发生的时候。会告知Observer,而Observer则会採取对应的行动。
在本范例中,Observer有警报器和显示器,它们採取的行动各自是发出警报和显示水温。 在本例中。事情发生的顺序应该是这种:
类似这种样例是非常多的。GOF对它进行了抽象,称为Observer设计模式:Observer设计模式是为了定义对象间的一种一对多的依赖关系,以便于当一个对象的状态改变时。其它依赖于它的对象会被自己主动告知并更新。Observer模式是一种松耦合的设计模式。
托付事件
编辑托付的原型定义:有一个void返回值,并接受两个输入參数:一个Object 类型,一个 EventArgs类型(或继承自EventArgs)。 事件的命名为 托付去掉 EventHandler之后剩余的部分。
继承自EventArgs的类型应该以EventArgs结尾。 再做一下说明:
回调函数(比方Alarm的MakeAlert)能够通过它訪问触发事件的对象(Heater)。 EventArgs 对象包括了Observer所感兴趣的数据,在本例中是temperature。上面这些事实上不不过为了编码规范而已。这样也使得程序有更大的灵活性。比方说,假设我们不光想获得热水器的温度,还想在Observer端(警报器或者显示器)方法中获得它的生产日期、型号、价格,那么托付和方法的声明都会变得非常麻烦。而假设我们将热水器的引用传给警报器的方法。就能够在方法中直接訪问热水器了。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
|
using System; using System.Collections.Generic; using System.Text; namespace Delegate { // 热水器 public class Heater { private int temperature; public string type = "RealFire 001" ; // 加入型号作为演示 public string area = "China Xi'an" ; // 加入产地作为演示 //声明托付 public delegate void BoiledEventHandler(Object sender, BoiledEventArgs e); public event BoiledEventHandler Boiled; //声明事件 // 定义BoiledEventArgs类。传递给Observer所感兴趣的信息 //继承EventArgs public class BoiledEventArgs : EventArgs { public readonly int temperature; // public BoiledEventArgs( int temperature) { this .temperature = temperature; } } |
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
|
// 能够供继承自 Heater 的类重写,以便继承类拒绝其它对象对它的监视 protected virtual void OnBoiled(BoiledEventArgs e) { if (Boiled != null ) { // 假设有对象注冊 Boiled( this , e); // 调用全部注冊对象的方法 } } // 烧水。 public void BoilWater() { for ( int i = 0; i <= 100; i++) { temperature = i; if (temperature > 95) { //建立BoiledEventArgs 对象。 BoiledEventArgs e = new BoiledEventArgs(temperature); OnBoiled(e); // 调用 OnBoiled方法 } } } } // 警报器 public class Alarm { public void MakeAlert(Object sender, Heater.BoiledEventArgs e) { Heater heater = (Heater)sender; //这里是不是非常熟悉呢? //訪问 sender 中的公共字段 Console.WriteLine( "Alarm:{0} - {1}: " , heater.area, heater.type); Console.WriteLine( "Alarm: 嘀嘀嘀。水已经 {0} 度了:" , e.temperature); Console.WriteLine(); } } // 显示器 public class Display { public static void ShowMsg(Object sender, Heater.BoiledEventArgs e) { //静态方法 Heater heater = (Heater)sender; Console.WriteLine( "Display:{0} - {1}: " , heater.area, heater.type); Console.WriteLine( "Display:水快烧开了。当前温度:{0}度。
Console.WriteLine(); } } class Program { static void Main() { Heater heater = new Heater(); Alarm alarm = new Alarm(); heater.Boiled += alarm.MakeAlert; //注冊方法 heater.Boiled += ( new Alarm()).MakeAlert; //给匿名对象注冊方法 heater.Boiled += new Heater.BoiledEventHandler(alarm.MakeAlert); //也能够这么注冊 heater.Boiled += Display.ShowMsg; //注冊静态方法 heater.BoilWater(); //烧水,会自己主动调用注冊过对象的方法 } } } |
posted on 2017-08-21 12:54 cynchanpin 阅读(270) 评论(0) 编辑 收藏 举报