手动依赖注入(二)

　　首先通过下面简单的例子理解依赖注入思想。假如你正在玩一个游戏，勇士们为荣耀而战。首先需要为我们的勇士装备合适的武器。

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace Inject
{
    /// <summary>
    /// 刀
    /// </summary>
    public class Sword
    {
        public void Hit(string target)
        {
            Console.WriteLine("Hit the target {0} by sword", target);
        }
    }
}

　　接着，创建类Samurai来表示勇士。为攻击敌人，我们创建一个攻击方法Attack。当这个方法被调用时，勇士将用刀攻击对手。

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace Inject
{
    /// <summary>
    /// 勇士
    /// </summary>
    public class Samurai
    {
        private Sword _sword;

        public Samurai()
        {
            _sword = new Sword();
        }

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

　　创建勇士参加战斗。

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace Inject
{
    class Program
    {
        static void Main(string[] args)
        {
            Samurai s = new Samurai();
            s.Attack("enemy");

            Console.ReadKey();
        }
    }
}

　　如果想为勇士装备其它的武器，该如何做呢？因为Sword 对象在Samurai的构造函数中被创建，所以我们不得不修改类的实现。
　　当一个类依赖一个实例，称为紧耦合(tightly coupled)。在上面例子中，Samurai类相对于Sword类是紧耦合的。当类是紧耦合，在没有修改实现的情况下，被依赖项是不能被交换的。为了避免紧耦合，我们可以使用接口提供间接层。

　　创建武器接口。

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace Inject
{
    /// <summary>
    /// 武器
    /// </summary>
    public interface IWeapon
    {
        void Hit(string target);
    }
}

　　接着，修改类Sword实现接口IWeapon。

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace Inject
{
    /// <summary>
　　/// 刀
　　/// </summary>
    public class Sword : IWeapon
    {
        public void Hit(string target)
        {
            Console.WriteLine("Hit the target {0} by sword", target);
        }
    }
}

　　修改Samurai类。

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace Inject
{
    /// <summary>
　　/// 勇士
　　/// </summary>
    public class Samurai
    {
        private IWeapon _weapon;

        public Samurai()
        {
            _weapon = new Sword();
        }

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

　　这样勇士可以使用不同的武器，但是Sword还是在Samurai的构造函数中被创建，Samurai 类相对于Sword类还是紧耦合的。为了让勇士使用其它的兵器，我们还要修改类Samurai的实现。

　　将Sword作为参数传递给Samurai的构造函数。

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace Inject
{
    /// <summary>
　　/// 勇士
　　/// </summary>
    public class Samurai
    {
        private IWeapon _weapon;

        public Samurai(IWeapon weapon)
        {
            _weapon = weapon;
        }

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

　　这样，我们可以通过Samurai的构造函数注入Sword，这就是依赖注入。

　　接着，为勇士创建新的武器镖。

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace Inject
{
    /// <summary>
　　/// 镖
　　/// </summary>
    public class Shuriken : IWeapon
    {
        public void Hit(string target)
        {
            Console.WriteLine("Hit the target {0} by shuriken", target);
        }
    }
}

　　接着，创建军队。

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace Inject
{
    class Program
    {
        static void Main(string[] args)
        {
            // 使用刀
            Samurai s1 = new Samurai(new Sword());
            s1.Attack("enemy");

            // 使用镖
            Samurai s2 = new Samurai(new Shuriken());
            s2.Attack("enemy");

            Console.ReadKey();
        }
    }
}

　　这就是手动依赖注入。每次创建一个Samurai，需要先创建实现了IWeapon接口的对象，传递给Samurai的构造函数。现在我们改变勇士使用的武器，就不用再修改Samurai类。Samurai被分离出来，我们可以创建新的武器而不关心Samurai的代码。

　　手动依赖注入对于小项目是有效的策略，但是随着应用程序的大小和复杂性的增长，关联对象将变得越来越繁杂。接下来我们将使用Ninject实现依赖注入。

 

参考资料：

http://ninject.codeplex.com/wikipage?title=Dependency%20Injection%20By%20Hand&referringTitle=User%20Guide