详解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(int i);

这就是一个委托的定义。蓝色部分是声明委托的关键字，红色部分是返回的类型，而黑色部分是委托的类型名，和一个类名差不多，而()里的就是参数部分。它的意思是，你要使用这个委托来做事情的话，那么，做事情的方法必须满足以下条件：

1、返回类型和委托的返回类型一致，这里是string类型；

2、能且只能有一个参数，并且是int类型。

ok,满足以上两个条件，一切就可以工作了:)

例如：

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)
     {
       /* 调用方法 */
       processdelegate pd = new processdelegate(new test().process);
       console.writeline(pd("text1", "text2"));
     }
   }
 
   public class test
   {
     /// <summary>
     /// 方法
     /// </summary>
     /// <param name="s1"></param>
     /// <param name="s2"></param>
     /// <returns></returns>
     public string process(string s1,string s2)
     {
       return s1 + s2;
     }
   }
 }

输出的结果是:

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

以上就是本文的全部内容，希望对大家的学习有所帮助，也希望大家多多支持。