c# - pattern - que hace el patron strategy

¿Cómo utilizar el patrón de estrategia con C#?

Question

Esto es lo que tengo hasta ahora:

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!");
        }
    }
}

Ahora si tengo una superclase de Character.cs. ¿Cómo puede esa superclase implementar un comportamiento de arma para que las clases de niños puedan ser más específicas?

namespace Strategy
{
    class Character
    {
        public IWeaponBehavior weapon;

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

namespace Strategy
{
    class Thief : Character
    {

    }
}

¿Cómo puedo implementar esto? Estoy muy confundido sobre lo que debe ser el código real.

Sé que esto podría estar pidiendo demasiado, pero si pudieras escribir el código real para que yo pudiera estudiarlo, sería muy amable de todos. Aprendo al ver el código. : P Muchas personas podrían beneficiarse de esta pregunta.

Answer 1

¿Usar la inyección de dependencia en la clase de 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

Editado según lo solicitado.

Answer 2

Aquí hay un artículo muy centrado sobre el uso de este patrón en C #: http://www.lowendahl.net/showShout.aspx?id=115

Answer 3

Eche un vistazo a la inyección de dependencia y luego vea también Inversión de control.

TekPub tiene un gran episodio gratuito sobre estas dos ideas utilizando una muestra muy similar a la tuya. Esto debería ayudarte con una muestra concreta. :-)

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

Código de muestra del video:

class Samurai {
  IWeapon _weapon;

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

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

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

Lo anterior es DI (con el constructor IWeapon). Ahora agregando Inversión de control, obtienes aún más control.

Al usar un contenedor IOC, podrá controlar el IWeapon mediante inyección en lugar de hacerlo en la propia clase.

El video usa NInject como es IOC y muestra cómo puede eliminar IWeapon Constructor y obtener control sobre la clase y todas las clases que necesitan usar IWeapon para usar lo que desea en una ubicación / área de configuración.

Muestra de video:

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

La configuración anterior le dice a NInject que siempre que se encuentre con un IWarrior para usar Samurai y siempre que aliente a un IWeapon a usar la Espada.

El video continúa explicando cómo este pequeño cambio aumenta tu flexibilidad. Agrega otro módulo para una Samuria que usa un arma a distancia, etc ...

Puede cambiar estos según sea necesario / deseado.

Answer 4

Hay algunas posibilidades. Lo que realmente estás preguntando es, "¿cómo debería un personaje específico saber qué arma usar?".

Puedes tener una fábrica de personajes que pueda crear e inyectar el tipo correcto de arma en el personaje (que sonó mal :)), o dejar que el constructor de un personaje específico se encargue de crear el arma.

Answer 5

Si todos tus personajes tienen su propia arma específica, no necesitas utilizar el patrón de estrategia. Podrías usar el polimorfismo plano. Pero el patrón de estrategia podría ser más limpio de todos modos.

Solo necesitas inicializar el arma:

public class Character
{
     IWeapenBehavior weapon;

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


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

En el código que controla tus personajes, puedes llamar al método Attack() .

Answer 6

  class Character
  {
    private IWeaponBehavior _weapon;

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

    public void WeaponInterface()
    {
      _weapon.UseWeapon();
    }
  }

Answer 7

public class Character { IWeaponBehavior Weapon; } public class Princess : Character { Weapon = new Pan(); } public class Thief : Character { Weapon = new Knife(); }