把总结写在前面

1）委托是一种类，所以除了能够写在类里面，还可以写到命名空间里面，如下：

2）定义委托的方法是加上delegate修饰，委托不可以直接拿来使用，因为它是一个类，非静态类的使用必须要实例化。但它的实例化方式区别于普通的类，它不需要通过new关键字实例化。

        public delegate void MyDelegate();
        private MyDelegate myEvent;

这段代码myEvent就自动被实例化了，不需要加new关键字。

3）实例化后的委托对象叫做事件，event。很多人搞不明白委托和事件到底什么关系，它们的关系在我看来就是这样的关系。

4）实例化委托的时候，可以加上event修饰，加和不加都不会影响实例化，但是加了，系统就会默认给生成add和remove方法，把set和get方法屏蔽掉，这样外部类尝试去用=添加事件的时候，就会报错，只能用+=。

5）事件的注册都支持简写，下面的四种写法效果都是一样的：

        public delegate void MyDelegate(string str);
        public event MyDelegate MyEvent;
        public Form1()
        {
            InitializeComponent();
            MyEvent += this.Test;
            MyEvent += new MyDelegate(this.Test);
            MyEvent += (str) => { Console.WriteLine("被调用一次"); };
            MyEvent += delegate (string str) { Console.WriteLine("被调用一次"); };
        }
        private void Test(string str)
        {
            Console.WriteLine("被调用一次");
        }

 

以下是委托和事件使用详解部分。

1）定义如下代码：

    public class EventTest
    {
        public delegate void MyDelegate();
        public MyDelegate MyEvent;
        public void Invoke()
        {
            MyEvent?.Invoke();
        }
    }

写下面的测试代码：

        public Form1()
        {
            InitializeComponent();
            EventTest eventTest = new EventTest();
            eventTest.MyEvent = new EventTest.MyDelegate(Test);
            eventTest.MyEvent = new EventTest.MyDelegate(Test);
            eventTest.Invoke();
        }
        private void Test()
        {
            Console.WriteLine("被调用一次");
        }

控制台输出结果：

2）如果你把等于号改成+=，也就是这么写：

        public Form1()
        {
            InitializeComponent();
            EventTest eventTest = new EventTest();
            eventTest.MyEvent += new EventTest.MyDelegate(Test);
            eventTest.MyEvent += new EventTest.MyDelegate(Test);
            eventTest.Invoke();
        }
        private void Test()
        {
            Console.WriteLine("被调用一次");
        }

输出结果为：

由此我们可以看出来=和+=的区别，如果重写事件，就用=，如果多次注册，就用+=。

3）如果在定义的时候加上event：

    public class EventTest
    {
        public delegate void MyDelegate();
        public event MyDelegate MyEvent;
        public void Invoke()
        {
            MyEvent?.Invoke();
        }
    }

那么在使用=的时候 ，就会报错：

但是有一种情况是不会报错的：

        public delegate void MyDelegate();
        public event MyDelegate MyEvent;
        public Form1()
        {
            InitializeComponent();
            EventTest eventTest = new EventTest();
            MyEvent = new MyDelegate(Test);
            MyEvent = new MyDelegate(Test);
            MyEvent.Invoke();
        }
        private void Test()
        {
            Console.WriteLine("被调用一次");
        }

这是什么原因呢，其实是因为当你在定义委托的时候，系统会自动给你加上add和remove方法，这个方法是public，这个时候这个委托就缺少了get和set方法了，那么在类之外自然是无法访问它，可是在同一个类里面，有没有get和set方法都是是没有任何访问限制的，所以才会出现这个结果，看下面的代码：

        public delegate void MyDelegate();
        private MyDelegate myEvent;
        public event MyDelegate MyEvent
        {
            add
            {
                this.myEvent += value;
            }
            remove
            {
                this.myEvent -= value;
            }
        }
        public Form1()
        {
            InitializeComponent();
            EventTest eventTest = new EventTest();
            MyEvent = new MyDelegate(Test);
            MyEvent = new MyDelegate(Test);
            MyEvent.Invoke();
        }
        private void Test()
        {
            Console.WriteLine("被调用一次");
        }

编译器会报错：

应该说加了event的完整写法是上面这样写的，也可以不写add和remove，算是一种简写，效果是一样的。

4）思考这样一个需求，一个事件，我们只希望它被注册一次，应该怎样做呢，参考下面的代码：

    public class EventTest
    {
        public delegate void MyDelegate();
        public MyDelegate MyEvent { set; private get; }
        public void Invoke()
        {
            MyEvent?.Invoke();
        }
    }

这样写之后，如果你再尝试使用+=，比如下面这样：

        public Form1()
        {
            InitializeComponent();
            EventTest eventTest = new EventTest();
            eventTest.MyEvent += new EventTest.MyDelegate(this.Test);
            eventTest.MyEvent += new EventTest.MyDelegate(this.Test);
            eventTest.Invoke();
        }
        private void Test()
        {
            Console.WriteLine("被调用一次");
        }

编译器就会报错：