C#中的委托,事件,回调函数综合总结:结合了网上几位大神的例子

C# 里面这个东西一般指某个委托.其实也可以是接口.

delegate void WorkDone();
void Working(WorkDone callBack){
//Working code.
//当工作完成的时候执行这个委托.
callBack();
}
void WorkDoneHandler(){
   //Do something other.
}
void Do(){
  WorkDone callBack = newWorkDone(WorkDoneHandler);
  Working(callBack);
}

也就是相当把某个方法(WorkDoneHandler())当作参数传递给另外一个方法(Working(WorkDone callBack)).
这样做的好处在于,可以动态的指定执行哪个方法.
比如在Do()方法中,我们指定的callback 是WorkDoneHandler 当然也可以是其它匹配的方法. 而Working()方法 更本不需要知道自己最后执行的是哪个Handler.

详解C#委托,事件与回调函数

.Net编程中最经常用的元素,事件必然是其中之一。无论在ASP.NET还是WINFrom开发中,窗体加载(Load),绘制(Paint),初始化(Init)等等。
“protected void Page_Load(object sender, EventArgs e)”
这段代码相信没有人不熟悉的。细心一点一定会发现,非常多的事件方法都是带了“object sender,EventArgs e”这两个参数。这是不是和委托非常相似呢?

一、委托(有些书中也称为委派)

委托是什么呢?这个名字的意思已经赋予了我们想象的空间,你是编程的,你现在正在写一个ASP.NET网页,而JS是你不熟悉的,于是你委托你的一位同事来帮助你完成JS部分。这就是委托,把你所不能做的事情交给其他人去做。而怎么知道是哪个人去做呢?当然是要知道名字!而为了区别名字一样的不同人,因此,需要描述一个特征。

C#中,委托的作用是这样描述的:委托就像一个函数的指针,在程序运行时可以使用它们来调用不同的函数。这个其实和你委托同事完成 JS代码一样。如果有两位同事可以做这件事情,他们只要做的结果能够满足你的需求(就像一个接口),尽管他们做的过程不一样,并且作出的效果也不一样,但是,能够达到你的要求就可以了。

1
、简单的委托

那委托需要承载哪些信息呢?首先,它存储了方法名,还有参数列表(方法签名),以及返回的类型。比如:
delegate string/*返回类型*/ ProcessDelegate(inti);
这就是一个委托的定义。蓝色部分是声明委托的关键字,红色部分是返回的类型,而黑色部分是委托的类型名,和一个类名差不多,而()里的就是参数部分。它的意思是,你要使用这个委托来做事情的话,那么,做事情的方法必须满足以下条件:
1
、返回类型和委托的返回类型一致,这里是string类型;
2
、能且只能有一个参数,并且是int类型。
OK,
满足以上两个条件,一切就可以工作了:)

例如:

 1 using System;
 2 using System.Collections.Generic;
 3 using System.Text;
 4 
 5 namespace TestApp
 6 {
 7     /// <summary>
 8     /// 委托
 9     /// </summary>
10     /// <param name="s1"></param>
11     /// <param name="s2"></param>
12     /// <returns></returns>
13     public delegate string ProcessDelegate(string s1, string s2);
14 
15     class Program
16     {
17         static void Main(string[] args)
18         {
19             /*  调用方法  */
20             ProcessDelegate pd = new ProcessDelegate(new Test().Process);
21             Console.WriteLine(pd("Text1""Text2"));
22         }
23     }
24 
25     public class Test
26     {
27         /// <summary>
28         /// 方法
29         /// </summary>
30         /// <param name="s1"></param>
31         /// <param name="s2"></param>
32         /// <returns></returns>
33         public string Process(string s1,string s2)
34         {
35             return s1 + s2;
36         }
37     }
38 }

输出的结果是:
Text1Tex2


2
、泛型委托

泛型的委托,就是然参数的类型不确定,例如代码改写为:

using System;
using System.Collections.Generic;
using System.Text;

namespace TestApp
{
    /// <summary>
    
/// 委托
    
/// </summary>
    
/// <param name="s1"></param>
    
/// <param name="s2"></param>
    
/// <returns></returns>
    public delegate string ProcessDelegate<T,S>(T s1, S s2);

    class Program
    {
        static void Main(string[] args)
        {
            /*  调用方法  */
            ProcessDelegate<string,int> pd = new ProcessDelegate<string,int>(new Test().Process);
            Console.WriteLine(pd("Text1"100));
        }
    }

    public class Test
    {
        /// <summary>
        
/// 方法
        
/// </summary>
        
/// <param name="s1"></param>
        
/// <param name="s2"></param>
        
/// <returns></returns>
        public string Process(string s1,int s2)
        {
            return s1 + s2;
        }
    }
}


输出的结果就是:
Text1100

泛型的详细内容不属于本文的介绍范围,这里不加多说了。

二、事件

在某件事情发生时,一个对象可以通过事件通知另一个对象。比如,前台完成了前台界面,他通知你,可以把前台和你开发的程序整合了。这就是一个事件。可以看出事件是在一个时间节点去触发另外一件事情,而另外一件事情怎么去做,他不会关心。就事件来说,关键点就是什么时候,让谁去做。

C#中,时间定义关键字是event。例如:
event ProcessDelegate ProcessEvent;

整个事件定义方法以及执行过程:

using System;
using System.Collections.Generic;
using System.Text;

namespace TestApp
{
    /// <summary>
    
/// 委托
    
/// </summary>
    
/// <param name="s1"></param>
    
/// <param name="s2"></param>
    
/// <returns></returns>
    public delegate void ProcessDelegate(object sender, EventArgs e);

    class Program
    {
        

        static void Main(string[] args)
        {
            /*  第一步执行  */
            Test t = new Test();
            /* 关联事件方法,相当于寻找到了委托人 */
            t.ProcessEvent += new ProcessDelegate(t_ProcessEvent);
            /* 进入Process方法 */
            Console.WriteLine(t.Process()); 

            Console.Read();
        }

        static void t_ProcessEvent(object sender, EventArgs e)
        {
            Test t = (Test)sender;
            t.Text1 = "Hello";
            t.Text2 = "World";
        }
    }

    public class Test
    {
        private string s1;

        public string Text1
        {
            get { return s1; }
            set { s1 = value; }
        }

        private string s2;

        public string Text2
        {
            get { return s2; }
            set { s2 = value; }
        }


        public event ProcessDelegate ProcessEvent;

        void ProcessAction(object sender, EventArgs e)
        {
            if (ProcessEvent == null)
                ProcessEvent += new ProcessDelegate(t_ProcessEvent);
            ProcessEvent(sender, e);
        }

        //如果没有自己指定关联方法,将会调用该方法抛出错误
        void t_ProcessEvent(object sender, EventArgs e)
        {
            throw new Exception("The method or operation is not implemented.");
        }

        void OnProcess()
        {
            ProcessAction(this, EventArgs.Empty);
        }

        public string Process()
        {
            OnProcess();
            return s1 + s2;
        }
    }
}
 

感觉到了什么?是不是和代码注入了差不多,相当于是可以用任意符合委托接口(委托确实很像接口)的代码,注入到Process过程。在他返回之前给他赋值。

三、回调函数

打了这么多字,好累啊!

回调函数就是把一个方法的传给另外一个方法去执行。在C#有很多回调函数,比如异步操作的时候。这里先举个例子:

using System;
using System.Collections.Generic;
using System.Text;

namespace TestApp
{
    /// <summary>
    
/// 委托
    
/// </summary>
    
/// <param name="s1"></param>
    
/// <param name="s2"></param>
    
/// <returns></returns>
    public delegate string ProcessDelegate(string s1, string s2);

    class Program
    {
        static void Main(string[] args)
        {
            /*  调用方法  */
            Test t = new Test();
            string r1 = t.Process("Text1""Text2"new ProcessDelegate(t.Process1));
            string r2 = t.Process("Text1""Text2"new ProcessDelegate(t.Process2));
            string r3 = t.Process("Text1""Text2"new ProcessDelegate(t.Process3));

            Console.WriteLine(r1);
            Console.WriteLine(r2);
            Console.WriteLine(r3);
        }
    }

    public class Test
    {
        public string Process(string s1,string s2,ProcessDelegate process)
        {
            return process(s1, s2);
        }

        public string Process1(string s1, string s2)
        {
            return s1 + s2;
        }

        public string Process2(string s1, string s2)
        {
            return s1 + Environment.NewLine + s2;
        }

        public string Process3(string s1, string s2)
        {
            return s2 + s1;
        }
    }
}


输出结果:
Text1Text2
Text1
Text2
Text2Text1

Process
方法调用了一个回调函数,当然这里只执行了回调函数。可以看出,可以把任意一个符合这个委托的方法传递进去,意思就是说这部分代码是可变的。而设计上有一个抽离出可变部分代码的原则,这种用法无疑可以用到那种场合了。

全文完。http://birdshover.cnblogs.com   Birdshover

 

 

 

C#中委托、事件和回调函数的理解

2017-01-18 22:39 1584人阅读 评论(0) 收藏 举报

 分类:

C#6 

版权声明:本文为博主原创文章,未经博主允许不得转载。

在C#中我们经常会碰到事件,尤其是在WPF或者WinForm中,窗体加载、或者点击一个按钮,都会触发事件。实际上,事件是对委托的封装。如果不进行封装,让委托暴露给调用者,调用者就可以把委托变量重新引用到新的委托对象,也就删除了当前要调用的方法列表;更糟糕的是,公共的委托成员打破了封装不仅导致代码难以维护和调试,而且会导致应用程序有安全风险。下面分别说明。

1、委托

委托可以理解为一种协议。委托,是什么意思呢?举个例子,你碰到一件事,你需要让别人来帮你做(可能你还有别的事情要做),这就是委托,把你现在不能做的事让别人去做。为什么说委托就像一个协议呢,因为你不想把事情搞砸了,所以你“委托”的这个人做的这件事,你需要给他定一个标准。在C#中就是给所委托的对象定义好签名,参数有几个,分别是什么类型,委托方法需要反馈给你什么东西(或者不反馈)。从这种意义上理解,委托就像是一种协议。下面是例子。

[c#] view plain copy

1.  public delegate int MyDelegate(int x, int y);  

2.      class Delegate_Demo {  

3.          static void Main(string[] args) {  

4.              //实例化被委托者  

5.              Helper helper = new Helper();  

6.              //创建委托对象  

7.              MyDelegate myDele = new MyDelegate(helper.Add);  

8.              int sum = myDele(1, 2);  

9.              Console.WriteLine(sum);  

10.         }  

11.   

12.     }  

13.     class Helper {  

14.         public Helper() {}  

15.   

16.         public int Add(int num1, int num2) {  

17.             return num1 + num2;  

18.         }  

19.     }  

上述例子中public delegate int MyDelegate(intx, int y);声明了一个委托,告诉被委托者这件事你要这么干,我给你两个整数,你计算他们的和,怎么计算我不管,计算完之后你把和给我。

2、事件

在某件事情发生时,一个对象可以通过事件通知另一个对象。比如,前台界面一个求和按钮被点击了,他通知你,可以把a和b这两个数相加了。这就是一个事件。可以看出事件是在一个时间节点去触发另外一件事情,而另外一件事情怎么去做,他不会关心。就事件来说,关键点就是什么时候,让谁去做。

在编译器处理event关键字时,会自动提供注册和注销方法以及任何必要的委托类型成员变量(私有的),因此不能从触发事件的对象去调用它们,event关键字就像一个语法糖,节省了我们打字的时间。

定义一个事件有两步,首先定义一个委托,它包括了这件事的“协议”和委托方法(由谁去做);其次,用event关键字和相关委托声明这个事件。事件像是一个接口,封装了委托所定的“协议”。由于委托已经定义了协议,剩下的就是按这个协议去办事,至于怎么做它并不关心。下面是一个例子。

[c#] view plain copy

1.  public delegate int MyDelegate(int x, int y);  

2.      class Delegate_Demo {  

3.          //声明事件  

4.          static event MyDelegate myEvent;  

5.          static void Main(string[] args) {  

6.              //交代事件  

7.              myEvent += new Helper().Add;  

8.              int sum = myEvent(3, 4);  

9.              Console.WriteLine(sum);  

10.         }  

11.   

12.     }  

13.     class Helper {  

14.         public Helper() {}  

15.   

16.         public int Add(int num1, int num2) {  

17.             return num1 + num2;  

18.         }  

19.     }  

从上面可以看出,调用者无法访问委托对象。

3、回调函数

回调函数就是把一个方法的传给另外一个方法去执行。回调函数只是一个功能片段,由用户按照回调函数的调用约定来实现的一个函数。先看一个例子。

[c#] view plain copy

1.  public delegate int MyDelegate(int x, int y);  

2.      class Delegate_Demo {  

3.          //声明事件  

4.          static event MyDelegate myEvent;  

5.          static void Main(string[] args) {  

6.    

7.              int sum = MyAdd(1, 2, new Helper().Add);  

8.              Console.WriteLine(sum);  

9.          }  

10.         private static int MyAdd(int a, int b, MyDelegate myDele) {  

11.             return myDele(a, b);  

12.         }  

13.   

14.     }  

15.     class Helper {  

16.         public Helper() {}  

17.   

18.         public int Add(int num1, int num2) {  

19.             return num1 + num2;  

20.         }  

21.     }  

可以看出,可以把任意一个符合这个委托的方法传递进去,意思就是说这部分代码是可变的。而设计上有一个抽离出可变部分代码的原则,这种用法无疑可以用到那种场合了

评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值