C#中的委托和事件

C#中的委托和事件

 

前言

 

委托和事件在.NET框架中应用的很广泛,但是楼主因为知识尚浅,用到的不多,但是听前辈们说,这个委托和事件就像两座大山,只要翻过了这两座大山,.NET的知识可能就会一通百通了.最近几天咱们就一起来说说什么是委托,为啥要用委托,事件的由来,.NET框架中的委托和事件委托中方法异常和超时的处理,委托,与异步编程,委托和事件对Observer设计模式的意义.貌似很高大上呢!如果你对一个小白说出这些名词,估计小白会把你当天人来对待了!

 

 

首先理解委托

 

将方法作为方法的参数

 

先不管多么绕口,也别管委托杀个啥玩意,先看下面这两个最简单的方法,他们不过是在屏幕上输出一下:

 

        public void GreetPeople(string name)
        {
            //做某些额外的事情,比如初始化之类的
            EnglishGreetPeople(name);
        }
        public void EnglishGreetPeople(string name)
        {
            Console.WriteLine("hello : "+name);
        }
 

暂且不管这两个方法有没有实际意义,GreetPeople用于向某人问好,当传递代表某人姓名的name参数,比如”Jimmy”进去的时候,在这个方法中,将会调用EnglishGreetProple方法,再次传递name参数,EnglishGreetPeople则用于想屏幕输出”hello : Jimmy”.

 

现在如果这个程序需要进行全球化,比如中国人不明白”hello”是啥意思,怎么办呢?我们需要改程序:

        public void ChineseGreeting(string name)
        {
            Console.WriteLine("你好 : "+name);
        }

这个时候,GreetPeople也需要修改,不然如何判断使用哪个版本的问候方法合适呢?在进行这个之前,只好再定义一个枚举作为判断的依据:

        public enum Language
        {
            English,
            Chinese
        }
        public void GreetPeople(string name,Language lang)
        {
            //做某些额外的事情,比如初始化之类的
            switch (lang)
            {
                case Language.English:
                    EnglishGreetPeople(name);
                    break;
                case Language.Chinese:
                    ChineseGreeting(name);
                    break;                
            }
        }

好了,尽管这样解决了问题,但不用说大家也应该回箱单,这个方法的扩展性很差,世界上有这么多国家,如果这样的话,我们就必须一一的添加各个国家的GreetPeople()方法.

 

在考虑新的解决方案之前,先来看一下GreetPeople的方法签名:

public void GreetPeople(string name,Language lang)

我们仅仅看string name,在这里,string是参数类型,name是参数变量,当赋给name字符串”jimmy”的时候,它就代表”jimmy”这个值;当赋给它”张三”的时候,它又代表”张三”这个值.然后,就可以在方法体内对这个name进行其他操作.

 

再仔细想想,假如GreetPeople()方法可以接受一个参数变量,这个变量可以代表另一个方法,当这个变量被赋值为EnglishGreetPeople的时候,它代表EnglishGreetPeople这个方法;当赋给ChineseGreet的时候,它又代表ChineseGreet这个方法了,我们将这个参数变量命名为MakeGreeting,那么不是可以和给name赋值时一样,在调用GreetPeople()方法的时候,给这个MakGreeting参数也赋上值.然后在方法体内部,也可以像使用别的参数一样使用MakGreeting.但是,由于MakGreeting代表着一个方法,它的使用方式应该和它被赋值的方法(比如ChineseGreet)一样.说了这么多,是不是有点晕?没关系,咱们先看个案例:

 

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
 
namespace 委托和泛型2
{
    public delegate void GreetingDelegate(string name);
    class Program
    {
        static void Main(string[] args)
        {
            GreetPeople("Jimmy",EnglishGreeting);
            GreetPeople("张三",ChineseGreeting);
        }
        public static void ChineseGreeting(string name)
        {
            Console.WriteLine("你好 "+name);
        }
        public static void EnglishGreeting(string name)
        {
            Console.WriteLine("hello "+name);
        }
        private static void GreetPeople(string name, GreetingDelegate MakeGreeting)
        {
            MakeGreeting(name);
        }     
    }
}
 

 

这个案例可能不是很清楚说明我的意思,咱们慢慢道来.这里不再需要枚举了,因为在向MakeGreeting赋值的时候动态的决定使用哪个方法,而在这个两个方法的内部,已经对使用”hello”还是”你好”.

 

本例中的委托的定义:

public delegate void GreetDelegate(string name)

咱们完全可以先和上面EnglishGreeting方法的签名对比一下,除了加入了delegate关键字以外,其余的是不是完全一样?

 

有了委托的定义,就好办了,定义一个委托其实和定义一个int类型的变量一样.

现在对委托简单的说一点,委托其实是一个类,使得可以将方法当做另一个方法的参数来进行传递,这种将方法动态的赋给参数的做法,可以避免在程序中大量使用判断语句,同时是程序具有很好的扩展性.

 

将方法绑定到委托

 

看到这里,是不是还有点迷糊,没关系,慢慢的就明白了,上面的案例你肯定会觉得不就是输出一行语句吗,没啥实际意义,而且这样的代码更不容易让人理解.

 

上面的的例子中,不一定要直接在GreetPeople()方法中name参数赋值,可以像下面这样使用变量:

        static void Main(string[] args)
        {
            string name1, name2;
            name1 = "Jimmy";
            name2 = "张三";
            GreetPeople(name1,EnglishGreeting);
            GreetPeople(name2,ChineseGreeting);
        }

而既然委托GreetingDelegate和类型string的地位一样,都是定义了一种参数类型,那么是不是也可以像下面这样使用委托:

 

        static void Main(string[] args)
        {
            GreetingDelegate delegate1, delegate2;
            delegate1 = EnglishGreeting;
            delegate2 = ChineseGreeting;
            string name1, name2;
            name1 = "Jimmy";
            name2 = "张三";
            GreetPeople(name1,delegate1);
            GreetPeople(name2,delegate2);            
        }

这样也是没问题的,这里要说明的是委托不同于string的一个特性:可以将多个方法赋给同一个委托,或者理解为将多个方法绑定到同一个委托,当调用这个委托的时候,将依次调用其所绑定的方法.想下面这样:

        static void Main(string[] args)
        {
            GreetingDelegate delegate1;
            delegate1 = EnglishGreeting;
            delegate1 += ChineseGreeting;            
            GreetPeople("张三",delegate1);                 
        }
 

看一下输出:

hello 张三
你好 张三

 

实际上,完全可以绕过GreetPeople方法,通过委托来直接调用EnglishGreeting和ChineseGreeting:

            GreetingDelegate delegate1;
            delegate1 = EnglishGreeting;
            delegate1 += ChineseGreeting;
            //将先后调用EnglishGreeting与ChineseGreeting方法
            delegate1("张三");   

说明一下,这在本例中是没问题的,但回头看下上面GreetPeople()的定义,在其中可以在一些对于EnglishGreeting和ChineseGreeting来说都需要进行的工作,为了简便这里省了.

 

注意,这里第一次用的”=”,是赋值的语法;第二次用的是”+=”,是绑定的语法.如果第一次就是用”+=”,将出现”使用了为赋值的局部变量”的编译错误.

 

可以使用下面的代码赖建华这一过程:

        static void Main(string[] args)
        {
            GreetingDelegate delegate1 = new GreetingDelegate(EnglishGreeting);
            delegate1 += ChineseGreeting;
            delegate1("张三");
        }

这样的话,应该能看出这样一条语句和实例化一个类是何其的相似.不禁可以想到:上面第一次绑定委托时不可以使用”+=”的编译错误,或许可以用下面的方法来避免:

        static void Main(string[] args)
        {
            GreetingDelegate delegate1 = new GreetingDelegate();
            delegate1 += EnglishGreeting;
            delegate1 += ChineseGreeting;
            delegate1("张三");
        }

但是实际上,这样会出现编译错误:”GreetingDelegate”方法没有采用”0”个参数的重载.尽管这样的结果会让人觉得有点沮丧,但是编译时的提示”没有0个参数的重载”再次让我们联想到了类的构造函数.

 

既然委托可以绑定一个方法,那么也应该有办法取消对方法的绑定,这个语法是”-=”;

        static void Main(string[] args)
        {
            GreetingDelegate delegate1 = new GreetingDelegate(EnglishGreeting);            
            delegate1 += ChineseGreeting;//给此委托变量再绑定一个方法
            //将先后调用EnglishGreeting和ChineseGreeting方法
            GreetPeople("张三", delegate1);
            Console.WriteLine();
            delegate1 -= EnglishGreeting;//取消对EnglishGreeting方法 的绑定
            GreetPeople("张三",delegate1);
        }

 

小小的总结:

使用委托可以将多个方法绑定到同一个委托变量,当调用此变量时(这里用”调用”这个词,是因为此变量代表一个方法),可以依次调用所有绑定的方法.

 

 

委托与接口

 

在上面的例子中,使用委托定义了方法的前面,从而隔离了变化,此处所指的变化纪伟方法体内的具体实现.注意这里使用了”隔离变化”这个术语,他是一个面向对象设计的原则.实际上,对于上面说的案例,委托所起到的作用和定义一个只含有一个方法的接口完全一样.下面的代码使用接口完成了与使用委托完全相同的功能:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
 
namespace ConsoleApplication1
{
    public interface IGreeting
    {
        void GreetingPeople(string name);
    }
    public class EnglishGreeting : IGreeting
    {
        public void GreetingPeople(string name)
        {
            Console.WriteLine("hello :"+name);
        }
    }
    public class ChineseGreeting : IGreeting
    {
        public void GreetingPeople(string name)
        {
            Console.WriteLine("你好 :"+name);          
        }
    }
    class Program
    {
        private static void GreetPeople(string name, IGreeting makeGreeting)
        {
            makeGreeting.GreetingPeople(name);
        }
        static void Main(string[] args)
        {
            GreetPeople("Jimmy",new EnglishGreeting());
            GreetPeople("张三",new ChineseGreeting());
        }
    }
}
 

可以看到,在使用接口时,代码量大了很多,而且还需要定义实现了接口的类.需要注意的是,在采用接口实现时,利用的是C#的多态能力.尽管他们的结构是一样的,但是过程是不一样的.