什么是构造函数注入？

如果编写一个验证ClassA特定行为的测试，它始终依赖于ClassB。如果在ClassA的构造函数中创建ClassB，则无法控制它。如果ClassA为了做一些有条件的工作而读取ClassB的属性Foo，那么如何检查不同的情况呢？您没有简单的方法来设置测试，即将Foo属性设置为您需要的值。

如果你将ClassB注入到ClassA的构造函数中，它会突然变得更加简单。在您的测试中，您现在可以构造ClassB的实例，为Foo指定一个值，构造ClassA的实例并验证正确的行为。测试完毕。重复其他Foo值...

此模式称为依赖注入，应优先于您的其他方法。直接在其构造函数中构造类的依赖关系是一种反模式，因为它会导致副作用并使测试更加困难。

让我们通过一个简单的例子来研究依赖注入的概念。假设你正在编写下一部重磅游戏，那里的贵族战士将为伟大的荣耀而战。首先，我们需要一种适合武装武士的武器。

class Sword 
{
    public void Hit(string target)
    {
        Console.WriteLine("Chopped {0} clean in half", target);
    }
}

然后，让我们创建一个类来代表我们的战士。为了攻击它的敌人，战士需要一个Attack（）方法。当这个方法被调用时，它应该使用它的剑来打击它的对手。

class Samurai
{
    readonly Sword sword;
    public Samurai() 
    {
        this.sword = new Sword();
    }

    public void Attack(string target)
    {
        this.sword.Hit(target);
    }
}

现在，我们可以创建我们的武士并进行战斗！

class Program
{
    public static void Main() 
    {
        var warrior = new Samurai();
        warrior.Attack("the evildoers");
    }
}

正如你可能想象的那样，这将打印出来“Chopped the evildoers clean in half到控制台。这很好用，但如果我们想用另一种武器武装我们的武士呢？由于Sword是在Samurai类的构造函数中创建的，因此我们必须修改类的实现以进行此更改。

当一个类依赖于具体依赖时，它被认为与该类紧密耦合。在这个例子中，Samurai类与Sword类紧密耦合。当类紧密耦合时，如果不改变它们的实现，它们就不能互换。为了避免紧密耦合类，我们可以使用接口来提供间接级别。让我们创建一个界面来代表我们游戏中的武器。

interface IWeapon
{
    void Hit(string target);
}

然后，我们的Sword类可以实现这个接口：

class Sword : IWeapon
{
    public void Hit(string target) 
    {
        Console.WriteLine("Chopped {0} clean in half", target);
    }
}

我们可以改变我们的Samurai课程：

class Samurai
{
    readonly IWeapon weapon;
    public Samurai() 
    {
        this.weapon = new Sword();
    }
    public void Attack(string target) 
    {
        this.weapon.Hit(target);
    }
}

现在我们的武士可以装备不同的武器。可是等等！Sword仍在Samurai的构造函数中创建。由于我们仍然需要改变武士的实施以便为我们的战士提供另一种武器，因此武士仍与Sword紧密相连。

幸运的是，有一个简单的解决方案。我们可以将它作为构造函数的参数公开，而不是在Samurai的构造函数中创建Sword。也称为构造函数注入。

class Samurai
{
    readonly IWeapon weapon;
    public Samurai(IWeapon weapon) 
    {
        this.weapon = weapon;
    }
    public void Attack(string target) 
    {
        this.weapon.Hit(target);
    }
}

此外，还有属性注入。这将是这样的：

class Samurai
{
    IWeapon weapon;

    public Samurai() { }


    public void SetWeapon(IWeapon weapon)
    {
        this.weapon = weapon;
    }

    public void Attack(string target) 
    {
        this.weapon.Hit(target);
    }

}

假设您有一个类，A每个实例都需要另一个类的实例B。

class A
{
   B b;
}

依赖注入意味着引用B由管理A实例的对象设置（而不是直接A管理引用的类B）。

构造函数注入意味着引用B作为参数传递给构造函数的构造函数A和设置：

class A
{
    B b;

    A(B b)
    {
        this.b = b;
    }
}

另一种方法是使用setter方法（或属性）来设置引用B。在这种情况下，管理一个实例的对象a的A必须先调用的构造A和以后调用设置器方法来设置成员变量A.b之前a被使用。后者注射方法是在必要时对象包含对于彼此，例如循环引用如果一个实例b的B，在一个实例设置a的A包含一个回参考a。

**编辑**

以下是解决该评论的更多细节。

1. A类管理B实例

class A
{
    B b;

    A()
    {
        b = new B();
    }
 }

2. B实例在构造函数中设置

class A
{
    B b;

    A(B b)
    {
        this.b = b;
    }
}

class M
{
    ...
    B b = new B();
    A a = new A(b);
}

3.使用setter方法设置B实例

class A
{
    B b;

    A()
    {
    }

    void setB(B b)
    {
        this.b = b;
    }
}

class M
{
    ...
    B b = new B();
    A a = new A();

    a.setB(b);
}