按本身的想法去理解事件和泛型（C#）

上一篇那些年困扰咱们的委托(C#)讲了委托，这一篇天然就轮到事件了。

不喜欢官方的表达方式，喜欢按照本身的想法去理解一些抽象的东西，我是一个喜欢简单怕麻烦的人。

事件

考虑到委托使用的一些缺陷，就有了事件。委托是不安全的，打个比方，若是把委托看成共有字段，那么事件就至关因而属性的概念。

事件就是被限制使用的委托变量，事件里面封装了一个多播委托。

事件语法：public event 委托类型 事件名;

事件的做用：事件的做用与委托变量同样，只是功能上比委托变量有更多的限制。好比：只能经过+=或者-=来绑定方法。只能在类内部调用事件。

当一个结果发生时，有可能引发另外的一些反应，这就好像因果关系。而事件则是这个因与果的内部联系。

事件的本质：委托的一个实例，添加了event关键字修饰。

委托是一种类型，事件是委托类型的实例。

和委托的区别：

• 事件不能用=来注册方法。（防止外面直接赋值为null，致使注册失效）
• 事件不能被外部调用（安全性控制）

整个windows系统都是经过事件驱动的，事件都有触发条件。

在WebForm或者WinForm中，咱们常常看到：

        private void button1_Click(object sender, EventArgs e)
        {
            //代码
        }

上面是一个按钮的单击事件。从上能够看到三个事件因素：

• 对象：button
• 事件名：click
• 参数：object sender，事件源，在这里其实就是button，eventArgs e是事件须要的资源数据。

咱们在Winform中都是经过以下的方式来注册事件的。

this.button1.Click += new System.EventHandler(this.button1_Click);

EventHandler就是一个委托：

public delegate void EventHandler(object sender, EventArgs e);

这也就是为何咱们注册的事件老是有sender和e这两个参数，由于委托就是这样声明的。咱们来自定义一个事件：

        public event EventHandler OnSay;
        public Form1()
        {
            InitializeComponent();
            OnSay += Form1_OnSay;
        }

        void Form1_OnSay(object sender, EventArgs e)
        {
            Console.Write("你好吗");
        }

咱们经过Reflector工具来查看：

事件OnSay中，实际上是2个方法，咱们来看下源码：

        public void add_OnSay(EventHandler value)
        {
            EventHandler handler2;
            EventHandler onSay = this.OnSay;
            do
            {
                handler2 = onSay;
                EventHandler handler3 = (EventHandler)Delegate.Combine(handler2, value);
                onSay = Interlocked.CompareExchange<EventHandler>(ref this.OnSay, handler3, handler2);
            }
            while (onSay != handler2);
        }
        public void remove_OnSay(EventHandler value)
        {
            EventHandler handler2;
            EventHandler onSay = this.OnSay;
            do
            {
                handler2 = onSay;
                EventHandler handler3 = (EventHandler)Delegate.Remove(handler2, value);
                onSay = Interlocked.CompareExchange<EventHandler>(ref this.OnSay, handler3, handler2);
            }
            while (onSay != handler2);
        }

 这里能够看出对事件的操做，其实最终仍是体如今对委托的操做。

泛型

为何要有泛型？

更好的实现代码复用，可是它不是经过面向对象的思想来实现代码复用。面向对象惯用的三板斧：封装、继承、多态。

咱们先来看一下代码，假设在一个类中有多个方法，他们的操做很相似，可能仅仅只是传入的参数类型不一样而已

using System;

namespace GenericsDemo
{
    public class MethodTest
    {
        public void IntShow(int i)
        {
            Console.WriteLine(string.Format("IntShow方法，参数类型{0}",i.GetType()));
        }
        public void StrShow(string s)
        {
            Console.WriteLine(string.Format("StrShow方法，参数类型{0}", s.GetType()));
        }
    }
}

若是一个类中存在多个这样的方法，咱们总不能把全部的方法都这么写一遍吧，有没有一种方式来将这些方法进行合并呢？

这个时候咱们会想到Object是任何类型的父类，任何父类出现的地方，均可以使用子类来代替。接下来，咱们来改造一下代码实现：

        public void ObjShow(object obj)
        {
            Console.WriteLine(string.Format("ObjShow方法，参数类型{0}", obj.GetType()));
        }

咱们来看下调用：

            _MethodTest.IntShow(1);
            _MethodTest.StrShow("1");

            _MethodTest.ObjShow(1);
            _MethodTest.ObjShow("1");

方法是合并了，可是如今存在什么样的问题？出现了装箱拆箱，严重影响性能。并且不够安全，由于若是当我把代码进行以下修改时，会发生什么

        public void ObjShow(object obj)
        {
            //Console.WriteLine(string.Format("ObjShow方法，参数类型{0}", obj.GetType()));
            Console.WriteLine(string.Format("ObjShow方法，参数类型{0},参数值{1}", obj.GetType(),Convert.ToInt32(obj)));
        }

调用代码： _MethodTest.ObjShow("a");

编译时不会报错，可是运行时就报错了。也就是说经过object来做为参数传递，实际上是存在严重的安全隐患的。

那么有没有什么办法来解决这两个问题呢？C#2.0泛型的出现正是基于这样的需求。

        public void GenericsShow<T>(T t)
        {
            Console.WriteLine(string.Format("GenericsShow方法，参数类型{0}", t.GetType()));
        }

调用代码：_MethodTest.GenericsShow<int>(1);

这样依赖，泛型方法在申明的时候可以实现相似于Objet的效果，在调用时先肯定类型，这样就达到了安全检查的目的。

泛型就像是使用了一个类型占位符，而这一特性在使用集合时更能体现其强大之处。

也正是因为泛型太强大了，强大得像孙悟空同样，咱们须要弄一道紧箍咒来对其进行束缚，不然不容易控制。这时，就有了泛型约束，它在泛型方法或者泛型委托声明之时就对其进行限定。限定关键字经过where。

   public class Student
    {
        public string Name { get; set; }
    }
        public void StudentShow<T>(T t) where T : Student
        {
            Console.WriteLine(string.Format("GenericsShow方法，参数类型{0}", t.GetType()));
        }
        public void GenericsShow<T>(T t)
        {
            Console.WriteLine(string.Format("GenericsShow方法，参数类型{0}", t.GetType()));
        }
        public void GenericsShow<T>(T t)
        {
            Console.WriteLine(string.Format("GenericsShow方法2，参数类型{0}", t.GetType()));
        }

须要注意的是，这里使用了泛型重载，这个时候编译是能够正常经过的，但是注意了，调用的时候就出现问题了

为何会这样呢？由于泛型的类型参数在编译器并不能肯定其类型，而重载时进行类型检查发送在实例方法被调用时。

同时须要注意的是，当通常方法和泛型方法同时调用时，优先选择通常方法，由于编译器会进行类型推断。

泛型的运用远不止于此，它还支持泛型继承、泛型接口、泛型类、泛型委托等。