12事件

继续上一篇：11委托演绎中国足球队打进世界杯  

□ 含有相同参数列表的各种处理球方法不变，把带委托参数的方法放到一个类中

namespace ConsoleApplication11
{
    class Program
    {
        static void Main(string[] args)
        {
            GameManager gm = new GameManager();
            gm.Game("球",PassBall);
            Console.WriteLine();
            gm.Game("球",TransferpBall);
            Console.ReadKey();
        }

        private static void PassBall(string ball)
        {
            Console.Write("传" + ball);
        }

        private static void StopBall(string ball)
        {
            Console.Write("停/接" + ball);
        }

        private static void TransferpBall(string ball)
        {
            Console.Write("转移" + ball);
        }

        private static void RunBall(string ball)
        {
            Console.Write("带" + ball);
        }

        private static void ScoreBallByHead(string ball)
        {
            Console.Write("头"+ball + "射门");
        }

        private static void ScoreBallByInnerFeet(string ball)
        {
            Console.Write("推射" + ball + "射门");
        }

        private static void ScoreBallByOuterFeet(string ball)
        {
            Console.Write("外脚背射" + ball + "门");
        }
    }
    public delegate void PlayBall(string ball);

    public class GameManager
    {
        public void Game(string ball, PlayBall playBallDelegate)
        {
            playBallDelegate(ball);
        }
    }
}

 

结果：

 

□ 采用多播委托，把多个方法绑定到同一个委托变量

            GameManager gm = new GameManager();
            PlayBall del = PassBall;
            del += RunBall;
            gm.Game("球",del);
            Console.ReadKey();

 

当然也可以：

□ 把委托封装到类中

    class Program
    {
        static void Main(string[] args)
        {
            GameManager gm = new GameManager();
            gm.delegate1 = ScoreBallByHead;
            gm.delegate1 += ScoreBallByInnerFeet;
            gm.Game("球", gm.delegate1);
            Console.ReadKey();
        }
        .....
    }
    public delegate void PlayBall(string ball);

    public class GameManager
    {
        public PlayBall delegate1;
        public void Game(string ball, PlayBall playBallDelegate)
        {
            playBallDelegate(ball);
        }
    }

 

结果：

 

还可以把gm.Game("球", gm.delegate1)改成类似gm.Game("球")，达到这样的效果，需要在Game()方法体内让委托变量来执行方法。

□ 直接调用类的实例方法，不带委托参数

   class Program
    {
        static void Main(string[] args)
        {
            GameManager gm = new GameManager();
            gm.delegate1 = PassBall;
            gm.delegate1 += ScoreBallByOuterFeet;
            gm.Game("球");
            Console.ReadKey();
        }
        ......
    }
    public delegate void PlayBall(string ball);

    public class GameManager
    {
        public PlayBall delegate1;
        public void Game(string ball)
        {
            if (delegate1 != null)
            {
                delegate1(ball);
            }
        }
    }

 

结果：

 

依然存在的问题是：
1、把委托字段成delegate1声明成public,客户端可以随意赋值，破坏了对象的封闭原则。
2、如果把委托字段成delegate1声明成private，客户端就不能调用。
3、给委托赋值用=，给委托注册用+=,好像也不是很统一。

 

□ 事件就此登上历史舞台

    class Program
    {
        static void Main(string[] args)
        {
            GameManager gm = new GameManager();
            gm.event1 = PassBall;
            gm.event1 += ScoreBallByOuterFeet;
            gm.Game("球");
            Console.ReadKey();
        }
        ......
    }
    public delegate void PlayBall(string ball);

    public class GameManager
    {
        public event PlayBall event1;
        public void Game(string ball)
        {
            event1(ball);
        }
    }

 

事件可以看成：
为委托类型量身定制的属性。

编译时就报错，运行也报错：

 

使用事件的好处：
限制含有事件类型的能力，即事件应该由事件的发布者触发，而不应该由事件的客户端来触发。

 

□ 事件的一个例子

namespace ConsoleApplication12
{
    class Program
    {
        static void Main(string[] args)
        {
            Publisher publisher = new Publisher(2);
            Subscriber subscriber = new Subscriber();

            publisher.NumberChanged += new NumberChangedEventHandler(subscriber.OnNumberChanged);
            publisher.DoSth();
            Console.ReadKey();
        }
    }

    //定义委托
    public delegate void NumberChangedEventHandler(int count);

    //事件发布者
    public class Publisher
    {
        private int count;
        public event NumberChangedEventHandler NumberChanged;

        public Publisher(int count)
        {
            this.count = count;
        }

        public void DoSth()
        {
            Console.WriteLine("我是发布者，我开始工作了~~");
            if (NumberChanged != null)
            {
                count++;
                NumberChanged(count);
            }
        }
    }

    //定义事件订阅者
    public class Subscriber
    {
        public void OnNumberChanged(int count)
        {
            Console.WriteLine("我知道了，现在的数量是：" + count);
        }
    }
}

结果：

 

关于事件的小结：
● 在委托的前面加上关键字event，就变成了事件public event NumberChangedEventHandler NumberChanged
● 一旦声明成事件，只能通过事件所在类(发布者)的方法来触发事件：publisher.DoSth();

 

订阅者的和发布者的惯例：
● 如果想运行订阅者的方法触发事件public delegate void NumberChangedEventHandler(int count)，从而让订阅者也触发相应的方法，那订阅者的方法OnNumberChanged(int count)的参数列表和事件一致，并且是在事件变量NumberChanged前面加上On变成OnNumberChanged。

● 订阅者是通过publisher.NumberChanged += new NumberChangedEventHandler(subscriber.OnNumberChanged)绑定到发布者的事件，建立触发关联的。

 

参考资料：
※ 《.NET之美》--张子阳,感谢写了这么好的书！