Множественное наследование и гетерогенная коллекция в C #

борется с заданием, предназначенным для перевода чего-то, что работает в C ++, в C #.

Я знаю, что истинное множественное наследование не поддерживается в C #, но что оно может быть смоделировано через интерфейсы и композицию.

В C ++ у меня есть дизайн, где два класса наследуются от одного родительского класса. Скажем, Vehicle — родительский класс, а Car и Boat наследуются от Vehicle.

Есть второй класс, из которого получены еще три класса. Давайте назовем эту лицензию. Три дополнительных класса наследуются как от трех классов транспортных средств, так и от класса лицензии.

Итак, у нас есть что-то вроде:

    // C++
class Vehicle
{
public:
virtual void move();
};

class Car : public Vehicle
{
public:
void move();
};

class Boat : public Vehicle
{
public:
void move();
};

class License
{
public:
void renew();
};

class LicensedVehicle : public Vehicle, public License {...};
class LiscensedCar : public Car, public License {...};
class LisencedBoat : public Boat, public License {...};

Теперь в моем основном методе я могу создавать объекты для трех вышеупомянутых классов с множественным наследованием и добавлять их в два массива указателей, одного из типа Vehicle и одного типа License. Затем я могу получить доступ к половине функциональности Транспортного средства из одного массива и функциональности Лицензии из другого. Например:

    // C++
Vehicle* VehicleHeteroArray[3];
License* LiscenseHeteroArray[3];

LisencedVehicle* lvPtr = new LisencedVehicle();
LisencedCar* lcPtr = new LisencedCar();
LisencedBoat* lbPtr = new LisencedBoat();

VehicleHeteroArray[0] = lvPtr;
LiscenseHeteroArray[0] = lcPtr;

VehicleHeteroArray[1] = lcPtr;
LiscenseHeteroArray[1] = lcPtr;

VehicleHeteroArray[2] = lbPtr;
LiscenseHeteroArray[2] = lbPtr;

Теперь я могу пройтись по этим двум массивам и получить доступ ко всем методам в Vehicle и License. Например:

    // C++
for (int i = 0; i < 3; i++)
{
VehicleHeteroArray[i].move();
LiscenseHeteroArray[i].renew();
}

Теперь это прекрасно работает в C ++, поэтому мой вопрос касается перевода этого на C #. Есть ли разумный способ сделать что-то подобное?

На данный момент у меня настроены три класса транспортных средств, а три класса «имитированного множественного наследования» настроены следующим образом:

    // C#
class Vehicle
{
public virtual void move();
}

class Car : Vehicle
{
public override void move();
}

class Boat : Vehicle
{
public override void move();
}

interface ILicense
{
void renew();
}

class License : ILicense
{
public void renew();
}

class LicensedVehicle : Vehicle, ILicense
{
License l;

void ILicense.renew()
{
l.renew();
}
}

class LiscensedCar : Car, ILicense {...}
class LisencedBoat : Boat, ILicense {...}

Я знаю, что могу создать гетерогенный массив типа Vehicle и access move (), но есть ли способ иметь гетерогенную коллекцию для доступа к renew (), как я делал в C ++ с LiscenseHeteroArray []?