什么是构造函数注⼊？
如果编写⼀个验证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
writeline方法属于类
{
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);
}

版权声明：本站内容均来自互联网，仅供演示用，请勿用于商业和其他非法用途。如果侵犯了您的权益请与我们联系QQ:729038198，我们将在24小时内删除。