任何非平凡的应用程序都由两个或多个类组成，它们相互协作以执行某些业务逻辑。传统上，每个对象都负责获取自己对与其协作的对象（其依赖关系）的引用。在应用DI时，对象在创建时由协调系统中每个对象的某个外部实体赋予其依赖性。换句话说，依赖项被注入到对象中。

有关详细信息，请参阅此处输入链接描述

这意味着对象应该只具有完成其工作所需的依赖项，并且依赖项应该很少。此外，如果可能的话，对象的依赖关系应该是接口，而不是“具体”对象。（具体对象是用关键字new创建的任何对象。）松散耦合促进了更高的可重用性，更容易维护，并允许您轻松地提供“模拟”对象来代替昂贵的服务。

“依赖注入”（DI）也称为“控制反转”（IoC），可以用作鼓励这种松散耦合的技术。

实施DI有两种主要方法：

构造函数注入设值注入

构造函数注入

这是一种将对象依赖关系传递给构造函数的技术。

注意，构造函数接受接口而不是具体对象。此外，请注意，如果orderDao参数为空，则会引发异常。这强调了接受有效依赖的重要性。在我看来，构造函数注入是赋予对象依赖关系的首选机制。在调用对象时，开发人员很清楚需要向“Person”对象提供哪些依赖关系才能正确执行。

沉淀剂注入

但是考虑下面的例子……假设您有一个类，它有十个没有依赖关系的方法，但是您要添加一个新方法，它确实依赖于IDAO。您可以将构造函数更改为使用构造函数注入，但这可能会迫使您更改所有的构造函数调用。或者，您可以添加一个新的构造函数来获取依赖项，但是开发人员如何轻松地知道何时使用一个构造函数而不是另一个构造函数。最后，如果依赖项的创建成本很高，为什么要创建它并传递给构造函数，因为它可能很少使用？“Setter Injection”是另一种DI技术，可用于此类情况。

Setter注入不会强制将依赖项传递给构造函数。相反，依赖项被设置到需要的对象公开的公共财产上。正如前面所暗示的，这样做的主要动机包括：

支持依赖注入而无需修改遗留类的构造函数。允许在需要时尽可能晚地创建昂贵的资源或服务。

下面是上述代码的示例：

public class Person {
    public Person() {}

    public IDAO Address {
        set { addressdao = value; }
        get {
            if (addressdao == null)
              throw new MemberAccessException("addressdao" +
                             " has not been initialized");
            return addressdao;
        }
    }

    public Address GetAddress() {
       // ... code that uses the addressdao object
       // to fetch address details from the datasource ...
    }

    // Should not be called directly;
    // use the public property instead
    private IDAO addressdao;

让我们想象一下，你想去钓鱼：

没有依赖注入，你需要自己处理所有的事情。你需要找一艘船，买一根鱼竿，寻找诱饵等等。当然，这是可能的，但这给你带来了很多责任。在软件方面，这意味着你必须对所有这些东西进行查找。通过依赖注入，其他人负责所有准备工作，并为您提供所需的设备。你将收到（“被注射”）船、鱼竿和鱼饵——所有这些都准备好使用。

例如，我们有两类客户机和服务。客户端将使用服务

public class Service {
    public void doSomeThingInService() {
        // ...
    }
}

无依赖注入

方式1）

public class Client {
    public void doSomeThingInClient() {
        Service service = new Service();
        service.doSomeThingInService();
    }
}

方式2）

public class Client {
    Service service = new Service();
    public void doSomeThingInClient() {
        service.doSomeThingInService();
    }
}

方式3）

public class Client {
    Service service;
    public Client() {
        service = new Service();
    }
    public void doSomeThingInClient() {
        service.doSomeThingInService();
    }
}

1） 2）3）使用

Client client = new Client();
client.doSomeThingInService();

优势

易于理解的

缺点

难以测试客户端类当我们更改Service构造函数时，我们需要在所有位置更改代码createService对象

使用依赖注入

方式1）构造函数注入

public class Client {
    Service service;

    Client(Service service) {
        this.service = service;
    }

    // Example Client has 2 dependency 
    // Client(Service service, IDatabas database) {
    //    this.service = service;
    //    this.database = database;
    // }

    public void doSomeThingInClient() {
        service.doSomeThingInService();
    }
}

使用

Client client = new Client(new Service());
// Client client = new Client(new Service(), new SqliteDatabase());
client.doSomeThingInClient();

方式2）沉淀剂注入

public class Client {
    Service service;

    public void setService(Service service) {
        this.service = service;
    }

    public void doSomeThingInClient() {
        service.doSomeThingInService();
    }
}

使用

Client client = new Client();
client.setService(new Service());
client.doSomeThingInClient();

方式3）接口注入

检查https://en.wikipedia.org/wiki/Dependency_injection

===

现在，这段代码已经遵循了依赖注入，测试客户端类更容易。然而，我们仍然多次使用新的Service（），并且在更改Service构造函数时效果不佳。为了防止这种情况，我们可以使用DI注射器1） 简单手动喷油器

public class Injector {
    public static Service provideService(){
        return new Service();
    }

    public static IDatabase provideDatatBase(){
        return new SqliteDatabase();
    }
    public static ObjectA provideObjectA(){
        return new ObjectA(provideService(...));
    }
}

使用

Service service = Injector.provideService();

2） 使用库：适用于Android dagger2

优势

使测试更容易更改服务时，只需在Injector类中更改如果您使用使用构造函数注入，当您查看Client的构造函数时，您将看到Client类有多少依赖项

缺点

如果使用构造函数注入，则在创建客户端时创建服务对象，有时我们在客户端类中使用函数而不使用服务，因此创建的服务被浪费

依赖注入定义

https://en.wikipedia.org/wiki/Dependency_injection

依赖项是可以使用的对象（服务）注入是将依赖项（Service）传递给将使用它的依赖对象（Client）

让我们用Car和Engine类来尝试一个简单的例子，任何汽车都需要一个引擎，至少目前是这样。下面是没有依赖注入的代码的外观。

public class Car
{
    public Car()
    {
        GasEngine engine = new GasEngine();
        engine.Start();
    }
}

public class GasEngine
{
    public void Start()
    {
        Console.WriteLine("I use gas as my fuel!");
    }
}

为了实例化Car类，我们将使用以下代码：

Car car = new Car();

这个代码的问题是我们与GasEngine紧密耦合，如果我们决定将其更改为ElectricityEngine，那么我们需要重写Car类。应用程序越大，我们必须添加和使用新型引擎的问题和麻烦就越多。

换句话说，这种方法是我们的高级Car类依赖于低级GasEngine类，这违反了SOLID的依赖反转原理（DIP）。DIP建议我们应该依赖抽象，而不是具体的类。因此，为了满足这一点，我们引入了IEngine接口并重写如下代码：

    public interface IEngine
    {
        void Start();
    }

    public class GasEngine : IEngine
    {
        public void Start()
        {
            Console.WriteLine("I use gas as my fuel!");
        }
    }

    public class ElectricityEngine : IEngine
    {
        public void Start()
        {
            Console.WriteLine("I am electrocar");
        }
    }

    public class Car
    {
        private readonly IEngine _engine;
        public Car(IEngine engine)
        {
            _engine = engine;
        }

        public void Run()
        {
            _engine.Start();
        }
    }

现在我们的Car类只依赖于IEngine接口，而不是引擎的特定实现。现在，唯一的诀窍是我们如何创建Car的实例，并给它一个实际的具体Engine类，比如GasEngine或ElectricityEngine。这就是依赖注入的作用。

   Car gasCar = new Car(new GasEngine());
   gasCar.Run();
   Car electroCar = new Car(new ElectricityEngine());
   electroCar.Run();

在这里，我们基本上将依赖项（Engine实例）注入（传递）到Car构造函数。因此，现在我们的类在对象及其依赖关系之间具有松散的耦合，我们可以在不更改Car类的情况下轻松添加新类型的引擎。

依赖注入的主要好处是类之间的耦合更加松散，因为它们没有硬编码的依赖关系。这遵循了上面提到的依赖反转原则。类不是引用特定的实现，而是请求抽象（通常是接口），这些抽象是在构造类时提供给它们的。

所以最终依赖注入只是一种技术实现对象及其依赖关系之间的松散耦合。而不是直接实例化类需要的依赖项为了执行其操作，向类提供依赖项（通常）通过构造函数注入。

此外，当我们有很多依赖项时，使用控制反转（IoC）容器是非常好的做法，我们可以告诉哪些接口应该映射到我们所有依赖项的具体实现，我们可以让它在构建对象时为我们解决这些依赖项。例如，我们可以在IoC容器的映射中指定IEngine依赖项应映射到GasEngine类，当我们向IoC容器请求Car类的实例时，它将自动构建Car类，并传入GasEngine依赖项。

更新：最近观看了Julie Lerman关于EF Core的课程，也喜欢她对DI的简短定义。

依赖注入是一种允许应用程序注入的模式对象，而无需强制类来负责这些对象。它允许您的代码更松散的耦合，并且实体框架核心插入到该框架中服务体系。

针对5岁儿童的依赖注入。

当你自己去把冰箱里的东西拿出来时，你可能会引起问题。你可能会让门开着，你可能会得到妈妈或爸爸不希望你拥有的东西。你甚至可能在寻找我们甚至没有或已经过期的东西。

你应该做的是陈述一个需要，“我需要午餐时喝点东西”，然后我们会确保你坐下吃饭时有东西。