Polymorphism in generic type parameters

Yes, you misunderstood how generic works. This is as well the biggest limitation to usage of Generic types (in fact you should avoid them as much as possible because of that). If Derived inherits from Base then it is normally not true that Generic<Derived> is Generic<Base>. The exception to this is covariance and contravariance. In C# it works only with interfaces and delegate types. If you define your Generic interface like:

public interface Generic<out T> {}

then Generic<Derived> is Generic<Base>

If you define your Generic class like:

public interface Generic<in T> {}

then Generic<Base> is Generic<Derived> (surprise, huh?).

Why the simple cast does not work? Imagine object of a class implementing interface that looks as follows:

public interface Generic<T> 
{
    public void Func1(T input);
    public T Func2();
}

Imagine we have Generic<Derived> object and we are using it as Generic<Base>. In this case Func2 works perfectly - it returns Derived object which can be caster to Base. But Func1 won't work - we have a function that accepts Base object but the actual object has Func1 that accepts only Derived objects and not all Base objects are Derived, right?

This example explains why with in and out inheritance works. If we apply in constraint on type parameter in generic class we commit that T type may only be returned from properties or functions, but it may never be accepted as parameter. In such case our Generic interface looks like this:

public class Generic<out T> 
{
    public T Func2();
}

As we exaplained in previously Func2 will work fine if we will use Generic<Derived> object as Generic<Base>. For the same reason for an interface:

public interface Generic<in T> 
{
    public void Func1(T input);
}

Func1 will work fine if object Generic<Base> will be used as Generic<Derived> - in this case we will always pass to Func1 Derived objects as parameters and Dervied is always Base by definition.