依赖倒置原则:尝试理解

Dependency inversion principle: trying to understand

本文关键字：原则 依赖      更新时间：2023-10-16

我正在学习设计模式及其周围的东西（特别是SOLID和依赖反转原理），看起来我失去了一些东西：

遵循DIP规则，我应该能够通过不在类中创建对象（composition），而是将对象引用/指针发送到类构造函数（聚合。但这意味着我必须在其他地方创建一个实例：所以一个具有聚合的类越灵活，另一个就越脆弱。

请解释我哪里错了。

您只需要遵循这个想法直到其逻辑结论。是的，你必须在其他地方创建实例，但这可能不仅仅是在比你的类高一级的类中，它一直需要被推出，直到只在应用程序的最外层创建对象。

理想情况下，您可以在一个地方创建所有对象，这被称为组合根（从工厂创建的对象除外，但工厂是在组合根中创建的）。具体位置取决于您正在构建的应用程序的类型。

  • 在桌面应用程序中，这将在Main方法中（或非常接近它）
  • 在ASP.NET（包括MVC）应用程序中，它将位于Global.asax
  • 在WCF中，它将在ServiceHostFactory中
  • 等等

这个地方最终可能会变得"脆弱"，但为了能够重新配置应用程序，您只有一个地方可以更改内容，然后所有其他类都是可测试和可配置的。

看到这个优秀的答案（上面引用）

是的，您需要在某个地方实例化该类。如果你正确地遵循DIP，你最终会在一个地方创建所有的实例。我把这里称为课堂作文。阅读我的博客，更深入地了解这个主题在这里

您错过的一个重要可能性是工厂的注入，而不是类本身。这样做的一个优点是，它允许您对实例的所有权更加干净。注意，代码有点难看，因为我明确地赋予了容器组件的所有权。如果使用shared_ptr而不是unique_ptr，事情可能会稍微整洁一点，但所有权是模糊的。

因此，从如下代码开始：

struct MyContainer {
  std::unique_ptr<IFoo> foo;
  MyContainer() : foo(new Foo() ) {};
  void doit() { foo->doit(); }
}
void useContainer() {
   MyContainer container;
   container.doit();
}

非工厂版本看起来像这个

struct MyContainer {
  std::unique_ptr<IFoo> foo;
  template<typename T>
  explicit MyContainer(std::unique_ptr<T> && f) :
     foo(std::move(f))
  {}
  void doit() { foo->doit(); }
}
void useContainer() {
   std::unique_ptr<Foo> foo( new Foo());
   MyContainer container(std::move(foo));
   container.doit();
}

工厂版本看起来像

struct FooFactory : public IFooFactory {
  std::unique_ptr<IFoo> createFoo() override {
    return std::make_unique<Foo>();
  }
};
struct MyContainer {
  std::unique_ptr<IFoo> foo;
  MyContainer(IFooFactory & factory) : foo(factory.createFoo()) {};
  void doit() { foo->doit(); }
}
void useContainer() {
   FooFactory fooFactory;
   MyContainer container(fooFactory);
   container.doit();
}

IMO明确表示所有权&C++中的生存期很重要-它是C++身份的关键部分-它是RAII和许多其他C++模式的核心。

相关文章：