C#高级编程笔记 Delegate 的通俗了解 2016年二月 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会指向无效地址或者越界地址。
    

民用明白(利用原博主的源代码举行分析)

  • 例一 
     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 CompareDelegate cd=new CompareDelegate(Compare);

 

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

  • 图片 1

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

自家以图解来讲述一下

  • 图片 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 }
    11 public static void RecieveDelegateArgsFuns(MyTestDelegate func)
    12 {
    13 func(21);
    14 }
    15 public static void DelegateFunction(int i)
    16 {
    17 System.Console.WriteLine(“传来的参数{0}”,i);
    18 }
    19 }
    20 } 

沾满手稿

  • 图片 3           
      图片 4

由此了然 .Net 中的OnClick 机制 来深刻了然 Delegate 

C#中的事件处理实际上是一种具有非同平日签名的 delegate

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

内部的三个参数,sender代表事件发送者,e是事件参数类。My伊夫(Eve)ntArgs类用来含有与事件相关的数量,所有的事件参数类都不可能不从
System.伊夫(Eve)ntArgs类派生。当然,假若你的风波不含参数,那么可以一贯用System.伊夫(Eve)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;
    2 namespace Jandar.Test.YinXi{
    3
    4 class TestDelegate
    5 {
    6 public delegate void DelegateMethod(); //评释了一个Delegate Type
    7
    8 public DelegateMethod delegateMethod; //评释了一个Delegate对象
    9
    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){
    23 Console.WriteLine(“———“);
    24 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 ,说白了就是可以把方法当作参数传递。

 

相关文章