.net的委托和事件的直接理解

原创 2003年10月08日 00:07:00

                                       

         初学者在理解委托和事件时常常被msdn搞糊涂,为了让初学.net的人快速应用.net的委托和事件模型编程,我在这里主要是提出理解的关键,以下代码都可直接运行,先看下面的代码。

using System;

namespace delegeteTest
{
          
        class delegeteClass
         {   

             public delegate void fHandler(int a);     //关键-此行可以看成类的声明
             public  fHandler f0;
              public void d(int a,int b )
                {
                   int c=a+b;
                   f0(c);
                }
         }
        class test
        {
              public void output(int mun)
                {
                    System.Console .WriteLine ("{0}",mun);
                }
  
             [STAThread]
             static void Main(string[] args)
              {
                    test t=new test ();
                    delegeteClass dc=new delegeteClass ();
                   dc.f0 =new  delegeteTest.delegeteClass.fHandler (t.output);//实例的初始化
                   dc.d(2,3);
              }
       }
}

解释一下"关键": 实际上 public delegate void fHandler(int a);可以看成如下:

                  class fHandler 
                       {.....}

    类内部由编译器自动完成,是一个sealed类通过反汇编可以看到,是一个类的声明,它检查加入自己的函数的信息,如,返回值和参数类型

现在熟悉vc++的人可能感觉到public delegate void fHandler(int a);这句就象一个宏   

现在好了既然是个类的定义,那么也可以直接拿到命名空间下了     

           using System;

namespace delegeteTest
{
 public delegate void fHandler(int a);//fHandler现在上升到了类的层次
 
 class delegeteClass
 {
  public  fHandler f0;//声明了委托fHandler的实例f0;

  public fHandler  f1;//也可以再声明一个fHandler类的实例f1;
  public void d(int a,int b )
  {
   int c=a+b;
   f0(c);
  }
 }
 class test
 {
  public void output(int mun)
  {
   System.Console .WriteLine ("{0}",mun);
  }
  
  [STAThread]
  static void Main(string[] args)
  {
   test t=new test ();
   delegeteClass dc=new delegeteClass ();
   dc.f0 =new  delegeteTest.fHandler (t.output);//此行做相应的修改
   dc.d(2,3);
  }
 }
}

     有以上可知public delegate void fHandler(int a)这行代码只能放在能够声明类的地方,自然fHandler.后面的函数都是静态方法了,如fHandler.Equals (...);

    那么fHandler到底声明了什么? 实际上是声明了函数的类型,既函数的有关信息(如返回值,参数类型)。说到委托还是要说一下委托类型的实例。在msdn中的很多地方,(委托)这个词指的是委托类型的实例,它拥有了一个列表,列表的每一项包含了函数信息和函数所在的对象的引用。

    在声明fHandler类的实例f0的时候,f0还不能用,是空的,所以f0需要初始化 dc.f0 =new  delegeteTest.fHandler (t.output); 初始化的参数包含了两个信息 t--对象的引用output--函数信息,如果把初始化的这句注释掉,你运行一下看有什么信息----“未将对象引用设置到对象的实例”。另外output函数的参数和返回值需要和fHandler的类声明一致,这是由编译器在编译时检查的。

       经过初始化之后  现在实例中有了一项数据(实际上大多数只有一项,这样效率比较高,也就是single cast的,此时实例是Delegate类型的(注意是大写的D))。

     现在说一下委托的多播(multi cast),实际上委托的多播就是把列表里的每一项函数调用一次),但是多播的效率不是很高的所以委托的大部分实例都是单播(single cast),另外可能委托的实例会根据列表内函数的个数来运行不同的机制(这里我们就没必要研究它了)。看下面的代码:

namespace delegeteTest
{
    public delegate void fHandler(int a);
 
    class delegeteClass
      {
          public  fHandler f0;
          public  fHandler f1;
          public void d(int a,int b )
            {
                int c=a+b;
                f1(c);                   //合并指针列表的多播委托
            }
       }
    class test
     {
           public void output(int mun)
            {
                     System.Console .WriteLine ("          函数1显示{0}",mun);
             }
           public void output1(int mun)
               {
                      System.Console .WriteLine ("          函数2显示{0}",mun);
                }
  
          [STAThread]
          static void Main(string[] args)
           {
                   test t=new test ();
                  delegeteClass dc=new delegeteClass ();
                  dc.f0 =new  delegeteTest.fHandler (t.output);
                  dc.f1 =new fHandler (t.output1 );
   
                  System.Console .WriteLine ("第一次触发");
                  dc.d (2,3);//第一次触发
   
                   dc.f1 =(fHandler)Delegate.Combine (dc.f0 ,dc.f1 );//合并生成新的]函数列表
                  dc.f1 =(fHandler)MulticastDelegate.Combine (dc.f1 ,dc.f0 );//同上
                   System.Console .WriteLine ("第二次触发");
                  dc.d(2,3);//第二次触发
            }
      }
}
实际上dc.f1 =(fHandler)MulticastDelegate.Combine (dc.f1 ,dc.f0 );和dc.f1 =(fHandler)Delegate.Combine (dc.f1 ,dc.f0 );效果是一样的;由上面的例子可知我们完全可以由delegate 来构造我们自己的事件。微软为了方便大家进行编程,为我们提供了event。
using System;

namespace delegeteTest
{
 public delegate void fHandler(int a);
 
 class delegeteClass
 {
  public  fHandler f0;
  public  fHandler f1;
  public  event fHandler f3; //关键--实际上此行也可以看成一个宏

  public void d(int a,int b )
  {
   int c=a+b;
   f3(c);                                     // 改由event进行
  }
 }
 class test
 {
  public void output(int mun)
  {
   System.Console .WriteLine ("          第1显示{0}",mun);
  }
  public void output1(int mun)
  {
   System.Console .WriteLine ("          第2显示{0}",mun);
  }
  
  [STAThread]
  static void Main(string[] args)
  {
   test t=new test ();
   delegeteClass dc=new delegeteClass ();
   dc.f0 =new  delegeteTest.fHandler (t.output);
   dc.f1 =new fHandler (t.output1 );
   
   dc.f3 +=new fHandler(t.output); //f3是event
   System.Console .WriteLine ("第一次触发");
   dc.d (2,3);//第一次触发

    System.Console .WriteLine ("第二次触发");
   dc.f3 +=(fHandler)Delegate.Combine (dc.f0 ,dc.f1 );//添加列表到f3
   dc.d(2,3);//第二次触发
  }
 }
}

通过ildasm反汇编可以看到public  event fHandler f3声明了两个成员

        .field private class delegeteTest.fHandler f3和对f3的一个包装:

.event delegeteTest.fHandler f3
{
  .addon instance void delegeteTest.delegeteClass::add_f3(class delegeteTest.fHandler)
  .removeon instance void delegeteTest.delegeteClass::remove_f3(class delegeteTest.fHandler)
},

      所以上面红色的代码可以替换成如下:

  private  fHandler _f3;//由于不能与属性名相同,所以用_f3,是私有
  public  event fHandler f3
  {
     add
       {
          this._f3 += value;
       }
     remove
      {
          this._f3  -= value;
      }
   }

event 关键字方便了大家的习惯,同时它(由event定义的事件)在类的外部使用时隐藏了它的成员函数(这一点非常重要,几乎就是使用event关键字的原因),并且只能用“+=”和“-=”来操作,除此之外和直接声明public fHandler f3没有区别。它可以和上面的f0,f1一样允许有各种参数和返回值(EventHandler是一个特定的委托,没有返回值,参数是object和EventArgs类(或继承)的)。是在委托基础上的。实际上我们都能用delegate 来构造我们想要的事件,这就是delegate 在.net里的地位很高的原因。

     下面我就说说一般控件的事件模型

    我先谈一下控件里的"On事件名"这个函数 如:OnTextChange(EventArgs e),类似的有很多,实际上这是一种编程方面的习惯,他代表的是引发这个TextChanged事件(当然和上面一样,包含一个委托onTextChanged和一个event包装),具体的说就是在Text变量已经被赋值后执行的一个函数OnTextChanged(),OnTextChanged()里面包含了类似onTextChanged(e)这样的引发事件的代码。如果你重写了OnTextChanged(),而没有在(重写的函数)里添加base.OnTextChanged(e);那么你在外部添加的TextChanged事件的处理程序,永远也不会触发到,也就是TextChanged事件失效了。

 

以上只是帮助大家理解,因为这样才能事半功倍,尤其上面的关键,可以省了大家不少力气。希望专家批评指正
  
 

快速理解C#中的委托与事件

以下内容只是个人理解,仅供参考。 什么是委托? 先看最简单的委托例子: namespace DelegateTest { public delegate void MessageDele...
  • Wiiix
  • Wiiix
  • 2016年05月20日 20:02
  • 5641

[C#]委托和事件(详细讲解)

引言 委托 和 事件在 .Net Framework中的应用非常广泛,然而,较好地理解委托和事件对很多接触C#时间不长的人来说并不容易。它们就像是一道槛儿,过了这个槛的人,觉得真是太容易了,而没...
  • s10141303
  • s10141303
  • 2014年03月02日 00:23
  • 4320

C# .Net 委托和事件的区别

   在.net中,事件是一种特殊的委托,那他到底特殊在哪,换句话说,加上event关键字到底有什么用,我理解主要有两方面,下面用实例说明:    一 、事件只能在本类型内部“触发”,委托不管在本类型...
  • azkaser
  • azkaser
  • 2009年11月24日 15:18
  • 8887

C# 中的委托和事件(详解)

C# 中的委托和事件        委托和事件在 .NET Framework 中的应用非常广泛,然而,较好地理解委托和事件对很多接触 C# 时间不长的人来说并不容易。它们就像是一道槛儿,过了这个槛...
  • ZXD9790902
  • ZXD9790902
  • 2016年09月29日 09:10
  • 379

什么时候该用委托,为什么要用委托,委托有什么好处

好多人一直在问:什么时候该用委托,为什么要用委托,委托有什么好处.... 看完下面的文章你将茅塞顿开..(看不懂的直接TDDTDS) 概念虽然我不喜欢讲太多 我们直接先来YY 个场景: 我很喜...
  • cheungbill
  • cheungbill
  • 2012年06月24日 18:21
  • 8319

委托和事件的区别(讲的很详细)

原文地址:http://www.tracefact.net/CSharp-Programming/Delegates-and-Events-in-CSharp.aspx 委托 和 事件在 .Net F...
  • chopper7278
  • chopper7278
  • 2008年10月25日 23:58
  • 12412

Unity3D 委托和事件的优点(一)

上周接触到了委托,这周终于在自己的项目中用到了,现在准备用委托和事件的方案替换掉之前的一些使用不足的解决方案!   在此感谢前辈们的优秀文章,我是根据在网上阅读的文章,通过自己的见解,并在自己的项目...
  • VioletTD
  • VioletTD
  • 2015年11月15日 12:37
  • 2274

C#委托,事件与回调函数详解

C#委托与事件,回调函数详解
  • whl632359961
  • whl632359961
  • 2016年06月15日 16:08
  • 4559

通俗易懂地解释一下C#中的事件和委托

作者:吴杰 链接:http://www.zhihu.com/question/21638630/answer/26061308 来源:知乎 著作权归作者所有,转载请联系作者获得授权。 如果...
  • wonengguwozai
  • wonengguwozai
  • 2016年09月10日 19:20
  • 540

.Net2.0中通过委托和事件进行线程安全的控件访问

         在Framework2.0中,跨线程进行访问控件时,编译器会检查你所使用的方法是否线程安全。如VS2003那样直接无视线程赋值和取值的话,编译器会报错,提示线程不安全。几乎所有初次接...
  • bspiritxp
  • bspiritxp
  • 2007年05月01日 04:54
  • 1321
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:.net的委托和事件的直接理解
举报原因:
原因补充:

(最多只允许输入30个字)