¿Cómo usar 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 bien, si tengo una superclase 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 aplicar esto? Estoy muy confundido sobre cuál debe ser el código real.

Sé que esto puede ser pedir demasiado, pero si usted podría escribir el código real para que pudiera estudiar, eso sería muy agradable de ustedes. Aprendo al ver el código. : P Muchas personas podrían beneficiarse de esta pregunta.

Answer 1

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

Answer 2

uso de inyección de dependencia en la clase 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 como solicitado.

Answer 3

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

Puedes tener una fábrica de Personajes que cree e inyecte el tipo correcto de arma en el personaje (Eso sonó mal :)), o deja que el constructor de un personaje específico se encargue de crear el arma.

Answer 4

class Character 
    { 
    private IWeaponBehavior _weapon; 

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

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

Answer 5

 
public class Character 
{ 
    IWeaponBehavior Weapon; 
} 

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

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

Answer 6

Si sus personajes tienen su propia arma específica, que en realidad no necesita usar el patrón de estrategia. Podría usar polimorfismo simple. Pero el patrón de estrategia podría ser más limpio de todos modos.

sólo tiene que intitialize 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 sus caracteres, puede llamar al método Attack().

Answer 7

Tome un vistazo a la inyección de dependencias & entonces también mirar en Inversión de Control.

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

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

código de ejemplo de 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 IWeapon constructor). Ahora, al agregar Inversion of Control, obtienes aún más control.

El uso de un contenedor COI usted será capaz de controlar el IWeapon a través de inyección en lugar de en la propia clase.

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

de ejemplo de video:

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

La configuración anterior dice Ninject que cada vez que se encuentra con un iwarrior utilizar Samurai y siempre que encourters un IWeapon utilizar la espada.

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

Puede cambiarlos según lo necesite/desee.