Delegate Event

    public delegate void tspEventHander();
    //delegate 是关键词,【注：EventHandler是一个声明委托的微软C#的命名标准，我的习惯是标准就要第一时间说，也就这个命名习惯要第一时间养成】

    // public void BugTickEventHandler() { 方法体}
    // 区别知道了吧，在现实生活中，委托只是个命令，做事情是别人，而在程序世界里委托只是存储了各个方法的地址(方法的容器)。

    public class tsp
    {
        public static void BuyTicket()
        {
            Console.WriteLine("tsp,申明了委托就自然要想到委托对应的方法(委托是方法的容易嘛)！");
        }
        public static void BuyMovieTicket()
        {
            Console.WriteLine("t_sp，申明委托的时候后面记得加上EventHander，这个是标准的命名规范！");
        }
    }

    class Program
    {
        static void Main(string[] args)
        {
            tspEventHander sp = new tspEventHander(tsp.BuyTicket);
            sp += tsp.BuyMovieTicket;
            sp();

            tspEventHander sp1 = new tspEventHander(delegate() { Console.WriteLine("你好啊我是匿名委托方法"); });
            sp1();

            tspEventHander sp2 = new tspEventHander(()=>Console.WriteLine("你好啊我是lambda"));
            sp2();
            Console.ReadKey();
        }
    }

　　Event：

    class Program
    {
        /*事件的发生一般都牵扯2个角色
          事件发行者（Publisher）:一个事件的发行者，也称作是发送者（sender），其实就是个对象，这个对象会自行维护本身的状态信息，当本身状态信息变动时，便触发一个事件，并通知说有的事件订阅者。
          事件订阅者（Subscriber）:对事件感兴趣的对象，也称为Receiver，可以注册感兴趣的事件，在事件发行者触发一个事件后，会自动执行这段代码。*/
        public class Publisher
        {
            //声明一个出版的委托
            public delegate void PublisherEventHandler();
            //在委托的机制下我们建立以个出版事件
            public event PublisherEventHandler Onpublisher;

            public void Issue()
            {
                if (Onpublisher!=null)
                {
                   Console.WriteLine("我想你了你确不知道,我把我的思念寄托在xx可得到是NULL");
                    Onpublisher();
                }
            }
        }

        //订阅者
        public class Mrtsp
        {
            //对事件感兴趣的事情，这里指对发布者感兴趣
            public static void Receive()
            {
                Console.WriteLine("我是tsp!");
            }
        }

        //订阅者，悲情人物t_sp
        public class Mrt_sp
        {
            //对事件感兴趣的事情
            public static void Receive()
            {
                Console.WriteLine("你不知道的事情 学习的东西好多 可精通的没多少 哎!");
            }
        }

        static void Main(string[] args)
        {
            Publisher pub = new Publisher();
            pub.Onpublisher += new Publisher.PublisherEventHandler(Mrtsp.Receive);

            //另一种事件注册方式
            pub.Onpublisher +=Mrt_sp .Receive;

            pub.Issue();
            Console.ReadKey();
        }
    }

上面Event：+=应该放到对象注册类 内部 这样才能体现封装对应修改代码：

    class Program
    {
        /*事件的发生一般都牵扯2个角色
          事件发行者（Publisher）:一个事件的发行者，也称作是发送者（sender），其实就是个对象，这个对象会自行维护本身的状态信息，当本身状态信息变动时，便触发一个事件，并通知说有的事件订阅者。
          事件订阅者（Subscriber）:对事件感兴趣的对象，也称为Receiver，可以注册感兴趣的事件，在事件发行者触发一个事件后，会自动执行这段代码。*/
        public class Publisher
        {
            //声明一个出版的委托
            public delegate void PublisherEventHandler();
            //在委托的机制下我们建立以个出版事件
            public event PublisherEventHandler Onpublisher;

            public void Issue()
            {
                if (Onpublisher != null)
                {
                    Console.WriteLine("我想你了你确不知道,我把我的思念寄托在xx可得到是NULL");
                    Onpublisher();
                }
            }
        }

        //订阅者
        public class MrtspReceiver
        {
            //对事件感兴趣的事情，这里指对发布者感兴趣
            public MrtspReceiver(Publisher publisher)
            {
                //产生一个委托实例并添加到PublisherEventHandler产生的事件列表中
                publisher.Onpublisher += new Publisher.PublisherEventHandler(Receive);
            }
            //事件处理函数
            public static void Receive()
            {
                Console.WriteLine("我是tsp!");
            }
        }

        //订阅者，悲情人物t_sp
        public class Mrt_spReceiver
        {
            //对事件感兴趣的事情，这里指对发布者感兴趣
            public Mrt_spReceiver(Publisher publisher)
            {
                //产生一个委托实例并添加到PublisherEventHandler产生的事件列表中
                publisher.Onpublisher += new Publisher.PublisherEventHandler(Receive);
            }

            //事件处理函数
            public static void Receive()
            {
                Console.WriteLine("你不知道的事情 学习的东西好多 可精通的没多少 哎!");
            }
        }

        static void Main(string[] args)
        {
            //实例化一个事件发送方
            Publisher publisher = new Publisher();

            //实例化一个事件接收方
            Mrt_spReceiver eventReceiver = new Mrt_spReceiver(publisher);
            MrtspReceiver Mrtsp = new MrtspReceiver(publisher);

            publisher.Issue();
            Console.ReadKey();
        }
    }

　　

总结：委托就是方法的容器  事件就是委托的约束