Comment utiliser le modèle de stratégie avec C#?

Question

Voici ce que j'ai jusqu'à présent:

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

Maintenant, si j'ai une superclasse Character.cs. Comment cette super-classe peut-elle implémenter un comportement d'arme afin que les classes enfants puissent être plus spécifiques?

namespace Strategy 
{ 
    class Character 
    { 
     public IWeaponBehavior weapon; 

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

namespace Strategy 
{ 
    class Thief : Character 
    { 

    } 
} 

Comment puis-je implémenter cela? Je suis très confus sur ce que le code doit être.

Je sais que cela pourrait être trop demander, mais si vous pouviez écrire le code réel afin que je puisse l'étudier, ce serait très gentil de votre part. J'apprends en voyant du code. : P Beaucoup de gens pourraient bénéficier de cette question.

Answer 1

Voici un article très axé sur l'utilisation de ce modèle en C#: http://www.lowendahl.net/showShout.aspx?id=115

Answer 2

Utiliser l'injection de dépendance en classe 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 

Édité selon les besoins.

Answer 3

Il y a quelques possibilités. Ce que vous demandez vraiment, c'est "comment un personnage spécifique devrait-il savoir quelle arme utiliser?". Vous pouvez avoir une fabrique de personnage qui créerait et injecterait le bon type d'arme dans le personnage (qui sonnait mal :)), ou laisser le constructeur d'un personnage spécifique s'occuper de créer l'arme.

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 vos personnages ont tous leur propre arme spécifique, vous n'avez pas réellement besoin d'utiliser le modèle de stratégie. Vous pourriez utiliser le polymorphisme simple. Mais le schéma de stratégie pourrait être plus propre de toute façon.

Vous avez juste besoin Initialisez l'arme:

public class Character 
{ 
    IWeapenBehavior weapon; 

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


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

Dans le code qui contrôle vos personnages, vous pouvez appeler la méthode Attack().

Answer 7

Jetez un coup d'œil à l'injection de dépendances & puis regardez également dans Inversion de contrôle.

TekPub a un super épisode gratuit sur ces deux idées en utilisant un échantillon très similaire au vôtre. Cela devrait vous aider avec un échantillon concret. :-)

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

Exemple de code de la vidéo:

class Samurai { 
    IWeapon _weapon; 

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

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

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

Ce qui précède est DI (avec constructeur IWeapon). Maintenant, en ajoutant Inversion of Control, vous gagnez encore plus de contrôle. En utilisant un conteneur IOC, vous serez en mesure de contrôler l'Iweapon par injection plutôt que dans la classe elle-même.La vidéo utilise NInject comme IOC et montre comment vous pouvez éliminer le constructeur IWeapon et prendre le contrôle de la classe et de toutes les classes ayant besoin d'utiliser IWeapon pour utiliser ce que vous voulez dans un emplacement/zone de configuration.

Echantillon de la vidéo:

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

La configuration ci-dessus indique que Ninject chaque fois qu'il rencontre un iWarrior à utiliser Samouraï et chaque fois qu'il encourters un IWeapon d'utiliser l'épée.

La vidéo continue pour expliquer comment ce petit changement augmente votre flexibilité. Il ajoute un autre module pour une samourie qui utilise une arme à distance, etc ....

Vous pouvez les modifier au besoin.