同样的基本问题，你经常遇到的面向对象编程，样式规则和其他一切。这是可能的——事实上是非常常见的——做太多的抽象，添加太多的间接，并且通常在错误的地方过度地应用好的技术。

您应用的每个模式或其他构造都会带来复杂性。抽象和间接分散了信息，有时会移除了无关的细节，但有时也会让人更难理解到底发生了什么。你应用的每一条规则都会带来不灵活性，排除了可能是最佳方法的选择。

重点是编写能够完成这项工作的代码，并且是健壮的、可读的和可维护的。你是软件开发人员，而不是象牙塔建造者。

相关的链接

平台内效应

不要让建筑宇航员吓到你

可能依赖注入最简单的形式(别笑)是一个参数。依赖代码依赖于数据，而数据是通过传递参数的方式注入的。

是的，这很愚蠢，而且它没有解决依赖注入的面向对象问题，但是函数式程序员会告诉你(如果你有第一类函数)这是你唯一需要的依赖注入。这里的重点是举一个简单的例子，并展示潜在的问题。

以这个简单的传统函数为例。c++语法在这里并不重要，但我必须以某种方式拼写它……

void Say_Hello_World ()
{
  std::cout << "Hello World" << std::endl;
}

我有一个依赖，我想提取出来并注入-文本“Hello World”。很容易…

void Say_Something (const char *p_text)
{
  std::cout << p_text << std::endl;
}

为什么它比原来的更不灵活呢?如果我决定输出应该是Unicode。我可能想从std::cout切换到std::wcout。但这意味着我的字符串必须是*wchar_*t，而不是char类型的。要么必须更改每个调用方，要么(更合理地)将旧的实现替换为转换字符串并调用新实现的适配器。

这是维修工作如果我们保留原来的就不需要了。

如果它看起来微不足道，那么看看这个来自Win32 API的真实函数……

函数(winuser.h)

这有12个“依赖项”需要处理。例如，如果屏幕分辨率变得非常大，也许我们将需要64位的坐标值-和另一个版本的CreateWindowEx。是的，已经有一个旧版本仍然存在，它可能会在幕后映射到新版本……

创造温杜瓦宏(winuser宏)

这些“依赖关系”不仅仅是原始开发人员的问题——每个使用该接口的人都必须查找依赖关系是什么，它们是如何指定的，以及它们的含义，并确定为他们的应用程序做什么。这就是“明智的默认”可以让生活简单得多的地方。

面向对象的依赖注入在原理上没有什么不同。无论是在源代码文本中还是在开发人员时间中，编写类都是一种开销，如果编写该类是为了根据某些依赖对象规范提供依赖项，那么依赖对象将被锁定为支持该接口，即使需要替换该对象的实现。

这些都不应该被解读为依赖注入是不好的——远非如此。但是任何好的技术都可能被过度地应用在错误的地方。就像不是每个字符串都需要提取出来并转化为参数一样，也不是每个低级行为都需要从高级对象中提取出来并转化为可注入的依赖项。

如果您有一个自己开发的解决方案，依赖项就会在构造函数中直接出现。或者作为方法参数，这也不难发现。尽管框架管理的依赖关系，如果走到极端，就会开始变得像魔术一样。

然而，在太多的类中有太多的依赖项是一个明显的标志，说明你的类结构搞砸了。因此，在某种程度上，依赖注入(自行开发或框架管理)可以帮助发现那些可能隐藏在暗处的突出设计问题。

为了更好地说明第二点，这里是本文的一段摘录(原始来源)，我完全相信这是构建任何系统的基本问题，而不仅仅是计算机系统。

Suppose you want to design a college campus. You must delegate some of the design to the students and professors, otherwise the Physics building won't work well for the physics people. No architect knows enough about about what physics people need to do it all themselves. But you can't delegate the design of every room to its occupants, because then you'll get a giant pile of rubble. How can you distribute responsibility for design through all levels of a large hierarchy, while still maintaining consistency and harmony of overall design? This is the architectural design problem Alexander is trying to solve, but it's also a fundamental problem of computer systems development.

DI能解决这个问题吗?不。但它确实帮助你清楚地看到，如果你试图把设计每个房间的责任委托给它的居住者。

控制反转(不是完全依赖注入，但已经足够接近了)最大的“缺点”是，它倾向于去掉一个点来查看一个算法的概述。这基本上就是当你有解耦的代码时所发生的事情——在一个地方查看的能力是紧密耦合的产物。

有一件事让我对DI有点不安，那就是假设所有注入的对象都很容易实例化，而且不会产生副作用- or -依赖关系被频繁使用，以至于它超过了任何相关的实例化成本。

当依赖项在消费类中不经常使用时，这一点可能很重要;比如IExceptionLogHandlerService。显然，这样的服务很少在类中调用(希望:))——大概只在需要记录异常时调用;然而，规范的构造器-注入模式……

Public Class MyClass
    Private ReadOnly mExLogHandlerService As IExceptionLogHandlerService

    Public Sub New(exLogHandlerService As IExceptionLogHandlerService)
        Me.mExLogHandlerService = exLogHandlerService
    End Sub

    ' ...
End Class

.．.要求提供该服务的“活动”实例，该死的成本/副作用。并不是说它可能会这样做，但是如果构建这个依赖实例涉及到服务/数据库命中，或配置文件查找，或在释放之前锁定资源，该怎么办呢?如果该服务是按需构建的、服务定位的或工厂生成的(它们都有各自的问题)，那么您将只在必要时才承担构建成本。

Now, it is a generally accepted software design principle that constructing an object is cheap and doesn't produce side-effects. And while that's a nice notion, it isn't always the case. Using typical constructor-injection however basically demands that this is the case. Meaning when you create an implementation of a dependency, you have to design it with DI in mind. Maybe you would have made object-construction more costly to obtain benefits elsewhere, but if this implementation is going to be injected, it will likely force you to reconsider that design.

顺便说一下，某些技术可以通过允许延迟加载注入的依赖项来缓解这个问题，例如，提供一个Lazy<IService>实例类作为依赖项。这将改变依赖对象的构造函数，并使其更加了解实现细节，例如对象构造开销，这也可以说是不可取的。

If you're using DI without an IoC container, the biggest downside is you quickly see how many dependencies your code actually has and how tightly coupled everything really is. ("But I thought it was a good design!") The natural progression is to move towards an IoC container which can take a little bit of time to learn and implement (not nearly as bad as the WPF learning curve, but it's not free either). The final downside is some developers will begin to write honest to goodness unit tests and it will take them time to figure it out. Devs who could previously crank something out in half a day will suddenly spend two days trying to figure out how to mock all of their dependencies.

类似于马克·西曼(Mark Seemann)的回答(现已删除;只有超过1万个声誉点)，底线是你花时间成为一个更好的开发人员，而不是把代码拼凑在一起，然后把它扔出去/投入生产。你的企业更愿意选择哪一种?只有你能回答这个问题。

这是我自己的第一反应:基本上任何模式都有同样的缺点。

学习是需要时间的 如果误解了，就会弊大于利 如果走到极端，工作量可能会超过收益