Disclaimer: Almost all of this was "stolen" from the Ninject Wiki

什麼是建構函式注入呢，建構函式注入是不是就是一個具體的依賴注入呢，下面給個例子來解釋：

構造器注入就是一個具體的依賴注入的例子：

Let’s examine the idea of dependency injection by walking through a simple example. Let’s say you’re writing the next blockbuster game, where noble warriors do battle for great glory. First, we’ll need a weapon suitable for arming our warriors.

classSword{publicvoidHit(string target){Console.WriteLine("Chopped {0} clean in half", target);}}

Then, let’s create a class to represent our warriors themselves. In order to attack its foes, the warrior will need an Attack() method. When this method is called, it should use its Sword to strike its opponent.

classSamurai{readonlySword sword;publicSamurai(){this.sword =newSword();}publicvoidAttack(string target){this.sword.Hit(target);}}

Now, we can create our Samurai and do battle!

classProgram{publicstaticvoidMain(){var warrior =newSamurai();
        warrior.Attack("the evildoers");}}

As you might imagine, this will print Chopped the evildoers clean in half

 to the console. This works just fine, but what if we wanted to arm our Samurai with another weapon? Since the Sword is created inside the Samurai class’s constructor, we have to modify the implementation of the class in order to make this change.

When a class is dependent on a concrete dependency, it is said to be tightly coupled to that class. In this example, the Samurai class is tightly coupled to the Sword class. When classes are tightly coupled, they cannot be interchanged without altering their implementation. In order to avoid tightly coupling classes, we can use interfaces to provide a level of indirection. Let’s create an interface to represent a weapon in our game.

interfaceIWeapon{voidHit(string target);}

Then, our Sword class can implement this interface:

我們可以將Sword類定位一個介面

classSword:IWeapon{publicvoidHit(string target){Console.WriteLine("Chopped {0} clean in half", target);}}

And we can alter our Samurai class:

classSamurai{readonlyIWeapon weapon;publicSamurai(){this.weapon =newSword();}publicvoidAttack(string target){this.weapon.Hit(target);}}

Now our Samurai can be armed with different weapons. But wait! The Sword is still created inside the constructor of Samurai. Since we still need to alter the implementation of Samurai in order to give our warrior another weapon, Samurai is still tightly coupled to Sword.

Fortunately, there is an easy solution. Rather than creating the Sword from within the constructor of Samurai, we can expose it as a parameter of the constructor instead. Also known as Constructor Injection.

幸運的是，有一個容易解決的方法，不是在Samurai建構函式內建立Sword，我們在將其暴露出來成為一個建構函式的引數，這就是所謂的構建函式注入：

classSamurai{readonlyIWeapon weapon;publicSamurai(IWeapon weapon){this.weapon = weapon;}publicvoidAttack(string target){this.weapon.Hit(target);}}

As Giorgio pointed out, there's also property injection（屬性注入）. That would be something like:

classSamurai{IWeapon weapon;publicSamurai(){}publicvoidSetWeapon(IWeapon weapon){this.weapon = weapon;}publicvoidAttack(string target){this.weapon.Hit(target);}}