16

这是我到目前为止所拥有的：

namespace Strategy
{
    interface IWeaponBehavior
    {
        void UseWeapon();
    }
}

namespace Strategy
{
    class Knife : IWeaponBehavior
    {
        public void UseWeapon()
        {
            Console.WriteLine("You used the knife to slash the enemy! SLASH SLASH!");
        }
    }
}

namespace Strategy
{
    class Pan : IWeaponBehavior
    {
        public void UseWeapon()
        {
            Console.WriteLine("You use the pan! 100% Adamantium power! BONG!");
        }
    }
}

现在，如果我有一个 Character.cs 超类。该超类如何实现武器行为，以便子类可以更具体。

namespace Strategy
{
    class Character
    {
        public IWeaponBehavior weapon;

        public Character(IWeaponBehavior specificWeapon)
        {
            weapon = specificWeapon;
        }        
    }
}

namespace Strategy
{
    class Thief : Character
    {

    }
}

我该如何实施？我对实际代码需要什么感到非常困惑。

我知道这可能要求太多，但是如果您可以编写实际代码以便我可以研究它，那对你们非常好。我通过看代码来学习。:P 许多人可以从这个问题中受益。

4

7 回答 7

26

在类中使用依赖注入Character？

public class Character
{
    public Character(IWeaponBehavior weapon) 
    {
        this.weapon = weapon;
    }

    public void Attack()
    {
        weapon.UseWeapon();
    }

    IWeaponBehavior weapon;
}

public class Princess: Character
{
    public Princess() : base(new Pan()) { }
}

public class Thief: Character
{
    public Thief() : base(new Knife()) { }
}

...

Princess p = new Princess();
Thief t = new Thief();

p.Attack(); // pan
t.Attack(); // knife

按要求编辑。

于 2010-08-10T13:55:30.350 回答
5

有几种可能性。您真正要问的是，“特定角色应该如何知道要使用哪种武器？”。

您可以拥有一个角色工厂来创建并注入正确类型的武器到角色中（这听起来不对:)），或者让特定角色的构造函数负责创建武器。

于 2010-08-10T13:56:05.177 回答
3 
  class Character
  {
    private IWeaponBehavior _weapon;

    // Constructor
    public Character(IWeaponBehavior strategy)
    {
      this._weapon = strategy;
    }

    public void WeaponInterface()
    {
      _weapon.UseWeapon();
    }
  }
于 2010-08-10T13:56:07.047 回答
1

看看依赖注入，然后看看控制反转。

TekPub 有一个关于这两个想法的精彩免费插曲，使用的示例与您的非常相似。这应该可以帮助您获得具体的样本。:-)

http://tekpub.com/view/concepts/1

视频中的示例代码：

class Samurai {
  IWeapon _weapon;

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

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

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

以上是 DI（带有 IWeapon 构造函数）。现在添加控制反转，您可以获得更多控制权。

使用 IOC 容器，您将能够通过注入而不是在类本身中控制 IWeapon。

该视频使用NInject作为 IOC，并展示了如何消除 IWeapon 构造函数并获得对类和所有需要使用 IWeapon 的类的控制，以便在一个位置/配置区域使用您想要的东西。

视频样本：

class WarriorModule: NinjectModule {
  public override void Load() {
   Bind<IWarrior>().To<Samurai>();
   Bind<IWeapon>().To<Sword>();
}

上面的配置告诉 NInject 每当它遇到 IWarrior 使用 Samurai 并且每当它鼓励 IWeapon 使用 Sword 时。

视频继续解释这个小改变如何增加你的灵活性。它为使用远程武器等的 Samuria 添加了另一个模块......

您可以根据需要/需要更改这些。

于 2010-08-10T14:54:29.900 回答
1 
公共类人物
{
    IWeaponBehavior 武器；
}

公共课公主：性格
{
    武器 = new Pan();
}

公共类小偷：角色
{
    武器 = 新刀（）；
}
于 2010-08-10T13:57:08.397 回答
0

这是一篇关于在 C# 中使用此模式的重点文章：http ://www.lowendahl.net/showShout.aspx?id=115

于 2010-08-10T13:55:22.447 回答
0

如果您的角色都有自己的特定武器，那么您实际上不需要使用策略模式。你可以使用普通的多态性。但无论如何，策略模式可能会更清晰。

你只需要初始化武器：

public class Character
{
     IWeapenBehavior weapon;

     public Attack()
     {
          weapon.UseWeapon();
     }
}


public class Thief : Character
{
      Thief()
      {
           weapon = new Knife();
      }
}

在控制您的 Characters 的代码中，您可以调用该Attack()方法。

于 2010-08-10T14:00:26.500 回答