如何实现接受任何参数的接口方法？

Question

I have a EnemyManager that handles class instances that implement an interface: IEnemy.

public class EnemyManager
{
   public void AddEnemy(IEnemy enemy)
   {
      // Initialize enemy ...
   }
}

public interface IEnemy
{
   void Init<T>(T enemyData);
}

I want every instance to be initialized with a different custom type: EvilSkeletonData, BossEnemyData ... etc. But I do not want to create an overload for each of those datatypes to maintain my interface as clean as possible.

I was thinking that Generics could work but perhaps it defeats the purpose as I would need to explicitly convert the data on each IEnemy implementation:

public class EvilSkeleton : IEnemy
{
   public void Init<T>(T enemyData)
   {
      var enemyData = initParams as EvilSkeletonData;
      if(enemyData != null)
      {
          // Logic here
      } 
   }
}

What would be a clean (and if possible efficient) way to solve this?

Answer 1

You can manage a generic IEnemy interface to use it with custom data (like EvilSkeletonData , BossEnemyData , etc), instead of having just a generic Init method. And non-generic version to have any common data for any enemy (like health for example)

public interface IEnemy
{
    int Health { get; set; }
}

public interface IEnemy<in T> : IEnemy
{
    void Init(T enemyData);
}

public class EvilSkeletonData
{
}

public class EvilSkeleton : IEnemy<EvilSkeletonData>
{
    public int Health { get; set; }

    public void Init(EvilSkeletonData enemyData)
    {
    }
}

Non-generic IEnemy interface also allows you to correctly pass the instance to AddEnemy method in EnemyManager class, otherwise you'll face with some casting and generic variance issues. Example of the usage

var manager = new EnemyManager();

var skeleton = new EvilSkeleton();
skeleton.Init(new EvilSkeletonData());

manager.AddEnemy(skeleton);

Answer 2

To clarify, I was talking about this in comments (if I understand you correctly):

public interface IEnemy
{
    void Init(object enemyData);
}

public interface IEnemy<T> : IEnemy
{
    void Init(T enemyData);
}

public class EvilSkeleton : IEnemy<EvilSkeletonData>
{
    public void Init(EvilSkeletonData enemyData)
    {
        // Logic here
    }

    void IEnemy.Init(object enemyData) => Init((EvilSkeletonData)enemyData);
}

public class EnemyManager
{
    public void AddEnemy(IEnemy enemy)
    {
        // Initialize enemy ...
        enemy.Init(new EvilSkeletonData());
    }
}