C#高级编程笔记 Delegate 的通俗精晓 2016年2月 1二7日

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会指向无效地址或者越界地址。
    

个体驾驭(利用原博主的源代码进行剖析)

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

第一我们来分析一下 例1 的库房调用进度

1 CompareDelegate cd=new CompareDelegate(Compare);

 

因为 CompareDelegate 是叁个引用类型。所以那步执行的是在
堆中开创2个引用类型对象

  • 图片 1

接下去执行 cd(1,二);

本人以图解来讲述一下

  • 图片 2

接下去的例二和上例一差不离 ,以下也给出源代码

  • 1 namespace Jandar.Test.Yinxi
    2 {
    3     public delegate void MyTestDelegate(int i);//use like interface 
    4 
    5     public class DelegateTest
    6     {
    7         public static void Main()
    8         {
    9             RecieveDelegateArgsFuns(new MyTestDelegate(DelegateFunction));
    

    10 }
    1壹 public static void RecieveDelegateArgsFuns(MyTestDelegate func)
    12 {
    一3 func(二一);
    14 }
    1伍 public static void DelegateFunction(int i)
    16 {
    一七 System.Console.WriteLine(“传来的参数{0}”,i);
    1八 }
    1九 }
    20 } 

依附手稿

  • 图片 3           
      图片 4

由此掌握 .Net 中的OnClick 机制 来深远精通 Delegate 

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

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

内部的七个参数,sender代表事件发送者,e是事件参数类。My伊芙ntArgs类用来含有与事件有关的数目,全体的轩然大波参数类都必须从
System.伊夫ntArgs类派生。当然,假使你的风云不含参数,那么能够一贯用System.伊夫ntArgs类作为参数。(例子解释直接在代码中)

 1  using System;
 2  namespace Jandar.Test.YinXi
 3  {
 4      public class ButtonClickArgs : EventArgs
 5      {
 6          public string Clicker;//用来显示 操作对象。
 7      }
 8      public class MyButton
 9      {
10          public delegate void ClickHandle(object sender, ButtonClickArgs e);//声明一个delegate的类型
11  
12          public event ClickHandle OnClick;//定义事件,类型为 delegate 的ClickHandle对象;
13          public void Click()
14          {
15              OnClick(this, new ButtonClickArgs() { Clicker = "H" });////相当于 onClick中自带的 Invoke()方法,类似与 OnClick.Invoke(
16 //this, new ButtonClickArgs() { Clicker = "H" }
17          }
18      }
19      public class Program
20      {
21          public static void Main(string[] args)
22          {
23              MyButton btn = new MyButton();
24              btn.OnClick += new MyButton.ClickHandle(btn_OnClick);//注册时间,把btn_OnClick 方法绑定到 委托事件中。
25        btn.Click();//进行调用
26          }
27          public static void btn_OnClick(object sender, ButtonClickArgs e)
28          {
29              Console.WriteLine("Hello,MyWorld!");
30          }
31      }
32 }

 

 

 

定义二:(参考)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++中的函数指针不同,委托是面向对象、类型安全的,并且是安全的。
    

    1 using System;
    二 namespace Jandar.Test.YinXi{

    四 class TestDelegate
    5 {
    陆 public delegate void DelegateMethod(); //表明了四个Delegate Type
    7
    八 public DelegateMethod delegateMethod; //评释了三个Delegate对象

    10 public static void StaticMethod()
    11 {
    12 Console.WriteLine(“Delegate a static method”);
    13 }
    14
    15 public void NonStaticMethod()
    16 {
    17 Console.WriteLine(“Delegate a non-static method”);
    18 }
    19
    20 public void RunDelegateMethods()
    21 {
    22 if(delegateMethod != null){
    二三 Console.WriteLine(“———“);
    2四 delegateMethod.Invoke(); //运转 delegateMethod所搭载的函数
    25 Console.WriteLine(“———“);
    26 }
    27 }
    28 }
    29
    30 class Program
    31 {
    32 static void OtherClassMethod(){
    33 Console.WriteLine(“Delegate an other class’s method”);
    34 }
    35
    36 static void Main(string[] args)
    37 {
    38 var test = new TestDelegate();
    39 test.delegateMethod = new TestDelegate.DelegateMethod(test.NonStaticMethod);
    40 test.delegateMethod += new TestDelegate.DelegateMethod(TestDelegate.StaticMethod);
    41 test.delegateMethod += Program.OtherClassMethod;
    42 test.RunDelegateMethods();
    43 }
    44 }
    45 }

 

上面那个事例作者以为挺好的,呈现了概念一种的 解释

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