依赖注入

而不是实例化部件本身，汽车要求它的功能所需的部件。

class Car
{
    private Engine engine;
    private SteeringWheel wheel;
    private Tires tires;

    public Car(Engine engine, SteeringWheel wheel, Tires tires)
    {
        this.engine = engine;
        this.wheel = wheel;
        this.tires = tires;
    }
}

工厂

将各个部分组合在一起以形成一个完整的对象，并对调用者隐藏具体类型。

static class CarFactory
{
    public ICar BuildCar()
    {
        Engine engine = new Engine();
        SteeringWheel steeringWheel = new SteeringWheel();
        Tires tires = new Tires();
        ICar car = new RaceCar(engine, steeringWheel, tires);
        return car;
    }   
}

结果

正如你所看到的，工厂和DI是相辅相成的。

static void Main()
{
     ICar car = CarFactory.BuildCar();
     // use car
}

你还记得金发姑娘和三只熊吗?依赖注入有点像这样。这里有三种方法来做同样的事情。

void RaceCar() // example #1
{
    ICar car = CarFactory.BuildCar();
    car.Race();
}

void RaceCar(ICarFactory carFactory) // example #2
{
    ICar car = carFactory.BuildCar();
    car.Race();
}

void RaceCar(ICar car) // example #3
{
    car.Race();
}

例#1——这是最糟糕的，因为它完全隐藏了依赖关系。如果你把这个方法看作一个黑盒子，你就不会知道它需要一辆车。

例2——这样会好一点，因为我们经过了一家汽车厂，现在我们知道我们需要一辆车。但是这次我们传递的太多了，因为这个方法实际上只需要一个car。我们正在路过一个工厂，只是为了建造汽车，当汽车可以在外面建造的方法和通过。

示例#3—这是理想的，因为该方法要求的正是它所需要的。不要太多也不要太少。我不需要为了创建MockCars而编写MockCarFactory，我可以直接传入mock。它是直接的，界面不会说谎。

Misko Hevery的谷歌技术演讲非常棒，这是我得到我的例子的基础。http://www.youtube.com/watch?v=XcT4yYu_TTs

我使用这两种方法来创建反转控制策略，为在我之后需要维护它的开发人员提供了更强的可读性。

我使用工厂来创建不同的层对象(业务，数据访问)。

ICarBusiness carBusiness = BusinessFactory.CreateCarBusiness();

另一个开发人员会看到这一点，当创建业务层对象时，他会在BusinessFactory中查看，智能感知会为开发人员提供所有可能创建的业务层。不需要玩游戏，找到我想要创建的界面。

这个结构已经是控制反转了。我不再负责创建特定的对象。但是您仍然需要确保依赖注入能够轻松地更改内容。 创建自己的自定义依赖注入是荒谬的，所以我使用Unity。在CreateCarBusiness()中，我要求Unity解决哪个类属于这个和它的生命周期。

所以我的代码工厂依赖注入结构是:

public static class BusinessFactory
{
    public static ICarBusiness CreateCarBusiness()
    {
       return Container.Resolve<ICarBusiness>();
    }
}

现在我两者兼得。我的代码对于其他开发人员来说也更易于阅读，因为我使用的对象的范围，而不是构造函数依赖注入，它只是说在创建类时每个对象都是可用的。

当我创建单元测试时，我使用它将我的数据库数据访问更改为自定义编码的数据访问层。我不希望我的单元测试与数据库、网络服务器、电子邮件服务器等通信。他们需要测试我的业务层，因为这是智能所在。

[Factory] ->有一个基于请求参数创建类的类。毕竟，“工厂”在现实世界中也为你制造“物品”。你可以让你的汽车供应商工厂生产(免费:)特斯拉。1给你。

[DI] ->一个(服务)容器，用于存储接口(压缩类)。你不关心创建对象。你只需要让某个人/某个地方实现它，细节和其他东西对你、调用者或消费者都不重要。

DI是SOLID原则中“D”的基础。

我相信DI是一种配置或即时化bean的方法。DI可以通过很多方式来实现，比如构造函数，setter-getter等等。

工厂模式只是实例化bean的另一种方式。此模式将主要用于必须使用工厂设计模式创建对象时，因为在使用此模式时，您不配置bean的属性，只实例化对象。

检查这个链接:依赖注入

在我看来，使用依赖注入更好，如果你是: 1. 将代码部署在小分区中，因为它可以很好地解耦一个大代码。 2. 可测试性是DI可以使用的情况之一，因为你可以很容易地模拟非去耦的对象。通过使用接口，您可以轻松地模拟和测试每个对象。 3.你可以同时修改程序的每一部分，而不需要编码它的另一部分，因为它是松散解耦的。

您可以在这个链接中查看两种(和其他)方法在实际示例中的比较。

基本上，当需求发生变化时，如果您使用工厂而不是DI，您最终会修改更多的代码。

这对于手动DI也是有效的(例如，当没有外部框架为你的对象提供依赖关系，但你在每个构造函数中传递它们时)。