关闭

委托和事件

320人阅读 评论(0) 收藏 举报
最近使用的比较多的delegate和event ,在使用之后发现自己只知其皮毛,故重新学习之。在论坛得一较好资料,学习,体会
一、委托的简介
1、委托的声明:
<access modifier> delegate <returnType> HandlerName ([parameters])
例如:
public delegate void PrintHandler(string str);
 
      委托声明定义了一种类型,它用一组特定的参数以及返回类型来封装方法。对于静态方法,委托对象封装要调用的方法。对于实例方法,委托对象同时封装一个实例和该实例上的一个方法。如果您有一个委托对象和一组适当的参数,则可以用这些参数调用该委托。
 
2、委托的使用:
using System;
 
public class MyClass
{
                public static void Main()
                {
                                PrintStr myPrinter = new PrintStr();
                                PrintHandler myHandler = null;
                                myHandler += new PrintHandler(myPrinter.CallPrint); // 将委托链接到方法,来实例化委托
                                if(myHandler!=null)
                                                myHandler("Hello World!");    // 调用委托,相当于匿名调用委托所链接的方法
                                Console.Read();
                }
}
 
public delegate void PrintHandler(string str);    // 声明委托类型
 
public class PrintStr
{              
                public void CallPrint(string input)
                {
                                Console.WriteLine(input);
                }
}
 
 
C#中使用委托方法:
·          创建委托所使用的方法必须和委托声明相一致(参数列表、返回值都一致)
·          利用 +=-=来进行委托的链接、取消链接或直接使用Delegate.CombineDelegate.Remove方法来实现
·          可以使用MulticastDelegate的实例方法GetInvocationList()来获取委托链中所有的委托
·          不能撰写包含 out 参数的委托
 
二、事件的简介
C# 中的“事件”是当对象发生某些事情时,类向该类的客户提供通知的一种方法。
1、事件的声明:
声明的格式为:<access modifier> event <delegate type> EventName
 
        因为使用委托来声明事件,所以在类里声明事件时,首先必须先声明该事件的委托类型<delegate type>(如果尚未声明的话)。在上面我们已经提到过了委托类型的声明,但是在.net  framework下为事件使用的委托类型进行声明时有更严格的规定
1)、事件的委托类型应采用两个参数;
2)、两个参数分别是:指示事件源的“对象源”参数和封装事件的其他任何相关信息的“e”参数;
3)、“e”参数的类型应为EventArgs 类或派生自 EventArgs 类。
如下的定义:
public delegate void PrintHandler(object sender,System.EventArgs e);
 
然后我们才能声明该委托类型的事件
例如:
public event PrintHandler Print;
当事件发生时,将调用其客户提供给它的委托。
 
2、调用事件:
        类 声明了事件以后,可以就像处理所指示的委托类型的字段那样处理该事件。如果没有任何客户将委托与该事件绑定,则该字段将为空;否则该字段引用应在调用该事 件时调用的委托。因此,调用事件时通常先检查是否为空,然后再调用事件。(调用事件,即触发事件,只能从声明该事件的类内进行)
 
if(Print != null)
{
                Print (this,e);
}
 
3、事件绑定:
        从类的外面来看,事件就象类的一个公共成员,通过 类名.事件名 的形式来访问,但是只能对它做绑定和解除绑定的操作,而不能有其他操作。
 
类名. Print += new PrintHandler(绑定的方法名// 将某个方法绑定到Print事件上
类名. Print  -= new PrintHandler(绑定的方法名// 将某个已绑定到Print事件上的方法从Print事件上解除
 
三、委托和事件的使用
委托和事件在用户界面程序里用的比较的多,比如象在winformwebform的用户UI上的button和它的click事件:
// Button1_Click()方法绑定到按钮控件Button1Click事件上
this.Button1.Click += new System.EventHandler(this. Button1_Click);
 
private void Button1_Click(object sender, System.EventArgs e)    // Button1_Click()方法
{
                …… 
}
 
然而除了用户界面程序外,在很多其他地方也用到了事件驱动模式,比如观察者模式(Observer)或发布/订阅(Publish/Subscribe)里:在一个类里发布(Publish)某个可以被触发的事件,而其他的类就可以来订阅(Subscribe)该事件。一旦这个发布者类触发了该事件,那么运行时环境会立刻告知所有订阅了该事件的订阅者类:这个事件发生了!从而各个订阅者类可以作出它们自己的反应(调用相应方法)。
 
我们来举一个生活中的实际例子来说明如何使用委托和事件,以及使用委托和事件所带来的好处:
 
比如说有一个公司(场景),你是老板,手下有主管员工,作为老板你会指派(委托)主管管理员工的工作,如果某个员工玩游戏,则让某个主管从该员工的薪水里扣去500元钱。

这就是现实中的委托。

而在写程序中,假设程序员就是老板,有两个类分别为主管员工,而主管小王员工小张就是两个类的对象实例。员工类一个方法:玩游戏,同时就有一个玩游戏的事件,他一玩游戏就会激发这个事件。而主管类就是负责处理该事件的,他负责把玩游戏的员工薪水扣除500
 
(一)、首先,我们来看看在非委托的情况下比较常见的一种设计方式(当然这不是唯一的方式,也不是最好的方式,但是很常见):
 
using System;
namespace CSharpConsole
{
                public class 场景
                {
                                [STAThread]
                                public static void Main(string[] args)
                                {
                                                Console.WriteLine("场景开始了.");
                                                // 生成主管类的对象实例小王
                                                主管小王 = new 主管();
                                                // 生成员工类的对象实例小张,指定他的主管
                                                员工小张 = new 员工(小王);
                               
                                                Console.WriteLine("该员工本有的薪水:" + 小张.薪水.ToString());
           
                                                // 员工开始玩游戏
                                                小张.玩游戏();
 
                                                Console.WriteLine("现在该员工还剩下:" +小张.薪水.ToString());
                               
                                                Console.WriteLine("场景结束");
                                                Console.ReadLine();
                                }
                }
 
 
 
                // 负责扣钱的人----主管
                public class 主管
                {
                                public 主管()
                                {
                                                Console.WriteLine("生成主管");
                                }
 
                                public void 薪水(员工 employee)
                                {
                                                Console.WriteLine("主管:好小子,上班时间胆敢玩游戏");
                                                Console.WriteLine("主管:看看你小子有多少薪水");
                               
                                                Console.WriteLine("开始扣薪水...");
                                                System.Threading.Thread.Sleep(1000);
 
                                                employee.薪水 = employee.薪水 - 500;
 
                                                Console.WriteLine("扣薪水执行完毕.");          
                                }
                }
 
                // 如果玩游戏,则会引发事件
                public class 员工
                {
                                // 保存员工的薪水
                                private int m_Money;
                                // 保存该员工的主管
                                private 主管 m_Manager;
 
                                public 员工(主管 manager)
                                {
                                                Console.WriteLine("生成员工.");
                                                m_Manager = manager;  // 通过构造函数,初始化员工的主管。
                                                m_Money = 1000; // 通过构造函数,初始化员工的薪水。
                                }
 
                                public int 薪水 // 此属性可以操作员工的薪水
                                {
                                                get
                                                {
                                                                return m_Money;
                                                }
                                                set
                                                {
                                                                m_Money = value;
                                                }
                                }
 
                                public void 玩游戏()
                                {
                                                Console.WriteLine("员工开始玩游戏了..");
                                                Console.WriteLine("员工:CS真好玩,哈哈哈!我玩...");
                                                System.Threading.Thread.Sleep(1000);
                                               
                                                m_Manager. 薪水(this);
                                }
                }
}

这种方法所带来的问题:员工类和主管类的耦合性太高
1   在客户程序里必须先创建了主管类之后才能生成员工类,如果在不需要主管类对象而只需员工类对象的地方,为了创建所需的员工类对象实例,你也不得不去先创建一个主管类的对象实例;
2   如果场景剧本(即客户程序需求)发生了变化
1)、现在要让一个新的角色(一个新的类),如保安来代替主管,负责在员工玩游戏时扣员工薪水,那么我们不得不去修改员工类,或许还需要修改主管类;
2)、如果场景剧本增加新的需求,要求员工在玩游戏后,不但要扣薪水,还要在绩效上扣分,那么我们也不得不修改员工类

二)、利用委托的实现:
 
下面有个例子:在C# 控制台应用程序编辑运行成功:
 
using System;
namespace CSharpConsole
{
                // 定义委托
                public delegate void PlayGameHandler(object sender,System.EventArgs e);
 
                // 负责扣钱的人----主管
                public class 主管
                {
                                public 主管()
                                {
                                                Console.WriteLine("生成主管");
                                }
 
                                public void 薪水(object sender,EventArgs e)
                                {
                                                Console.WriteLine("主管:好小子,上班时间胆敢玩游戏");
                                                Console.WriteLine("主管:看看你小子有多少薪水");
               
                                                员工 employee = (员工)sender;
               
                                                Console.WriteLine("开始扣薪水...");
                                                System.Threading.Thread.Sleep(1000);
                                                employee.薪水 = employee.薪水 - 500;
                                                Console.WriteLine("扣薪水执行完毕.");          
                                }
                }
 
                // 如果玩游戏,则会引发事件
                public class 员工
                {
                                // 先定义一个事件,这个事件表示员工在玩游戏。
                                public event PlayGameHandler PlayGame;
                                // 保存员工薪水的变量
                                private int m_Money;
 
                                public 员工()
                                {
                                                Console.WriteLine("生成员工.");
                                                m_Money = 1000; // 构造函数,初始化员工的薪水。
                                }
 
                                public int 薪水 // 此属性可以操作员工的薪水
                                {
                                                get
                                                {
                                                                return m_Money;
                                                }
                                                set
                                                {
                                                                m_Money = value;
                                                }
                                }
 
                                public void 玩游戏()
                                {
                                                Console.WriteLine("员工开始玩游戏了..");
                                                Console.WriteLine("员工:CS真好玩,哈哈哈!我玩...");
                                                System.Threading.Thread.Sleep(1000);
                                                System.EventArgs e = new EventArgs();
 
                                                OnPlayGame(e);
                                }
 
                                protected virtual void OnPlayGame(EventArgs e)
                                {
                                                if(PlayGame != null)
                                                {
                                                                PlayGame(this,e);
                                                }
                                }
                }
 
                public class 场景
                {
                                [STAThread]
                                public static void Main(string[] args)
                                {
                                                Console.WriteLine("场景开始了.");
                                                // 生成主管类的对象实例小王
                                                主管小王 = new 主管();
                                                // 生成员工类的对象实例小张
                                                员工小张 = new 员工();
 
                                                // 设下委托,指定监视
                                                小张.PlayGame += new PlayGameHandler(小王. 扣薪水);
                               
                                                Console.WriteLine("该员工本有的薪水:" + 小张.薪水.ToString());
            
                                                // 员工开始玩游戏
                                                小张.玩游戏();
 
                                                Console.WriteLine("现在该员工还剩下:" +小张.薪水.ToString());
                               
                                                Console.WriteLine("场景结束");
                                                Console.ReadLine();
                                }
                }
}
 
对于前面提出的问题:
1   解耦了主管类员工类之间的必然联系,可以单独创建员工类对象实例,而不用管是否有主管类对象实例的存在;
2   在客户程序需求变化时:
1)、我们只需修改客户程序,即上面例子里的class 场景,将委托改为如下:
 
保安 = new 保安();
小张.PlayGame += new PlayGameHandler(. 扣薪水);
 
即可实现由保安来负责扣薪水的需求变化,而不用动员工类
2)、我们只需修改客户程序,即上面例子里的class 场景,添加一个如下的委托:
 
                小张.PlayGame += new PlayGameHandler(某某. 扣绩效分);
 
这个“某某”可以是主管,也可以是其他新的角色(新的类),只需要在“某某”对应的类里定义扣绩效分的动作即可,而不用动员工类
 
四、总结
      当然,不使用委托和事件我们仍然可以设计出解耦的类,然而却会增加很多的类、接口以及关联等等,增加了代码量和程序的逻辑复杂性,而在.net里利用委托和事件我们只需少的多的代码来实现。
 
 委托和事件的使用有如下几个要素:

1
、激发事件的对象-----就是员工小张
2
、处理对象事件的对象-----就是主管小王
3
、定义委托,就是你让主管小王监视员工小张

如果这三个要素都满足的话,则你就写出了一个完整事件的处理。
/////////////////////////////////////////////////////////////////////////////////////////
体会:
1
在项目开发中遇到从不是创建UI控件的线程访问该控件,更新其内容。查找到2种方法。一种是仅仅使用delagate.如下例子:
        //更新ListBox信息
        public delegate void UpdateListBoxCallback();
 
        //更新用户列表
        private void UpdateClientListControl()
        {
            if (InvokeRequired)
            {
listBoxClientList.BeginInvoke(new UpdateListBoxCallback(UpdateClientList), null);
            }
            else
            {
                //创建该控件的主线程直接更新信息列表
                UpdateClientList();
            }
        }
//更新代码在这里
        public void UpdateClientList()
        {
            listBoxClientList.Items.Clear();
            for (int index = 0; index < WorkerSocketList.Count; index++)
            {
                string clientKey = Convert.ToString(index + 1);
                Socket workerSocket = (Socket)WorkerSocketList[index];
                if (workerSocket != null)
                {
                    //将连接着服务器的客户添加到客户列表中
                    if (workerSocket.Connected)
                    {
                        listBoxClientList.Items.Add(clientKey);
                    }
                }
            }
        }
 
2.后来又使用了event的方法。发现使用event的方法在刷新UI的效率和资源占用上都优于上面的方法1
还是拿例子说话:
//代码来自 自己的 远程唤醒(WOL)程序
//事件一
//声名
        public delegate void ShowMacInList(ListBox listBox, object obj);
        public event ShowMacInList ShowAllRresultInList;
//链接
this.ShowAllRresultInList += new ShowMacInList(RWOL_ShowAllRresultInList);
//
        void RWOL_ShowAllRresultInList(ListBox listBox, object obj)
        {
            try
            {
                this.BeginInvoke(new ShowMacInList(ShowResult),
                                new object[] { listBox, obj });
            }
            catch
            {
          
//在线程中使用
   ShowAllRresultInList(listBoxScanResult, ScanResultMessage[count]);
 
//事件二
        public delegate void UpdateButton(Button button, bool enable,string text);
        public event UpdateButton UpdateFormButton;
 
this.UpdateFormButton += new UpdateButton(RWOL_UpdateFormButton);
 
        void RWOL_UpdateFormButton(Button button, bool enable, string text)
        {
            try
            {
                this.BeginInvoke(new UpdateButton(UpdateButtons),
                                new object[] { button, enable,text });
            }
            catch
            {
            }
        }
//线程中使用
UpdateFormButton(buttonScan, false, "");
 
这里事件二和
        因为使用委托来声明事件,所以在类里声明事件时,首先必须先声明该事件的委托类型<delegate type>(如果尚未声明的话)。在上面我们已经提到过了委托类型的声明,但是在.net  framework下为事件使用的委托类型进行声明时有更严格的规定
1)、事件的委托类型应采用两个参数;
2)、两个参数分别是:指示事件源的“对象源”参数和封装事件的其他任何相关信息的“e”参数;
3)、“e”参数的类型应为EventArgs 类或派生自 EventArgs 类。
规定的2个参数并不相符。但是细细想想,原理是一样地的,只是这里把发送者具体化了,把参数也具体化了
 
0
0

查看评论
* 以上用户言论只代表其个人观点,不代表CSDN网站的观点或立场
    个人资料
    • 访问:60657次
    • 积分:1291
    • 等级:
    • 排名:千里之外
    • 原创:66篇
    • 转载:7篇
    • 译文:0篇
    • 评论:12条
    优化蜘蛛引导