c#委托事件及其讲解

一定要标明出处,波哥的文章。所有文章都值得一看。这篇是摘抄的大白话之C#事件讲解。委托

http://www.cnblogs.com/wudiwushen/archive/2010/04/20/1703368.html

例子是小明委托小明去买电影票

c#语法如下:

public delegate void BugTicketEventHandler();

delegate 是关键词,【注:EventHandler是一个声明委托的微软C#的命名标准,我的习惯是标准就要第一时间说,也就这个命名习惯要第一时间养成】

完了,这就是委托,就这么简单,看看和我们一般的方法有什么区别呢?

public void BuyTicket()
{
    方法体
}

区别知道了吧,在现实生活中,委托只是个命令,做事情是别人,而在程序世界里委托只是存储了各个方法的地址,而他自己也是什么也不做的。

那我们就把刚才那个,小明委托小张去买车票的现实生活场景,怎么在程序世界里体现呢?

//小张类
    public class MrZhang
    {
        //其实买车票的悲情人物是小张
        public static void BuyTicket()
        {
            Console.WriteLine("NND,每次都让我去买票,坏人呀!");
        }
    }

    //小明类
    class MrMing
    {
        //声明一个委托,其实就是个“命令”
        public delegate void BugTicketEventHandler();

        public static void Main(string[] args)
        {
            //这里就是具体阐述这个命令是干什么的,本例是MrZhang.BuyTicket“小张买车票”
            BugTicketEventHandler myDelegate = new BugTicketEventHandler(MrZhang.BuyTicket);

            //这时候委托被附上了具体的方法
            myDelegate();
            Console.ReadKey();
        }
    } 

BugTicketEventHandler myDelegate = new BugTicketEventHandler(MrZhang.BuyTicket);

这是委托的声明方法, BugTicketEventHandler(委托的方法);委托的方法必须要加上,因为委托的构造函数是不为空的。

注:委托的参数和返回类型,都要和你要具体委托的方法要一致,例:

public delegate void BugTicketEventHandler();

public static void BuyTicket()
  {
   Console.WriteLine("NND,每次都让我去买票,坏人呀!");
  }

同学们,看到这里可以先消化消化,休息一下,我们简单的讲一下委托链的概念:

其实委托链也是相当的简单,在现实生活中,小明叫小张买完车票之后,可能接着又让他带张电影票,

而我们程序世界里的表述为:

//小张类
    public class MrZhang
    {
        //其实买车票的悲情人物是小张
        public static void BuyTicket()
        {
            Console.WriteLine("NND,每次都让我去买票,鸡人呀!");
        }

        public static void BuyMovieTicket()
        {
            Console.WriteLine("我去,自己泡妞,还要让我带电影票!");
        }
    }

    //小明类
    class MrMing
    {
        //声明一个委托,其实就是个“命令”
        public delegate void BugTicketEventHandler();

        public static void Main(string[] args)
        {
            //这里就是具体阐述这个命令是干什么的,本例是MrZhang.BuyTicket“小张买车票”
            BugTicketEventHandler myDelegate = new BugTicketEventHandler(MrZhang.BuyTicket);

            myDelegate += MrZhang.BuyMovieTicket;
            //这时候委托被附上了具体的方法
            myDelegate();
            Console.ReadKey();
        }
    }

其实,我们只是在程序中加了 myDelegate += MrZhang.BuyMovieTicket;

这时这个委托就相当于要做2件事情,先是买车票,再是买电影票拉!
      好了,关于大白话的委托就介绍到这里了,是不是并没有大家想的这么可怕呢,在下一回我们就接着大白话的EVENT的讲解。

依然抛链接   原文出处  波哥  http://www.cnblogs.com/wudiwushen/archive/2010/04/20/1703763.html

什么是事件?EVENT?点击事件?加载事件?一连串的模糊的概念冲击着我们弱小的脑袋

那我们首先来看一下比较正统的感念吧:

事件是类在发生其关注的事情时用来提供通知的一种方式。

事件的发生一般都牵扯2个角色

事件发行者(Publisher):一个事件的发行者,也称作是发送者(sender),其实就是个对象,这个对象会自行维护本身的状态信息,当本身状态信息变动时,便触发一个事件,并通知说有的事件订阅者。

事件订阅者(Subscriber):对事件感兴趣的对象,也称为Receiver,可以注册感兴趣的事件,在事件发行者触发一个事件后,会自动执行这段代码。

为了更好的让大家理解上面的概念,我先什么都不讲,我们先来看一段简单的代码:

 //发布者(Publiser)
    public class Publisher
    {
        //声明一个出版的委托
        public delegate void PublishEventHander();
        //在委托的机制下我们建立以个出版事件
        public event PublishEventHander OnPublish;
        //事件必须要在方法里去触发,出版社发布新书方法
        public void issue()
        {
            //如果有人注册了这个事件,也就是这个事件不是空
            if (OnPublish != null)
            {
                Console.WriteLine("最新一期的《火影忍者》今天出版哦!");
                OnPublish();
            }
        }
    }

    //Subscriber 订阅者,无赖小明
    public class MrMing
    {
        //对事件感兴趣的事情,这里指对出版社的书感兴趣
        public static void Receive()
        {
            Console.WriteLine("嘎嘎,我已经收到最新一期的《火影忍者》啦!!");
        }
    }

    //Subscriber 订阅者,悲情人物小张
    public class MrZhang
    {
        //对事件感兴趣的事情
        public static void Receive()
        {
            Console.WriteLine("幼稚,这么大了,还看《火影忍者》,SB小明!");
        }
    }

    class Story
    {
        public static void Main(string[] args)
        {
            //实例化一个出版社
            Publisher publisher = new Publisher();

            //给这个出火影忍者的事件注册感兴趣的订阅者,此例中是小明
            publisher.OnPublish += new Publisher.PublishEventHander(MrMing.Receive);
            //另一种事件注册方式
            //publisher.OnPublish += MrMing.Receive;

            //发布者在这里触发出版火影忍者的事件
            publisher.issue();

            Console.ReadKey();
        }
    }

结果如下:

如果童靴们,从上到下仔细看一边的话,我想应该知道什么是发布者,什么是订阅者了吧,那至于事件呢

我们先看这句

publisher.OnPublish += new Publisher.PublishEventHander(MrMing.Receive);

这就是小明向出版社订阅他喜欢看的火影忍者,小张没有订阅所以小张没有收到书,

我们再仔细看看这个赋值语句,是不是似曾相识过呢?是的就是我们在上一讲,在讲委托声明的时候,简直就是一个眸子里刻出来的嘛

委托赋值:

BugTicketEventHandler myDelegate = new BugTicketEventHandler(MrZhang.BuyTicket);

所以,大家不要对事件有什么好怕的,其实事件的本质就是一个委托链,

我们看一下事件的声明:

//声明一个出版的委托
        public delegate void PublishEventHander();
        //在委托的机制下我们建立以个出版事件
        public event PublishEventHander OnPublish;
在我们使用事件的时候,必须要声明对应的委托,而触发事件,其实就是在使用委托链。

好了大家先消化消化这讲的内容,我们在下一讲里,我们会讲到我们期盼已久的Sender,e两个神秘的参数了。

原文链接  http://www.cnblogs.com/wudiwushen/archive/2010/04/21/1717378.html

今天我接着上面的3篇文章来讲一下,为什么我们在日常的编程活动中遇到这么多sender,EventArgs e 参数:
protected void Page_Load(object sender, EventArgs e)
{

}

protected void btnSearch_Click(object sender, ImageClickEventArgs e)
{

}

protected void grdBill_RowDataBound(object sender, GridViewRowEventArgs e)
{
          
}
那他们到底表示什么呢?

在回答上面的问题之前,我们先搞懂 .Net Framework的编码规范:

一、委托类型的名称都应该以EventHandler结束。
二、委托的原型定义:有一个void返回值,并接受两个输入参数:一个Object 类型,一个 EventArgs类型(或继承自EventArgs)。
三、事件的命名为 委托去掉 EventHandler之后剩余的部分。
四、继承自EventArgs的类型应该以EventArgs结尾。

这就是微软编码的规范,当然这不仅仅是规则,而是在这种规则下使程序有更大的灵活性,那我们就继续重构第三讲的例子,让他符合微软的规范。

  //所有订阅者【Subscriber】感兴趣的对象,也就是e,都要继承微软的EventArgs
    //本例中订阅者【也称观察者】MrMing,MrZhang他们感兴趣的e对象,就是杂志【magazine】
    public class PubEventArgs : EventArgs
    {
        public readonly string magazineName;
        public PubEventArgs()
        {

        }
        public PubEventArgs (string magazineName)
        {
           this.magazineName = magazineName;
        }
    }

    //发布者(Publiser)
    public class Publisher
    {
        //声明一个出版的委托
        //这里多了一个参数sender,它所代表的就是Subject,也就是监视对象,本例中就是Publisher
        public delegate void PublishEventHander(object sender ,PubEventArgs e);
        //在委托的机制下我们建立以个出版事件
        public event PublishEventHander Publish;

        //声明一个可重写的OnPublish的保护函数
        protected virtual void OnPublish(PubEventArgs e)
        {
            if (Publish != null)
            {
                //Sender = this,也就是Publisher
                this.Publish(this, e);
            }
        }

        //事件必须要在方法里去触发
        public void issue(string magazineName)
        {
            OnPublish(new PubEventArgs(magazineName));
        }
    }

    //Subscriber 订阅者
    public class MrMing
    {
        //对事件感兴趣的事情
        public static void Receive(object sender,PubEventArgs e)
        {
            Console.WriteLine("嘎嘎,我已经收到最新一期的《"+e.magazineName+"》啦!!");
        }
    }

    public class MrZhang
    {
        //对事件感兴趣的事情
        public static void Receive(object sender, PubEventArgs e)
        {
            Console.WriteLine("幼稚,这么大了,还看《火影忍者》,SB小明!");
            Console.WriteLine("这个我定的《"+e.magazineName+"》,哇哈哈!");
        }
    }

    class Story
    {
        public static void Main(string[] args)
        {
            //实例化一个出版社
            Publisher publisher = new Publisher();

            Console.Write("请输入要发行的杂志:");
            string name = Console.ReadLine();

            if (name == "火影忍者")
            {
                //给这个出火影忍者的事件注册感兴趣的订阅者,此例中是小明
                publisher.Publish += new Publisher.PublishEventHander(MrMing.Receive);
                //发布者在这里触发出版火影忍者的事件
                publisher.issue("火影忍者");
            }
            else
            {
                //给这个出火影忍者的事件注册感兴趣的订阅者,此例中是小明[另一种事件注册方式]
                publisher.Publish += MrZhang.Receive;
                publisher.issue("环球日报");
            }
            Console.ReadKey();
        }
    }

输入火影忍者后,触发小明订阅的事件

显示

通过例子我再做一次说明,其实我们不用把Sender,e想的过于可怕

一、委托声明原型中的Object类型的参数代表了Subject,也就是监视对象,在本例中是 Publisher(出版社)。。
二、EventArgs 对象包含了Observer所感兴趣的数据,在本例中是杂志。

好了,我们接着讲我们的委托与事件,其实如果大家对设计模式精通的话,其实他们关联的是观察者(Observer)模式,这里我就不再描述什么是观察者模式了,只是简单讲一下他们的关联:

在C#的event中,委托充当了抽象的Observer接口,而提供事件的对象充当了目标对象。委托是比抽象Observer接口更为松耦合的设计。

如果看不懂的话也没关系,当大家OO达到一定程度了,自然而然就会明白。

最后我们来看一个我们日常最最常用的观察者模式:

场景:当我们用信用卡刷完钱的时候,我们就会接收到手机短信,或者是电子邮件,其实这就是Observer pattern

    //---本例场景为当用户从银行账号里取出钱后,马上通知电子邮件和发手机短信---
    //本例中的订阅者,也就是观察者是电子邮件与手机
    //发布者,也就是被监视对象是银行账号

    //Obverser电子邮件,手机关心的对象e ,分别是邮件地址、手机号码、取款金额
    public class UserEventArgs : EventArgs
    {
        public readonly string emailAddress;
        public readonly string mobilePhone;
        public readonly string amount;
        public UserEventArgs(string emailAddress, string mobilePhone,string amount)
        {
            this.emailAddress = emailAddress;
            this.mobilePhone = mobilePhone;
            this.amount = amount;
        }
    }

    //发布者,也就是被监视的对象-银行账号
    class BankAccount
    {
        //声明一个处理银行交易的委托
        public delegate void ProcessTranEventHandler(object sender, UserEventArgs e);
        //声明一个事件
        public event ProcessTranEventHandler ProcessTran;

        protected virtual void OnProcessTran(UserEventArgs e)
        {
            if (ProcessTran != null)
            {
                ProcessTran(this, e);
            }
        }

        public void Prcess(UserEventArgs e)
        {
            OnProcessTran(e);
        }
    }

    //观察者Email
    class Email
    {
        public static void SendEmail(object sender, UserEventArgs e)
        {
            Console.WriteLine("向用户邮箱" + e.emailAddress + "发送邮件:您在"+System.DateTime.Now.ToString()+"取款金额为"+e.amount);
        }
    }

    //观察者手机
    class Mobile
    {
        public static void SendNotification(object sender, UserEventArgs e)
        {
            Console.WriteLine("向用户手机" + e.mobilePhone + "发送短信:您在" + System.DateTime.Now.ToString() + "取款金额为" + e.amount);
        }
    }

    //订阅系统,实现银行系统订阅几个Observer,实现与客户端的松耦合
    class SubscribSystem
    {
        public SubscribSystem()
        {

        }

        public SubscribSystem(BankAccount bankAccount, UserEventArgs e)
        {
            //现在我们在银行账户订阅2个,分别是电子邮件和手机短信
            bankAccount.ProcessTran += new BankAccount.ProcessTranEventHandler(Email.SendEmail);
            bankAccount.ProcessTran += new BankAccount.ProcessTranEventHandler(Mobile.SendNotification);
            bankAccount.Prcess(e);
        }
    }

    class Client
    {
        public static void Main(string[] args)
        {
            Console.Write("请输入您要取款的金额:");
            string amount = Console.ReadLine();
            Console.WriteLine("交易成功,请取磁卡。");
            //初始化e
            UserEventArgs user = new UserEventArgs("[email protected]", "18868789776",amount);
            //初始化订阅系统
            SubscribSystem subject = new SubscribSystem(new BankAccount(), user);
            Console.ReadKey();
        }
    }

运行结果如下:

网上还有个热水器烧水的OBSERVER PATTERN 也是蛮经典的,大家可以看看。

时间: 2024-07-28 21:32:01

c#委托事件及其讲解的相关文章

C#解惑1——委托&事件(转)

委托是一个类,它定义了方法的类型,使得可以将方法当作另一个方法的参数来进行传递,这种将方法动态地赋给参数的做法,可以避免在程序中大量使用If-Else(Switch)语句,同时使得程序具有更好的可扩展性. 委托和事件在.NET Framework[1]中的应用非常广泛,然而,较好地理解委托和事件对很多接触C#时间不长的人来说并不容易. 中文名 c#委托 外文名 Delegate 编程语言 C# 作    用 方便的引用被委托的方法 应    用 NET Framework 目录 1引言 2参数

C#委托事件

1.委托事件关键词:delegate 2.在声明函数的时候在函数类型后面加上 例:public delegate int Test(int x,int y) 3.定义委托变量:Test t1,委托接收的是方法引用. 4.委托变量可以当成函数的调用.用赋值“=” 委托变量 = 函数名 5.委托类型的变量,可以引用任何一个满足要求的方法,类似于C语言的函数指针. 6.一个委托变量可以使用“+=”挂接多个方法,也能使用“-=”动态地移除某个方法的引用. 7.引用多个方法的委托变量称为“多路委托”. 8

观察者(Observer)模式 * 委托事件

观察者(Observer)模式:定义了一种一对多的依赖关系.让多个观察者对象同时监听某一个主题对象.   这个主题对象发生变化时会通知所有观察者对象,使他们字段更新自己 /* * 抽象主题(Subject)角色:主题角色把所有对观察考对象的引用保存在一个聚集里,每个主题都可以有任何数量的观察者. 抽象主题提供一个接口,可以增加和删除观察者对象,主题角色又叫做抽象被观察者(Observable)角色,一般用一个抽象类或者一个接口实现. * 抽象观察者(Observer)角色:为所有的具体观察者定义

.Net 命名(委托,事件==)

委托及参数命名: public delegate void ClickedEventHandler(object sender, ClickedEventArgs e); ClickedEventHandler Clicked; .Net 命名(委托,事件==),布布扣,bubuko.com

jQuery Direct and delegated events 直接事件与委托事件

ref: http://api.jquery.com/on/ 直接事件: 将事件委托直接绑定到dom元素上,当事件发生时触发handler. 委托事件:  将事件委托绑定到dom元素的外层容器上,当事件发生时,冒泡到匹配的外层元素,触发相应handler. 采用委托事件的优势有2点: 1.效率高.对子元素数量非常多时,只需要绑定一个handler到父容器. 2. 可以对事件绑定调用时,尚未生成的子元素,仍然有效(只需要保证父容器已存在). jquery 使用on方法实现事件绑定. <!DOCTY

C# 委托 事件 之 窗体之间互传值

C# 委托 事件 之 窗体之间互传值 效果: Form1.cs: using System; using System.Windows.Forms; namespace 窗体事件互传值2 { public delegate void SetTxb2Del(string str, object obj);//定制针对Txb2的委托 public partial class Form1 : Form { private event SetTxb2Del st2dEvent;//声明Txb2委托的事件

委托事件的理解

委托是一种带有签名的类,需要用复合这个签名的静态函数或者非静态函数来初始化,就像楚怀王说:"先入秦关者望之".此时还不知道谁会先入秦观,可能是刘邦,可能是项羽.等到时间发展到一定时机,结论出来了,这个事委托给刘邦了.前提是刘邦复合这个签名,先入秦关了. 事件和委托类似,只不过事件源于委托,声明的时候需要先定义一个委托类型.也就是委托和类同级,事件和类里的属性方法同一个级别.事件只能在定义该事件的类里被初始化和使用,除了+=和-=.而委托无此限制.事件更形象化,就像,反秦起义这个事件爆发

一场武林盟主争霸赛-观察者模式PK委托事件技术

设计模式中提到观察者模式又叫做发布-订阅(Publish-订阅)模式.它定义了一种一对多的依赖关系,让多个观察者对象同时监听某一个主题对象.这个主题对象在状态发生变化时,会通知所有 观察者对象,使它们能够自动更新自己. C#中提到,委托是对函数的封装,可以当作给方法的特征指定一个名称.而事件则是委托的一种特殊形式,当发生有意义的事情时,事件对象处理通知过程.事件其实就是设计模式中观察者模式在.NET中的一种实现方式. 委托就是一种引用方法的类型.一旦为委托分配了方法,委托将与该方法具有完全相同的

对jQuery中on方法委托事件的理解

关于on方法中的委托事件,官方JQ API如下: http://api.jquery.com/on/#on-events-selector-data-handler 参考大牛阮一峰的博文: http://www.ruanyifeng.com/blog/2011/08/jquery_best_practices.html 什么时候使用委托事件: 1.对未被创建的元素添加事件监听 2.避免频繁添加或删除event handler,委托父元素来进行事件处理 使用委托事件的优点: 1.大量减少监听元素的