通用类型约束不适用

Question

I'm writing an emulator and I came across an interesting error:

error CS0311: The type 'T' cannot be used as type parameter 'T' in the generic type or method 'Emulator.Emulator<T>' . There is no implicit reference conversion from 'T' to 'Emulator.Emulator<T>.EmulatorState' .

The error is on the following code (specifically the T at Emulator.IOpcode):

protected abstract class Chip8Opcode<T> : Emulator<T>.IOpcode where T : Chip8.Chip8State

The simplified code is below ( ideone ):

public abstract class Emulator<T> where T : Emulator<T>.EmulatorState
{
    public abstract class EmulatorState { }
    public interface IOpcode
    {
        bool IsValid(T state);
        void Execute(T state);
    }
}

public class Chip8 : Emulator<Chip8.Chip8State>
{
    public class Chip8State : EmulatorState { }
}

abstract class Chip8Opcode<T> : Emulator<T>.IOpcode where T : Chip8.Chip8State
{
}

To my understanding the T should be limited to Chip8State, which can be converted to EmulatorState (which is what Emulator<> requires), however it seems that the generic type constraint isn't applying to the T in Emulator<T> , as the error is "The type 'T'" and not "The type 'Chip8State'." Is this a bug in the compilation or is there a better way to apply type constraints to inherited generics?

Note: This is not a duplicate to similar questions about type collisions, since T is never seen as the constrained type.

Also: Generics are in place to allow easy extending of the emulator if needed later, although it would be nice to know if there is a better way to do it.

Answer 1

Another way to solve the issue that I used was to create an interface for each class and have them implement it, which allowed covariance and contravariance to be applied correctly in later classes.

interface IEmulator<out T> where T : IEmulatorState
{ ... }
public interface IEmulatorState
{ ... }

which allows:

public abstract class Emulator<T> : IEmulator<T> where T : IEmulatorState
{ ... }

public interface IOpcode<in T> where T : IEmulatorState
{ ... }

and most importantly

abstract partial class Chip8Opcode<T> : IOpcode<T> where T : Chip8<T>.Chip8State
{ ... }

Answer 2

Can't you just put it like:

abstract class Chip8Opcode<T> : Emulator<Chip8.Chip8State>.IOpcode
    where T : Chip8.Chip8State

Also, check that subject about "covariance and contravariance in generics". It is only possible with interfaces in C#, to some extent.