设计模式之迪米特法则

　　What

　　Least Konwledge Principle(LCP)：最少知识原则，一个对象应该对其他的对象了解的最少。

　　Why

　　降低系统的耦合度，使类与类之间保持松散的耦合关系。

　　How

　　员工类

    class Employee

    {

        private string name;



        public string Name

        {

            get { return name; }

            set { name = value; }

        }

    }

　　老板类

   class Boss

    {

        private List<Employee> employees;



        public List<Employee> Employees

        {

            get { return employees; }

            set { employees = value; }

        }



        //将消息通知到各个员工

        public void Notify(string message)

        {

            foreach (var item in Employees)

            {

                Console.WriteLine(item.Name + message);

            }

        }

    }

　　客户端调用

    class Program

    {

        static void Main(string[] args)

        {

            Boss boss = new Boss();

            boss.Employees = new List<Employee>();

            boss.Employees.Add(new Employee() { Name = "张三" });

            boss.Employees.Add(new Employee() { Name = "李四" });



            boss.Notify("放假一天观看世界杯决赛");



            Console.ReadLine();

        }

    }

　　需求是完成了，但是我们来细想一下其中类之间的关系。对于Boss类来说，他需要知道所有员工，并且如果有消息的话，需要一个一个通知员工，对于规模不大的公司可能这样的是可行的，但是如果是大规模的公司，这样明显是不合适的，老板不需要知道每一个员工，老板是要做出决定，通知这种事情应该是由行政部门来协调。Boss知道了他不需要知道的事情，承担了他没有必要承担的职责，这样一个类的职责过重，也增加了类之间的耦合性，我们软件设计的目标是高耦合、低内聚。那么现实中，老板是有秘书的，一般是由秘书来完成这些工作，那么我们这里就新增一个秘书类，目前，秘书的职责是将老板宣布的消息通知相关人员（需求以后可能会改，可能增加了各个部门，通知部门等等，但我们不需要过度设计，而是当发生了小变化的时候及时做出改变）。

　　秘书类

   class Secretary : Employee

    {

        private List<Employee> employees;



        public List<Employee> Employees

        {

            get { return employees; }

            set { employees = value; }

        }



        //将消息通知到各个员工

        public void Notify(string message)

        {

            foreach (var item in Employees)

            {

                Console.WriteLine(item.Name + message);

            }

        }

    }

　　老板类

   class Boss

    {

        private Secretary bossSecretary;



        public Secretary BossSecretary

        {

            get { return bossSecretary; }

            set { bossSecretary = value; }

        }



        public void AnnounceMessage(string message)

        {

            if (BossSecretary != null)

            {

                BossSecretary.Notify(message);

            }

        }

    }

客户端调用

    class Program

    {

        static void Main(string[] args)

        {

            Boss boss = new Boss();

            Secretary secretary = new Secretary() { Name = "小丽" };



            secretary.Employees = new List<Employee>();

            secretary.Employees.Add(new Employee() { Name = "张三" });

            secretary.Employees.Add(new Employee() { Name = "李四" });

            secretary.Employees.Add((Employee)secretary);



            boss.BossSecretary = secretary;

            boss.AnnounceMessage("放假一天观看世界杯决赛");



            Console.ReadLine();

        }

    }

　　这样的改变之后，类之间的结构就更加的清晰和稳定，达到了松耦合的效果，Boss类与Employee类现在比较松散，在设想以后成立了新的部门的时候，我们也只需要对秘书类进行相应的处理，而Boss类是相对来说比较稳定的，