C# Generic Type Inheritance

Hi, To simplify your example allow me to take the list and the generic definition out of the equation. What you are trying to do is casting a class to another incompatible class implicitly without providing a mechanism telling the compiler how to do the casting.

 Class A {}
 Class B {}
 ...
 A obj = new B();

The code above will generate the same error you got because A and B are 2 separate types.

To solve t$$anonymous$$s error you have 2 options, either you implement a user defined type conversion like t$$anonymous$$s

 public class B 
 {
     public static implicit operator A(B obj)
     {
         return new A();
     }
 }

or you just simply make B inherits from A.

Now lets get back to the generic class definition, take a look at the following example

 //Behaviour is a Unity class where MonoBehaviour inherits from
 Class A<T> where T : Behaviour {}
 A<Behaviour> aBehaviour = new A<MonoBehaviour>();

t$$anonymous$$s will not compile successfully because the generic class A(Behaviour) is completely different than A(MonoBehaviour) even though MonoBehaviour is related to Behaviour and both types are supported by class A.

Put all that aside, IMO I see no need to have a generic class in your case, it just makes your code unnecessarily complicated. If you just do the following all will be fine.

 Class Building {}
 Class MiningBuilding : Building {}

You can't have a constructor like t$$anonymous$$s:

 class MiningBuilding : Building<MiningBuildingType>
 {
     public MiningBuilding(T type)
     {
         Type = type;
     }
 }

MiningBuilding could only have field "Type" of type MiningBuildingType (type of type lol)

 class MiningBuilding : Building<MiningBuildingType>
 {
     public MiningBuilding()
     {
         Type = new MiningBuildingType();
     }
 } 

Now declaring a List like t$$anonymous$$s:

 List<Building<BuildingType>>

won't let you to create it, because you can't create any instance of abstract class (building)

Adding intermediate building class can enable you to create generic list of buildings:

 abstract class BuildingBase<T> where T : BuildingTypeBase
 {
     public T Type;
 }
 
 abstract class BuildingTypeBase
 {
 
 }
 class MiningBuildingType : BuildingTypeBase { }
 
 class Building : BuildingBase<BuildingTypeBase>
 {
 
 }
 
 class MiningBuilding : Building
 {
     public MiningBuilding()
     {
         Type = new MiningBuildingType();
     }
 }
 
 public class Test
 {
     List<Building> buildings = new List<Building>();
     void myCode()
     {
         var b = new MiningBuilding();
         buildings.Add(b);
     }
 
 }