泛型委托简化事件处理-优快云博客

先来看一下典型的Window控件的事件处理方式,举两个例子,一个Button的MouseClick事件,一个LinkLabel的LinkClicked事件:

this.button1.MouseClick += new System.Windows.Forms.MouseEventHandler(this.button1_MouseClick);

this.linkLabel1.LinkClicked += new System.Windows.Forms.LinkLabelLinkClickedEventHandler(this.linkLabel1_LinkClicked);

这两个事件分别是两个委托类型:MouseEventHandler,LinkLabelLinkClickedEventHandler.再来看看这两个委托的定义:

public delegate void MouseEventHandler(object sender, MouseEventArgs e);

public delegate void LinkLabelLinkClickedEventHandler(object sender, LinkLabelLinkClickedEventArgs e);

现在,我们有了泛型委托,还需要两个委托吗?:)呵,这两个委托完全可以采用一个泛型委托就搞定了.

public delegate void GenericEventHandler<Sender,GenericEventArgs>(Sender sender,GenericEventArgs e) where GenericEventArgs : EventArgs;

    (请注意泛型委托的约束where GenericEventArgs : EventArgs是为了遵循.net的事件模式,所有的事件参数必须继承自EventArgs.要不然,就真的成"胡言乱语"了:)
    哈.既然能这样了, .net中所有的void xxxxEventHandler(xxx,xxx);现在不都可以通过这么一个泛型委托就搞定了?嘿嘿.所有这类的事件处理代码看起来都统一了.并且,这样还能得到类型安全的好处.我们在响应事件的时候,再也不用将object sender强制转换成发出事件的实际类型.哈哈.好处好真是"大大的"哦.:)那是不是在.net 2.0里面已经这样处理了呢?我急匆匆的打开VS 2005,发现事件委托还是老的,没有用泛型委托,郁闷.:(哈.肯定是MS闲改动起整个.net的委托来太麻烦了,姑且这么认为吧.哈:)
    于是,我自己写了个小例子验证这种做法:
    首先,定义一个泛型委托:

public delegate void GenericEventHandler<ParamOne,ParamTwo>(ParamOne paramOne,ParamTwo paramTwo);

然后定义两个不同的类,他们包含两个不同的事件,但该事件的类型都是同一个委托----这个泛型委托:

class TestClassOne
    {
        public string identifier = "TestClassOne";
        public event GenericEventHandler<TestClassOne,TestClassOneEventArgs> TestClassEvent;
        public class TestClassOneEventArgs : EventArgs 
        {
            public string message;
            public TestClassOneEventArgs(string message)
            {
                this.message = message;
            }
        }
        protected virtual void OnTestClassEvent(TestClassOneEventArgs e)
        {
            if (TestClassEvent != null)
            {
                TestClassEvent(this, e);
            }
        }
        public void MessageArrive(string message)
        {
            TestClassOneEventArgs e = new TestClassOneEventArgs(message);
            OnTestClassEvent(e);
        }
    }

    class TestClassTwo
    {
        public string identifier = "TestClassTwo";
        public event GenericEventHandler<TestClassTwo, TestClassTwoEventArgs> TestClassEvent;
        public class TestClassTwoEventArgs : EventArgs
        {
            public string message;
            public TestClassTwoEventArgs(string message)
            {
                this.message = message;
            }
        }
        protected virtual void OnTestClassEvent(TestClassTwoEventArgs e)
        {
            if (TestClassEvent != null)
            {
                TestClassEvent(this, e);
            }
        }
        public void MessageArrive(string message)
        {
            TestClassTwoEventArgs e = new TestClassTwoEventArgs(message);
            OnTestClassEvent(e);
        }
    }

现在,来看怎么使用泛型委托:

        static void Main(string[] args)
        {
            TestClassOne one = new TestClassOne();
            one.TestClassEvent += new GenericEventHandler<TestClassOne, TestClassOne.TestClassOneEventArgs>(one_TestClassEvent);
            TestClassTwo two = new TestClassTwo();
            two.TestClassEvent += new GenericEventHandler<TestClassTwo, TestClassTwo.TestClassTwoEventArgs>(two_TestClassEvent);

            one.MessageArrive("hello,woody");
            two.MessageArrive("hello,jeff");
        }

        static void two_TestClassEvent(TestClassTwo paramOne, TestClassTwo.TestClassTwoEventArgs paramTwo)
        {
            Console.WriteLine(paramOne.identifier + "has received message:" + paramTwo.message);
        }

        static void one_TestClassEvent(TestClassOne paramOne, TestClassOne.TestClassOneEventArgs paramTwo)
        {
            Console.WriteLine(paramOne.identifier + "has received message:" + paramTwo.message);
        }

哈哈.感觉这样做的两个主要好处是:
一,原来在.net里面需要写两个委托,现在只有用一个委托就搞定.当然不仅仅是两个委托可以用这个泛型委托来代替,只要委托的签名符合这个泛型委托就可以了(在我的例子里,只要是两个参数的委托都可以.其实,还可以增加一个返回值的泛型参数,这样是不是更加爽啊^0^,我们可以象下面这样定义这个泛型委托).

public delegate ReturnType GenericEventHandler<ParamOne, ParamTwo, ReturnType>(ParamOne paramOne, ParamTwo paramTwo);

二,看看我们的事件处理函数,现在再也不用出现(TestClassOne)sender的强制转换的代码了.用户可以直接使用这个强类型的sender,哈.是不是觉得很爽啊:)反正我是这么觉得的.-_-!

泛型委托实例