有没有很好的解耦c#中继承相同接口得到的类似代码的方法？

Question

假设，在代码中，我们有一个 IEnemy 接口，它上面有一个名为 Attack() 的方法。假设我们有五个来自 IEnemy 接口的敌人。在其中三个类中，我们使用完全相同的 Attack 方法实现。在其中之一中，我们也使用相同的代码，但在方法的某处更改了一两行代码。而且，在最后一个类中，我们仍然有相同的实现，但是在方法的某处添加/删除了一两行代码。您对解耦这段代码有什么建议吗？

我尝试过重写方法，如果我们在方法中间更改某些内容，则该方法不起作用。 我尝试使用委托作为参数，当我们想在方法中的其他地方更改某些内容时，它不起作用。 我尝试使用接口的扩展方法来制作默认实现，但其中两个类仍然具有解耦代码。

interface IEnemy
{
    void Attack();
}

class Enemy1 : IEnemy
{
    public void Attack()
    {
        Console.WriteLine("This is an enemy");
        Console.WriteLine("Enemy is jumping");
        Console.WriteLine("Enemy is attacking");
    }
}

class Enemy2 : IEnemy
{
    public void Attack()
    {
        Console.WriteLine("This is an enemy");
        Console.WriteLine("Enemy is jumping");
        Console.WriteLine("Enemy is attacking");
    }
}

class Enemy3 : IEnemy
{
    public void Attack()
    {
        Console.WriteLine("This is an enemy");
        Console.WriteLine("Enemy is jumping");
        Console.WriteLine("Enemy is attacking");
    }
}

//Let's say this enemy is not capable of jumping, so we want to remove the code that says enemy is jumping.
class Enemy4 : IEnemy
{
    public void Attack()
    {
        Console.WriteLine("This is an enemy");
        Console.WriteLine("Enemy is attacking");
    }
}

//Let's say this is the boss and instead of jumping, it will roar.
//So we want to change the code that says enemy is jumping to enemy is roaring.
class Enemy5 : IEnemy
{
    public void Attack()
    {
        Console.WriteLine("This is an enemy");
        Console.WriteLine("Enemy is roaring");
        Console.WriteLine("Enemy is attacking");
    }
}

Answer 1

我会将接口替换为具有默认实现的抽象基类，然后将Attack 方法分解为单独的可覆盖步骤。我将Attack 设置为虚拟的，用于完全拥有自己攻击模式的敌人。

abstract class BaseEnemy {
    public virtual void Attack() {
        AttackIdentify();
        AttackSignal();
        AttackAttack();
    }

    protected virtual void AttackIdentify() {
        Console.WriteLine("This is an enemy");
    }

    protected virtual void AttackSignal() {
        Console.WriteLine("Enemy is jumping");
    }

    protected virtual void AttackAttack() {
        Console.WriteLine("Enemy is attacking");
    }
}

class Enemy1 : BaseEnemy {
    protected override void AttackIdentify() {
        Console.WriteLine("This is an enemy 1");
    }
}

class Enemy2 : BaseEnemy {
}

class Enemy3 : BaseEnemy {
    protected override void AttackIdentify() {
        Console.WriteLine("This is an enemy 3");
    }
}

//Let's say this enemy is not capable of jumping, so we want to remove the code that says enemy is jumping.
class Enemy4 : BaseEnemy {
    protected override void AttackSignal() { }
}

//Let's say this is the boss and instead of jumping, it will roar.
//So we want to change the code that says enemy is jumping to enemy is roaring.
class Enemy5 : BaseEnemy {
    protected override void AttackSignal() {
        Console.WriteLine("Enemy is roaring");
    }
}

如果你还需要接口IEnemy，你可以让BaseEnemy实现它。

Answer 2

这里是它的抽象类版本的基本示例。

public abstract class Enemy
{
    public bool CanJump { get; set; } = false;
    public bool CanRoar { get; set; } = false;
    public bool CanAttack { get; set; } = false;

    public virtual void Attack()
    {
        Console.WriteLine("This is an enemy");

        if (CanJump)
        {
            Console.WriteLine("Enemy is jumping");
        }

        if (CanRoar)
        {
            Console.WriteLine("Enemy is roaring");
        }

        if (CanAttack)
        {
            Console.WriteLine("Enemy is attacking");
        }
    }
}

public class Enemy1 : Enemy
{
    public Enemy1()
    {
        CanJump = true;
        CanRoar = true;
    }
}

public class Enemy2 : Enemy
{
    public Enemy2()
    {
        CanRoar = true;
        CanAttack = true;
    }
}

public class Enemy3 : Enemy
{
    public Enemy3()
    {
        CanRoar = true;
        CanAttack = true;
    }

    public override void Attack()
    {
        base.Attack();

        Console.WriteLine("Custom thing");
    }
}

您会注意到Enemy1 和Enemy2 的工作方式相同，但设置了不同的属性，当您调用Attack 方法时将相应地显示这些属性。我希望您注意的有趣部分是覆盖该方法的Enemy3 类。这可以通过在 Enemy 抽象类中创建方法 Virtual 来实现。

此覆盖允许在类Enemy 中调用基类方法Attack，此外它还显示自定义值。所以它非常灵活。

请注意，这对于提供的示例非常有效，但是通过您的班级名称，我可以很容易地假设真正的项目是什么，这不是正确的方法。您不应该为每个敌人创建不同的类，但这超出了问题的范围。