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(,);
  
               //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();
           }
           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 ，说白了就是可以把方法当作参数传递。