c#中的事件

之前的博客讲到委托，委托本质上是将方法作为方法的参数传给方法。实际开发中，实现某个功能的的代码通常会封装成一个类，本例中字符串处理封装成MyStringProc类，

代码如下：

namespace DelegateTest
{
    public delegate string MyStringProcDelegate(string str);
    class MyStringProc
    {
        public string ProcString(string str,MyStringProcDelegate strProcDelegate)
        {
            return strProcDelegate(str);
        }
    }
}

在调用的时候实例化这个类，再调用对应的方法。如下：

namespace DelegateTest
{
    class Program
    {
        static void Main(string[] args)
        {
            MyStringProc msp = new MyStringProc();
            string str1=msp.ProcString("I am good.", StringToLower);
            string str2 = msp.ProcString("I am good too", StringToUpper);
            Console.WriteLine("{0},{1}",str1,str2);
            Console.ReadKey();
        }
        static string StringToLower(string str)
        {
            return str.ToLower();
        }
        static string StringToUpper(string str)
        {
            return str.ToUpper();
        }
    }
}

输出如下：

 

现在如果要实现某个功能，这个功能包含多种类型但操作参数都相同，只是内部逻辑不同，而且要依次调用其中几个，这时我们可以只定义一个委托变量，将这些操作的方法依次绑定到这个委托变量即可。

下面是处理一个字符串：字符串前后加'[]'，前后后加'{}'，代码如下：

class Program
    {
        static void Main(string[] args)
        {
            MyStringProc msp = new MyStringProc();
            MyStringProcDelegate strProcDelegate;
            strProcDelegate = StringProc1;
            strProcDelegate += StringProc2;
            msp.ProcString("I am a good boy",strProcDelegate);
            Console.ReadKey();
        }

        static string StringProc1(string str)
        {
            str= "["+str+"]";
            Console.WriteLine(str);
            return str;
        }
        static string StringProc2(string str)
        {
            str= "{" + str + "}";
            Console.WriteLine(str);
            return str;
        }
    }

输出如下：

以上并没有达到完全封装，本例用到的MyStringProcDelegate类型的委托变量是可以封装在MyStringProc类中，客户端直接调用该类的方法即可，无需再声明委托变量。如下：

public delegate string MyStringProcDelegate(string str);
    class MyStringProc
    {
        public MyStringProcDelegate strProcDelegate;
        public string ProcString(string str)
        {
            if (strProcDelegate!=null)
                str=strProcDelegate(str);
            return str;
        }
    }

调用代码如下：

class Program
    {
        static void Main(string[] args)
        {
            MyStringProc msp = new MyStringProc();
            msp.strProcDelegate = StringProc1;
            msp.strProcDelegate += StringProc2;
            msp.ProcString("I am a good boy");
            Console.ReadKey();
        }
        static string StringProc1(string str)
        {
            str= "["+str+"]";
            Console.WriteLine(str);
            return str;
        }
        static string StringProc2(string str)
        {
            str= "{" + str + "}";
            Console.WriteLine(str);
            return str;
        }
    }

输出如下：

 

事件

上面的改进无需再客户端声明委托变量，直接调用功能类的方法即可，但是委托变量声明成了public类型，意思就是说客户端可以随意操作该委托变量，破环了面向对象中的封装性。

假如我们将委托变量进行封装，类似于对字段的封装成属性，在c#中event就是对委托类型变量的一种封装，加上event关键字实际上是将普通的委托封装成具有Add和Remove方法

的一种特殊的委托，后面我用reflector反编译工具查看。

 

代码修改如下：

public delegate string MyStringProcDelegate(string str);
    class MyStringProc
    {
        public event MyStringProcDelegate strProcDelegate;
        public string ProcString(string str)
        {
            if (strProcDelegate != null)
                str = strProcDelegate(str);
            return str;
        }
    }

调用方法如下：

class Program
    {
        static void Main(string[] args)
        {
            MyStringProc msp = new MyStringProc();
            msp.strProcDelegate += StringProc1;
            msp.strProcDelegate += StringProc2;
            msp.ProcString("I am a good boy");
            Console.ReadKey();
        }
        static string StringProc1(string str)
        {
            str= "["+str+"]";
            Console.WriteLine(str);
            return str;
        }
        static string StringProc2(string str)
        {
            str= "{" + str + "}";
            Console.WriteLine(str);
            return str;
        }
    }

输出如下：

这样做的好处是，限定了委托的使用，可防止已注册该事件的方法被非法调用。注：事件只能用+=或-=。

下面是对定义的strProcDelegate 变量反编译结果，从中可看出我们在类中定义的该委托变量最终会编译成add、remove两个方法，add为对委托注册方法，remove为对委托取消注册方法。

 

而且虽然strProcDelegate 变量声明称public，但最终会编译成private，如下：

 

MyStringProcDelegate委托类型最终编译如下：