设计原则：依赖注入原则

依赖倒置原则，是一种程序设计模式的原则
高层模块不应该依赖底层模块，二者都应该依赖其抽象。
抽象不应该依赖细节，细节应该依赖抽象。依赖导致原则很好的体现了“面向接口编程”的思想。
Ioc容器是由依赖注入框架提供的，它是依赖注入框架中最主要的东西，它主要用来映射依赖管理对象创建和生存周期。

高耦合例子

这里是一个爸爸给孩子讲故事的例子，都是通过new来实例化类

class Program
    {
        static void Main(string[] args)
        {
            Father father = new Father();
            father.Read();
        }
    }

    public class Book
    {
        public string GetContent()
        {
            return "很久很久以前，有个人叫盘古";
        }
     }

    public class Father
    {
        public void Read()
        {
            Book book = new Book();
            Console.WriteLine("爸爸开始讲故事了");
            Console.WriteLine(book.GetContent());
        }
    }

突然有一天，孩子不想听故事了，想听报纸上的内容。这里有需要添加一个报纸类

class Program
    {
        static void Main(string[] args)
        {
            Father father = new Father();
            father.Read();
        }
    }

    public class Book
    {
        public string GetContent()
        {
            return "很久很久以前，有个人叫盘古";
        }
     }

    public class paper
    {
        public string GetContent()
        {
            return "报纸内容。。。。";
        }
    }

    public class Father
    {
        public void Read()
        {
            //Book book = new Book();
            //Console.WriteLine("爸爸开始讲故事了");
            //Console.WriteLine(book.GetContent());

            paper paper = new paper();
            Console.WriteLine("爸爸开始读报纸了");
            Console.WriteLine(paper.GetContent());
        }
    }

这里发现 Father 被修改了，突然有一天小孩又想听看网页上的新闻。。。这里Father内容是不是又要修改了呢？ 那肯定是的，这样Father会不断的被修改，耦合度太高，导致代码被频繁修改。这里能不能解耦呢？哎，那就用接口吧，降低耦合。来定义个接口

 public interface IReader
    {
        string GetContent();
    }

解耦例子

让 Book和paper 继承 IReader

 class Program
    {
        static void Main(string[] args)
        {
            //先来读书
            Father father = new Father(new Book());
            father.Read();
        }
    }

    public interface IReader
    {
        string GetContent();
    }

    public class Book:IReader
    {
        public string GetContent()
        {
            return "很久很久以前，有个人叫盘古";
        }
     }

    public class Paper : IReader
    {
        public string GetContent()
        {
            return "报纸内容。。。。";
        }
    }

    public class Father
    {

        public IReader Reader { get; set; }
        //通过构造函数实例化接口
        public Father(IReader reader) {
            Reader = reader;
        }
        public void Read()
        {
            //Book book = new Book();
            //Console.WriteLine("爸爸开始讲故事了");
            //Console.WriteLine(book.GetContent());

            //paper paper = new paper();
            //Console.WriteLine("爸爸开始读报纸了");
            //Console.WriteLine(paper.GetContent());

            Console.WriteLine("爸爸开始了。。");
            Console.WriteLine(Reader.GetContent());

        }
    }

在换一下Paper

 static void Main(string[] args)
  {
            //先来读书
            Father father = new Father(new Paper());
            father.Read();
  }

这样就实现了**解耦**。不用频繁修复Father，而是在调用的时候，随便调用。

---

版权属于：LCQ（除特别注明外）

原文链接：https://www.cnblogs.com/youmingkuang/p/11963404.html

本站文章采用 知识共享署名4.0 国际许可协议 进行许可，请在转载时注明出处及本声明！