设计模式之迪米特法则

　　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类是相对来说比较稳定的，