更复杂的扩展 generics 到 C#

Question

I have two trees of classes with generics and I cannot figure out one thing, that I know how to solve in Java with <? extends...><? extends...> .

First AI tree:

abstract class AbstractAI<TCtrl> : MonoBehaviour where TCtrl: IRotableWeaponController

abstract class AbstractShipAI : AbstractAI<IShipController>

class ModularAI : AbstractShipAI

Some other classes that extend AbstractAI and use various modules

Modules tree:

abstract class AbstractModule<TAi, TCtrl> : AIModule where TAi: AbstractAI<TCtrl> where TCtrl: IRotableWeaponController
{
    public virtual void Init(TAi parent)
}

class ShootModule: AbstractModule<AbstractAI<IRotableWeaponController>, IRotableWeaponController>

Some other modules that extend AbstractModule and can be used only with some AIs, that have required capabilities

Used controller interfaces tree:

interface IRotableWeaponController

interface IShipController: IRotableWeaponController

Other interfaces extending IRotableWeaponController...

The issue is:

class ModularAI : AbstractShipAI
{
    public ShootModule shootModule;

    protected override void Start()
    {
        shootModule.Init(this); // Error: Argument type 'ModularAI' is not assignable to parameter type 'AbstractAI<IRotableWeaponController>'    
    }
}

ModularAI is AbstractAI<IShipController> , IShipController is IRotableWeaponController , but I get an error.

In Java I would do:

abstract class AbstractModule<TAi, TCtrl> : AIModule where TAi: AbstractAI<? extends TCtrl> where TCtrl: IRotableWeaponController

I know it's kind of complex and there is probably a better way to design it (and I may eventually get to it one day) but I want to know, how to solve this issue. Please, how can I make it work?

Answer 1

I made an easier example to illustrate your issue:

class Fruit { }
class Apple : Fruit { }
class FruitMaker<T> where T : Fruit { }

class Program
{
    static void HandleFruit(FruitMaker<Fruit> fruitMaker) { }

    static void Main()
    {
        FruitMaker<Apple> appelMaker = new FruitMaker<Apple>();
        FruitMaker<Fruit> fruitMaker = appelMaker; //cannot convert from 'FruitMaker<Apple>' to 'FruitMaker<Fruit>'
        HandleFruit(fruitMaker);

    }
}

What you need is generics covariance, you need to pass FruitMaker<Apple> to a method that expects FruitMaker<Fruit> . This is enabled with the out keyword, what you want is class FruitMaker<out T> where T: Fruit { } , but you can't do that because FruitMaker is not an interface. You can solve this as follows:

class Fruit { }
class Apple : Fruit { }
interface IFruitMaker<out T> where T : Fruit { }
class FruitMaker<T> : IFruitMaker<T> where T : Fruit { }

class Program
{
    static void HandleFruit(IFruitMaker<Fruit> fruitMaker) { }

    static void Main()
    {
        FruitMaker<Apple> appelMaker = new FruitMaker<Apple>();
        IFruitMaker<Fruit> fruitMaker = appelMaker; //this is allowed thanks to the out keyword
        HandleFruit(fruitMaker);

    }
}

Notice that I introduced an interface just to be able to add the out keywork.

Answer 2

You can use Covariance by inserting an interface in place of the abstract class, appropriately marked for it:

interface IAbstractAI<out TCtrl> where TCtrl : IRotableWeaponController {
}

abstract class AbstractAI<TCtrl> : MonoBehaviour, IAbstractAI<TCtrl> where TCtrl : IRotableWeaponController {
}

abstract class AbstractModule<TAi, TCtrl> : AIModule where TAi : IAbstractAI<TCtrl> where TCtrl : IRotableWeaponController {
    public virtual void Init(TAi parent) {
    }
}

class ShootModule : AbstractModule<IAbstractAI<IRotableWeaponController>, IRotableWeaponController> {
}

class ModularAI : AbstractShipAI {
    public ShootModule shootModule;

    protected override void Start() {
        shootModule.Init(this); // Error: Argument type 'ModularAI' is not assignable to parameter type 'AbstractAI<IRotableWeaponController>'    
    }
}