Allgemein Typ Verwendung

Question

Könnte jemand bestätigen, ob mein unter Ansatz richtig ist oder eine bessere Alternative:

// An interface 
IAnimal 
{ 
    pubilc void Hunt(); 
} 

// An abstract class 
Animal<T> : IAnimal 
{ 
    public void Hunt() 
    { 
     UseWeapon(T); 
    } 

    protected abstract T GetWeapon(); 
    protected abstract void UseWeapon(T weapon); 
} 

Damit ich Implementierungen wie haben könnte:

Tiger : Animal<Claw> 
Hyena : Animal<Teeth> 
Eagle : Animal<Beak> 

Für zB:

Tiger : Animal<Claw> 
{ 
    protected override void UseWeapon(Claw claw) 
    { 
     // logic here 
    } 

    protected override void GetWeapon() 
    { 
     // logic here to populate props & return Claw(); 
    } 
} 

Und dann könnte ich anrufen:

IAnimal animal = GetRandomAnimal(); // OR GetTiger(); 
animal.Hunt() 

Answer 1

Ich würde lieber diesen Ansatz verwenden, die sich leicht mit DI funktioniert:

interface IAnimal 
{ 
    pubilc void Hunt(); 
} 

interface IWeapon 
{ 
} 

Animal : IAnimal 
{ 
    IWeapon _weapon; 

    public void Animal(IWeapon weapon) 
    { 
     _weapon = weapon; 
    } 

    public void Hunt() 
    { 
     UseWeapon(_weapon); 
    } 

    protected abstract void UseWeapon(IWeapon weapon); 
} 

Wenn Sie mehrere Waffen brauchen, dann nur Sie IEnumerable<IWeapon> im Konstruktor injizieren und die Logik entsprechend ändern.