寻根究底，委托到底有神马好处

上次导师制开会，朱丹说再看大话设计模式，问我“委托到底有神马好处”，扪心自问，一时答不上来。

先来模拟个场景:我在打游戏,但运气不好每次打游戏都会被主管看到,老板当然不喜欢他的员工在上班的时间打游戏,所以老板就跟主管说:以后员工在打游戏,你就扣他20块钱。

这其实就是一个委托,老板委托主管一旦发现员工打游戏,就做一件事情.

 

程序模拟：至少有2个类,主管与员工,主管有个方法扣钱,员工有个方法玩游戏。

一般程序实现

员工类:

public classEmployee

     {

         //员工的薪水

         private int money;

         //该员工的主管   

         private Manager Manager;

         public Employee(Manager manager)

         {

             // 通过构造函数，初始化员工的主管与薪水。

              Manager = manager; 

              money = 8000;

         }

         public int Money

         {

             get { return money; }

             set { money = value; }

         }

         public void PlayGame()

         {

             System.Diagnostics.Debug.WriteLine("员工:开始玩游戏了..");

             System.Diagnostics.Debug.WriteLine("员工:CS真好玩，哈哈哈！ 我玩...");

             Manager.RemoveMoney(this);

         }

     }

 

主管类:

     

public classManager

    {

       public Manager()

        {

        }

       //扣薪水

       public void RemoveMoney(Employee employee)

        {

            System.Diagnostics.Debug.WriteLine("主管：上班时间胆敢玩游戏");

            System.Diagnostics.Debug.WriteLine("主管：看看你小子有多少薪水:" + employee.Money);

            System.Diagnostics.Debug.WriteLine("主管：我开始扣薪水...");

            employee.Money -= 20;

            System.Diagnostics.Debug.WriteLine("主管：扣好了.");

            System.Diagnostics.Debug.WriteLine("主管：看看你小子薪水剩余：" + employee.Money);

        }

    }

 
public static void Main(string[] args)       {
           // 生成主管类的对象实例 king
           Manager king = new Manager();
 
           // 生成员工类类的对象实例 wind
           Employee wind = new Employee(king);
 
           // 员工开始玩游戏
           wind.PlayGame();
        }

 

  运行结果：

员工:开始玩游戏了..

员工:CS真好玩，哈哈哈！我玩...

主管：上班时间胆敢玩游戏

主管：看看你小子有多少薪水:8000

主管：我开始扣薪水...

主管：扣好了.

主管：看看你小子薪水剩余：7980

 

下面我们简单的分析下这个程序:

1:在创建主管类之后才能创建员工类,耦合性太高,也就是说你要创建个员工,必须要先创建个主管。

2:如果场景发生以下变化,我要让经理代替主管,我们不得不修改员工类,并增加经理类.

这样看来这段程序设计的并不好,没有把变化的部分抽出来，导致对修改关闭。

 

事件实现

必须要定义一个委托,就是让主管监视员工,然后员工类里要有个事件(员工也是激发该事件的对象),主管执行事件

 

public delegate void Play(ObjectSender, System.EventArgs e);

 
 public class Employee

    {

       public int money = 2200;//懒得写属性了..

       public event Play play;

       public Employee()

        {

        }

       public void PlayGame()

        {

            System.EventArgs e = new EventArgs();

            OnPlayGame(this, e);

        }

       void OnPlayGame(object Sender, EventArgs e)

        {

            if (play != null)

            {

                play(Sender, e);

            }

        }

    }

主管类就要实现一个方法,这个方法与委托的返回直一样,参数一样就行了,给委托来调用的.:

 

public class Manager

    {

       public Manager()

        {

        }

       public void RemoveMoney(Object Sender, System.EventArgs e)

        {

            Employee emp = Sender as Employee;

            emp.money -= 20;

            System.Diagnostics.Debug.WriteLine(emp.money);

        }

    }

那么调用就变的简单了

public static void Main(string[] args)        {
       Manager king= new Manager();

            Employee emp= new Employee();

 
            // 设下委托，指定监视

            emp.play += new Play(king.RemoveMoney);

 
            // 员工开始玩游戏,玩一次扣一次

            emp.PlayGame();

            emp.PlayGame();

 }

输出:

2180

2160

 

 

总结：

委托定义了自己的规范，凡是符合自己标准的，都能够被我所用。如果增加个经理类，符合该委托的规范就够了，员工类并不会做修改，即可实现经理监视员工。

 

由此看来：优秀的设计，主要在于能够应对变化，未雨绸缪。把可能发生的事情考虑到了，并做好相应的应对工作，而在程序中，只是用代码表现出来罢了。

 

 

参考

什么时候该用委托,为什么要用委托,委托有什么好处....