C#高级编程笔记 Delegate 的粗浅理解 2016年9月 13日

Delegate [重中之重] 委托

定义一：（参考）http://www.cnblogs.com/zhangchenliang/archive/2012/09/19/2694430.html

• 完全可以把delegate理解成C中的函数指针。
  它允许你传递一个 类A 的 方法m 给另一个 类B 的对象，使得 类B 的对象能够调用这个 方法m ，说白了就是可以把方法当作参数传递。
  不过delegate和函数指针还是有点区别的，delegate有许多函数指针不具备的优点。
  　　　　首先：函数指针只能指向静态函数，而delegate既可以引用静态函数，又可以引用非静态成员函数。
  　　　　在引用非静态成员函数时，delegate不但保存了对此函数入口指针的引用，而且还保存了调用此函数的类实例的引用。
  　　　　其次，与函数指针相 比，delegate是面向对象、类型安全、可靠的受控（managed）对象。
  也就是说，runtime能够保证delegate指向一个有效的方法， 你无须担心delegate会指向无效地址或者越界地址。

个人理解（利用原博主的源代码进行分析）

• 例一 
  

  namespace Jandar.Test.Yinxi{
      class DelegateTest{
          public delegate void CompareDelegate(int a,int b);
  
          public static void Compare(int a,int b){
              System.Console.WriteLine((a>b).ToString());
          }
          public static void Main(string[] args){
              CompareDelegate cd=new CompareDelegate(Compare);
              cd(1,2);
  
              //Compare(5,4);和上面两行的执行结果是一样的。
          }
      }
  }

首先我们来分析一下 例一 的堆栈调用过程

CompareDelegate cd=new CompareDelegate(Compare);

因为 CompareDelegate 是一个引用类型。所以这步执行的是在 堆中创建一个引用类型对象

• 

接下来执行 cd(1,2);

我以图解来描述一下

• 

接下来的例二和上例一差不多 ，以下也给出源代码

• namespace Jandar.Test.Yinxi
  {
      public delegate void MyTestDelegate(int i);//use like interface 
  
      public class DelegateTest
      {
          public static void Main()
          {
              RecieveDelegateArgsFuns(new MyTestDelegate(DelegateFunction));
          }
          public static void RecieveDelegateArgsFuns(MyTestDelegate func)
          {
              func(21);
          }
          public static void DelegateFunction(int i)
          {
              System.Console.WriteLine("传来的参数{0}",i);
          }
      }
  } 

附上手稿

•               

通过理解 .Net 中的OnClick 机制 来深入理解 Delegate 

C#中的事件处理实际上是一种具有特殊签名的 delegate

public delegate void MyEventHandler(object sender, MyEventArgs e);

其中的两个参数，sender代表事件发送者，e是事件参数类。MyEventArgs类用来包含与事件相关的数据，所有的事件参数类都必须从 System.EventArgs类派生。当然，如果你的事件不含参数，那么可以直接用System.EventArgs类作为参数。（例子解释直接在代码中）

 using System;
 namespace Jandar.Test.YinXi
 {
     public class ButtonClickArgs : EventArgs
     {
         public string Clicker;//用来显示 操作对象。
     }
     public class MyButton
     {
         public delegate void ClickHandle(object sender, ButtonClickArgs e);//声明一个delegate的类型
 
         public event ClickHandle OnClick;//定义事件，类型为 delegate 的ClickHandle对象;
         public void Click()
         {
             OnClick(this, new ButtonClickArgs() { Clicker = "H" });////相当于 onClick中自带的 Invoke()方法，类似与 OnClick.Invoke(
//this, new ButtonClickArgs() { Clicker = "H" }
         }
     }
     public class Program
     {
         public static void Main(string[] args)
         {
             MyButton btn = new MyButton();
             btn.OnClick += new MyButton.ClickHandle(btn_OnClick);//注册时间，把btn_OnClick 方法绑定到 委托事件中。
　　　　　　 btn.Click();//进行调用
         }
         public static void btn_OnClick(object sender, ButtonClickArgs e)
         {
             Console.WriteLine("Hello,MyWorld!");
         }
     }
}

定义二：（参考）http://www.cnblogs.com/idior/articles/100666.html

• 将Delegate理解为接口，只有一个方法的接口，这样最容易理解。这个方法只有声明，没有实现，实现在别的类。（实际上应该把它看作函数指针，不过接口更容易理解些。）
  在你的类中有一个Delegate就相当于有一个接口。通过这个接口你可以调用一个方法，而这个方法在别的类定义，由别的类来干。

定义三：（参考）http://www.cnblogs.com/hyddd/archive/2009/07/26/1531538.html

• Delegate中文翻译为“委托”。Msdn中对Delegate的解释如下：
  
  C#中的委托类似于C或C++中的函数指针。使用委托使程序员可以将方法引用封装在委托对象内。然后可以将该委托对象传递给可调用所引用方法的代码，
  而不必在编译时知道将调用哪个方法。与C或C++中的函数指针不同，委托是面向对象、类型安全的，并且是安全的。

using System;
namespace Jandar.Test.YinXi{

    class TestDelegate
    {
        public delegate void DelegateMethod();  //声明了一个Delegate Type

        public DelegateMethod delegateMethod;   //声明了一个Delegate对象

        public static void StaticMethod()   
        {
            Console.WriteLine("Delegate a static method");
        }

        public void NonStaticMethod()   
        {
            Console.WriteLine("Delegate a non-static method");
        }

        public void RunDelegateMethods()
        {
            if(delegateMethod != null){
                Console.WriteLine("---------");
                delegateMethod.Invoke();  //运行 delegateMethod所搭载的函数  
                Console.WriteLine("---------");
            }
        }
    }

    class Program
    {
        static void OtherClassMethod(){
            Console.WriteLine("Delegate an other class's method");
        }

        static void Main(string[] args)
        {
            var test = new TestDelegate();
            test.delegateMethod = new TestDelegate.DelegateMethod(test.NonStaticMethod);
            test.delegateMethod += new TestDelegate.DelegateMethod(TestDelegate.StaticMethod);
            test.delegateMethod += Program.OtherClassMethod;
            test.RunDelegateMethods();
        }
    }
 }

上面这个例子我觉得挺好的，体现了定义一种的 解释

它允许你传递一个 类A 的 方法m 给另一个 类B 的对象，使得 类B 的对象能够调用这个 方法m ，说白了就是可以把方法当作参数传递。