Wu.Country@侠缘

勤学似春起之苗,不见其增,日有所长; 辍学如磨刀之石,不见其损,日所有亏!

导航

对C#下函数,委托,事件的一点理解!

 

今天一来是有点空,二来是在博客上偶然看到有关于委托的文章,一时兴起,就自己也写一点心得与大家分享一下。

 

先看一个例子:

using System;
namespace ConsoleApplication1
{
    
class Class1
    
{
        [STAThread]
        
static void Main(string[] args)
        
{
            
bool m_isRight = false;
            
object m_obj = m_isRight?MyWrite("true"):MyWrite("false");
            Console.Write(m_obj);
        }

        
static private int MyWrite(object i_string)
        
{
            Console.Write(i_string);
            
return i_string.ToString().Length;
        }

    }

}

问输出的结果是什么?有一个刚学习程序设计不久的学生的回答是:false false

这个结果给我的映像很深,为什么呢?因为我觉得这个不仅仅是学生的一个错误,而更多的是这个学生深入的思考了问题。

因为m_obj是一个对象,所以这个学生理解为:MyWrite()这个函数对象可以直接赋值给m_obj,然后m_obj就当成MyWrite()这个函数来调用,所以他就认为:

Console.Write (m_obj); 等于是:Console.Write (MyWrite(“false”));
这是思维是很有创意的,不是吗?

于是就是C#里而很多人不好理解的委托了。其实,从使用上讲,它就是一个函数变量!如上面的例子,如果真的是想把MyWrite()做为对象赋值给m_obj会是个什么结果呢?

我觉得我们先得解决以下几个问题,才能正确的把函数当成变量赋值给一个对象:

1、             如果可以给一个对象赋函数值,如何来区别不同的函数?

2、             如何区别它是一个函数赋值,还是一个普通的对象赋值?

3、             如何用这个对象来调用原来的函数?

如果把这几个问题解决了,委托也就明白了一半。

先看问题1,如果可以给一个对象赋函数值,如何来区别不同的函数?

首先应该明白的是:C#里是可以对一个对象赋函数值的。解决这个问题的办法是先对该对象申明,申明它可以被什么样的函数来赋值,而这个对象申明在C#里的学名就是委托。

(在C++里称为函数指针申明,相应的对象也就叫做函数指针。Java里也不同的叫法,可惜我不知道。)

而它的语法就是:

delegate [function declare];

这里的function declare就包括了:

1、             函数返回类型,

2、             可用来存放函数的对象名(也就是委托名)

3、             函数参数

所以完整的定义可以是:

delegate int MyDelegate(object I_object);

当然,合法的委托定义可以是:

delegate void MyDelegate();

delegate void MyDelegate(object I_1,object I_2);

现在,上面的语法就定义了一个抽象的对象MyDelegate, 注意,这里说的是抽象的对象,也就是说,你不能直接给MyDelegate赋函数,而只能在它的实例上函数,这是C#里特殊的要求。它的语法是:

MyDelegate m_delegate = new MyDelegate(MyDelegate申明一致的函数名);

例如,以下是一个完全的,合法的委托申明与实例化一个对象:

delegate int MyDelegate(object i_object);
//
MyDelegate m_delegate = new MyDelegate(MyWrite);
//MyWrite函数如下,它是满足委托的申明的。
                   static private int MyWrite(object i_string)
                   
{
                            Console.Write(i_string);
                            
return i_string.ToString().Length;
                   }

现在我们就很好的解决了第一个问题,如何定义一个对象,使该对象可以把函数当变量来赋给它。而且,可以区别不同的函数类型,主要是通过函数返回值与函数参数来共区别一类函数。

OK,第二个问题:如果有了这样的一个对象后,如何来给它赋一个函数值呢?

其实上面的实例化一个委托对象时,就已经给它赋值了。上面的代码中,m_delegate就已经被赋值MyWrite,因此它已经具有了MyWrite函数的功能。

还有其实它的方法来给它赋值吗?有,在委托的一个应用中,可以看到其它的赋值方法。也就是另一个不好理解的概念:事件!后面会提到。

我们再来看一下最后一个问题:如何通过一个已经赋值好了的委托对象,还调用它上面赋值了的函数。

这个最简单了,当一个委托实例赋了函数对象在上面后,就可以像调用原函数一样的来调用它了。因此,下面是一个会法的调用:基于上面的申明。

m_delegate(“This is a delegate object to call the raw function.”);

它就等同于:

MyWrite(“This is a delegate object to call the raw function.”);

因此,上面的调用与原函数调用一样,会返回一个int结果。

OK,最后看一个完整的例子:

using System;
namespace ConsoleApplication1
{
    
class Class1
    
{
        
//先申明一个委托对象。
        delegate int MyDelegate(object i_object);
        [STAThread]
        
static void Main(string[] args)
        
{
            MyDelegate m_delegate 
= new MyDelegate(MyWrite);
            m_delegate(
"This is a delegate object to call the raw function.");
        }

        
//该函数是满足上面委托对象的申明的。
        static private int MyWrite(object i_string)
        
{
            Console.Write(i_string);
            
return i_string.ToString().Length;
        }
        
    }

}


再来讨论一下它的应用:事件!

事件是其于委托的。我们还是先来看最开始的那个例子:

object m_obj = m_isRight?MyWrite("true"):MyWrite("false");

我想把一个函数对象赋值到m_obj上!但上面的委托只能在实例化对象的时候就直接给它赋值了。而现在是,在运行时对一个委托赋函数值。可以做到吗?

同样是有这样的向个问题,当然,前提是我们已经知道有一种对象叫委托,它的实例可以赋函数对象。

下面的问题是:

1、             如果可以在运行时给某个“特殊委托”赋函数对象,如何实现?

2、             运行时,如何知道该“特殊委托”是否已经被赋过函数值?及如何再赋值?

3、             如果可以,能否在一个“特殊委托”上添加多个函数?如果可以,如何删除函数?

下面,我们就针对这几个问题,来讨论一下C#里的事件,也就是上面的“特殊委托”。(其它语言里是如何实现这些功能的,我就不清楚了。)

首先,C#里是可以实现在运行时给一个委托动态的赋函数值的,同时也是可以动态的删除已经添加在某个委托上的函数的,它的实现有一点点麻烦,就是要用到另一个对象:事件!event

(申明,你完全可以不把它叫事件,只不过这种动态的添加和删除函数的功能在真实的程序设计中,基本上是与事件相关,所以就叫做事件了。个人想法,呵呵。)

OK,下面是C#语法,来申明一个“特殊委托”――事件,让它可以动态的添加函数!

下文中,事件是指那些“特殊委托”,它的特殊之外,后面会讲到。而下文中的委托就是前面讲到的,一个特殊的对象,该对象可以把函数当“值”赋给它。

static event MyDelegate m_myevent;

(static 可以用其它的修饰符)

说明一下,这里其实就是申明了一个事件,用event来说明它是事件(特殊委托)的。其实对比实例化一个委托的语法,你可以理解到,它就像是申明了一个委托,只不过个委托加了个event来说明它:

Mydelegate m_delegate;//申明一个委托

event MyDelegate m_myevent;//申明一个事件

很像吧!不是吗?

OK,我们再来看,m_myevent m_delegate到底有什么不同的?也就是,事件(特殊委托)到底特殊在什么地方?

1、             事件不是一个可以直接把函数当值一样赋给它的委托。而委托可以直接赋函数,而且是在实例化的时候,赋函数名。

2、             事件只能把一个实例的委托当值赋给它。也就是说:事件是用来管理委托的,进而来管理函数!因为一个实例化的委托一定有一个函数与之对应。

3、             在事件上可以动态的添加与删除委托。而委托上不能动态的添加删除函数。

OK,下面的一个问题,上面事件的申明中,MyDelegate是起什么作用的呢?

还记得前面的委托申明吗?它就是说明了m_myevent在运行时可以动态的以委托的形式赋的函数要与MyDelegate申明的一样!

因此上面的一个实例化是完全合法的。

再理解一下:事件,是用来动态管理委托的,而委托是单一的与一个函数对应的。

 

现在看第二个问题,运行时,如何知道该“特殊委托”是否已经被赋过函数值?及如何再赋值?

即:如何知道一个事件上已经赋过经过委托过的函数?

前面已经说过,m_myevent没有给它赋值,如何给它赋值呢?它的赋值方法有点怪:

一个实例:

m_myevent += m_delegate;

有点怪吧!这里正好说明了:事件是用来动态管理委托的。把一个委托加在事件上。

当然,你还可以在添加委托的时候直接new一个新的委托:

m_myevent +=new MyDelegate(Class1_m_myevent);//后面的函数名由vs2003生动生成

这就是.net下标准的给事件添加委托的方法,也就是给一个事件添加了一个可调用的函数。确切的说,是一个回调函数(C++的概念)。

 

OK,下面就如何判断一个事件上是否已经被赋过经过委托的函数:

if(m_myevent==null)

就可以知道了!

那么如何知道一个事件上面有多少个委托呢?也就是多少个委托过的函数?

m_ myevent.GetInvocationList();

可以得到所有的委托!这里应该知道:事件本身是一个对象,当实例化一个事件后,它是有自己的一些方法也成员的。可以查阅MSDN得到更多说明,同样的委托也是一个对象,相关的说明也可以在MSDN里找到。

最后的问题:如何删除一个已经添加在事件上的委托?

太容易而且太有意思了:

m_myevent -= m_delegate;

那么这样的几个问题又来了:

1.             如果这个事件上没有该委托,“减掉”以后会出错吗?不会,放心的减吧。

2.             如何调用这个事件上的委托呢?上面有多个委托,它是怎样运行呢?

调用事件上的委托与调用委托上的函数是完全一样的:你要给出与委托申明一样的函数参数,并且调用会返回与申明一样的数据类型。

最后再回来看这个问题:

object m_obj = m_isRight?MyWrite("true"):MyWrite("false");

如何解决它呢?把一个函数赋给一个对象:一个例示(仅做演示解决这个问题,个人认为这样的做法没有实用意义)

using System;
namespace ConsoleApplication1
{
    
public class Class4
    
{
        
event System.EventHandler m_obj;
        
public Class4()
        
{
            System.EventHandler m_f1 
= new EventHandler(SomeFunc1);
            System.EventHandler m_f2 
= new EventHandler(SomeFunc2);
            
bool m_someCondition = false;
            m_obj 
+= m_someCondition?m_f1:m_f1;
            m_obj(
this,null);
        }


        
private void SomeFunc1(object sender, EventArgs args)
        
{
        }


        
private void SomeFunc2(object sender, EventArgs args)
        
{
        }

    }

}


最后看一个完整的例子:

using System;
namespace ConsoleApplication1
{
    
class Class1
    
{
        
//先申明一个委托对象。
        delegate int MyDelegate(object i_object);
        
static event MyDelegate m_myevent;
        [STAThread]
        
static void Main(string[] args)
        
{
            MyDelegate m_delegate 
= new MyDelegate(MyWrite);
            m_delegate(
"This is a delegate object to call the raw function.");
            m_myevent 
+= m_delegate;
            m_myevent 
+= new MyDelegate(MyWrite);
            m_myevent 
+=new MyDelegate(Class1_m_myevent);
            
if(m_myevent!=null)
            
{
                m_myevent(
"This is a event to call the funcaion on the delegate.");
            }
            
        }

        
//该函数是满足上面委托对象的申明的。
        static private int MyWrite(object i_string)
        
{
            Console.WriteLine(i_string);
            
return i_string.ToString().Length;
        }


        
private static int Class1_m_myevent(object i_object)
        
{
            Console.WriteLine(i_object);
            
return 0;
        }

    }

}

 

我们再来看一个.net下标准的事件驱动模型的例子:

using System;

namespace ConsoleApplication1
{
    
public delegate void MyEventHandle(object i_sender,object i_arg);

    
public class Class2
    
{
        
public Class2()
        
{
        }


        [STAThread]
        
static void Main2(string[] args)
        
{
            Class3 m_runOject 
= new Class3();
            m_runOject.OnError 
+= new MyEventHandle(m_runOject_OnError);
            m_runOject.OnSomeThingHappened 
+= new MyEventHandle(m_runOject_OnSomeThingHappened);
            m_runOject.Run();
        }


        
private static void m_runOject_OnError(object i_sender, object i_arg)
        
{
            Console.WriteLine(
"Error in {0}, arg:{1}",i_sender,i_arg);
            Console.WriteLine(
"Object {0} will stop running.",i_sender);
            (i_sender 
as Class3).Stop();
        }


        
private static void m_runOject_OnSomeThingHappened(object i_sender, object i_arg)
        
{
            Console.WriteLine(
"Something happended in {0}, arg:{1}",i_sender,i_arg);
        }

    }



    
public class Class3
    
{
        
public bool m_isStop = false;
        
public event MyEventHandle OnSomeThingHappened;
        
public event MyEventHandle OnError;

        
public Class3()
        
{
        }


        
public void Run()
        
{
            Random m_rand 
= new Random();
            
int m_randomNum = m_rand.Next();
            
while(!m_isStop)
            
{
                
if(m_isStop){break;}
                m_randomNum 
= m_rand.Next(100);
                
if(m_randomNum%5==0)
                
{
                    
if(this.OnError!=null)
                    
{
                        
this.OnError(this,m_randomNum);
                    }

                }

                
else
                
{
                    
if(this.OnSomeThingHappened!=null)
                    
{
                        
this.OnSomeThingHappened(this,m_randomNum);
                    }

                }

            }

        }


        
public void Stop()
        
{
            m_isStop 
= true;
        }

    }

}


好了,全部完了!

 

最后再从另一个角度来理解:函数,委托和事件!

1、             函数,是程序的基本单元,在.net下,有一个很重要的思想,就是:一切对象化!你可把一个int boxing后得到一个object,也可以把一个object unboxing后得到一个int. 可惜,就是没有函数对象化这个概念!?

2、             其实函数也可以对象化!就是通过delegate,委托就是把函数作为对象来处理,使它函数也具有了对象的一些特点。在实例化一个委托的时候,就是把一个函数”boxing”。因此,委托本质上就是一个类!它的初始化参数是一个函数名!不同的委托是不同的类,对应不同类型的函数。

3、             事件是对委托的一个管理封装,它可以很好的动态管理委托,从而完成很多有实用价值的事情,最主要的就是事件!

完全是个人理解,有不同意见,欢迎讨论!

================================
  /\_/\                        
 (=^o^=)  Wu.Country@侠缘      
 (~)@(~)  一辈子,用心做一件事!
--------------------------------
  学而不思则罔,思而不学则怠!  
================================

posted on 2006-11-29 10:09  Wu.Country@侠缘  阅读(7357)  评论(31编辑  收藏  举报