依赖注入

场景出发

假设存在如下游戏场景:

1:角色可以装备木剑,铁剑,魔剑3种装备,分别对怪物造成20HP,50HP,100HP伤害(未佩戴装备则无法攻击);

2角色可以向怪物攻击,一次攻击后损失角色所佩戴装备的HP伤害,当HP损失完毕后,怪物死亡;

不假思索地我会写出如下的代码:

class Monster
    {
        public string Name { get; set; }
        public int HP { get; set; }
        /// <summary>
        /// 怪物被攻击后提示
        /// </summary>
        /// <param name="loss">武器造成的HP伤害损失</param>
        public void Warn(int loss)
        {
            if (HP <= 0)
            {
                Console.WriteLine($"怪物{Name}已经死亡");
                return;
            }

            HP -= loss;

            Console.WriteLine($"怪物{Name}受到{loss}HP伤害");

            if (HP <= 0)
            {
                Console.WriteLine($"怪物{Name}被打死了");
            }
        }
    }

class Role
    {
        public string Name { get; set; }
        public string Weapon { get; set; }
        /// <summary>
        /// 武器攻击
        /// </summary>
        /// <param name="monster">攻击的怪物对象</param>
        public void Attack(Monster monster)
        {
            if (Weapon == "WoodenSword")
            {
                Console.WriteLine($"{Name}用木剑攻击了{monster.Name}");
                monster.Warn(25);
            }

            else if (Weapon == "IronSword")
            {
                Console.WriteLine($"{Name}用铁剑攻击了{monster.Name}");
                monster.Warn(50);
            }
            else if (Weapon == "MagicSword")
            {
                Console.WriteLine($"{Name}用魔剑攻击了{monster.Name}");
                monster.Warn(100);
            }
            else
            {
                Console.WriteLine($"{Name}没有武器,无法攻击");
            }
        }
    }

class Program
    {
        static void Main(string[] args)
        {
            var monster = new Monster()
            {
                Name = "沼泽首领",
                HP = 80
            };
            var role = new Role()
            {
                Name = "狂战士",
                Weapon="IronSword"
            };
            role.Attack(monster);
            role.Weapon = "WoodenSword";
            role.Attack(monster);
            role.Weapon = "MagicSword";
            role.Attack(monster);

            Console.ReadKey();
        }
    }

相信不止我一个人会这样写,因为它能快速的"完美的"实现上述功能

回过头来再仔细观察这段代码,就感觉像在看一段"直肠子",所有的逻辑算法都集中到了一个管道上,只要有需求或逻辑上的的变化,那么就得直接去修改业务类

改进分析

分析上述代码,它严重违背了开闭原则(OCP,Open Closed Principle,即我们的程序是可扩展的,在遇到新的需求或者变化的时候,是不需要对原有类有任何修改的),显然上述代码无法适应新的需求.随便一点需求的变化,就必须去修改具体类,对此我们做出如下简单的修改:

将Weapon抽象出来,  使Role对Weapon的依赖,转为对Weapon抽象的依赖,代码如下

 public interface IWeaponStrategy
    {
        void WeaponAttack(Monster monster);
    }

public class WoodenSwordStrategy : IWeaponStrategy
    {
        public void WeaponAttack(Monster monster)
        {
            Console.WriteLine("木剑攻击");
            monster.Warn(20);
        }
    }
    public class IronSwordStrategy : IWeaponStrategy
    {
        public void WeaponAttack(Monster monster)
        {
            Console.WriteLine("铁剑攻击");
            monster.Warn(50);
        }
    }

    public class MagicSwordStrategy : IWeaponStrategy
    {
        public void WeaponAttack(Monster monster)
        {
            Console.WriteLine("魔剑攻击");
            monster.Warn(100);
        }
    }

public class Monster
    {
        public string Name { get; set; }
        public int HP { get; set; }

        /// <summary>
        /// 怪物被攻击后提示
        /// </summary>
        /// <param name="loss">武器造成的HP伤害损失</param>
        public void Warn(int loss)
        {
            if (HP <= 0)
            {
                Console.WriteLine($"怪物{Name}已经死亡");
                return;
            }

            HP -= loss;

            Console.WriteLine($"怪物{Name}受到{loss}HP伤害");

            if (HP <= 0)
            {
                Console.WriteLine($"怪物{Name}被打死了");
            }
        }
    }

class Role
    {
        public string Name { get; set; }
        public IWeaponStrategy Weapon { get; set; }
        public void Attack(Monster monster)
        {
            Weapon.WeaponAttack(monster);
        }
    }

class Program
    {
        static void Main(string[] args)
        {
            var monster = new Monster()
            {
                Name = "沼泽首领",
                HP = 80
            };
            var role = new Role()
            {
                Name = "狂战士",
                Weapon=new IronSwordStrategy()
            };
            role.Attack(monster);
            role.Weapon = new WoodenSwordStrategy();
            role.Attack(monster);
            role.Weapon = new MagicSwordStrategy();
            role.Attack(monster);

            Console.ReadLine();
        }
    }

依赖注入

依赖注入(Dependency Injection,DI)即控制反转(Inversion of Control,IoC)[初步的理解,本质上是有区别的]:

起因:客户类或上端)(Role)依赖了服务类(Weapon)的细节(实例);

目的:降低程序耦合度

方式:依赖抽象

本质:一个转移依赖的过程

我认为依赖注入就是一个转移依赖的过程,只是因为实现方式的不同,依赖最后转移到了不同的地方

依赖注入的方式

1Setter注入

在客户类中,添加一个服务类的抽象类型的数据成员,并添加一个需要服务类抽象类型的参数的方法做为注入点,在方法中把具体的服务类赋值给该数据成员

简单修改下客户类即为Setter注入

    class Role
    {
        private IWeaponStrategy _weapon = null;

        public string Name { get; set; }

        public void AddWeapon(IWeaponStrategy weapon)
        {
            _weapon = weapon;
        }
        public void Attack(Monster monster)
        {
            _weapon.WeaponAttack(monster);
        }
    }

 2构造注入

构造注入与Setter注入类似,所不同的是构造方法替代了上述添加的方法,如果上述事例改为构造注入,则只需要修改下客户类和上端代码即可

  class Role
    {
        private IWeaponStrategy _weapon = null;
        public Role(IWeaponStrategy weapon)
        {
            _weapon = weapon;
        }
        public string Name { get; set; }
 
        public void Attack(Monster monster)
        {
            _weapon.WeaponAttack(monster);
        }
    }

在构造的时候把具体的服务类赋值给该数据成员

3配置文件

 上述两种方式注入,在上端任然需要实例具体的服务类,我们可以通过配置文件加工厂模式,把依赖从上端转移到工厂内部

<?xml version="1.0" encoding="utf-8" ?>
<configuration>
  <appSettings>
    <add key="Weapon" value="WoodenSword"/>
  </appSettings>
</configuration>

  public class WeaponFactory
    {
        public static IWeaponStrategy GetWeapon()
        {

            var type = ConfigurationManager.AppSettings["Weapon"];

            if (type== "IronSword")
            {
                return new IronSwordStrategy();
            }
            else if (type == "WoodenSword")
            {
                return new WoodenSwordStrategy();
            }
            else
            {
                return new MagicSwordStrategy();
            }
        }
    }

如果在再配合反射,工厂内部的依赖也可以被转移

 依赖注入的方式并不单一,要根据实际情况选择最合适的,但是它的本质是很容易理解的,在这个基础上,不管它如何的延伸,都可以轻松掌握

参考推荐博客:依赖注入那些事儿

 出自:博客园-半路独行

 原文地址:https://www.cnblogs.com/banluduxing/p/9185142.html

 本文出自于http://www.cnblogs.com/banluduxing 转载请注明出处。