I am wondering if `dynamic` is semantically equivalent to `object` when used as a generic type parameter. If so, I am curious why this limitation exists since the two are different when assigning values to variables or formal parameters.

I've written a small experiment in C# 4.0 to tease apart some of the details. I defined some simple interfaces and implementations:

```
interface ICovariance<out T> { T Method(); }

interface IContravariance<in T> { void Method(T argument); }

class Covariance<T> : ICovariance<T>
{
    public T Method() { return default(T); }
}

class Contravariance<T> : IContravariance<T>
{
    public void Method(T argument) { }
}

```

The interesting details of the experiment:

```
class Variance
{
    static void Example()
    {
        ICovariance<object> c1 = new Covariance<string>();
        IContravariance<string> c2 = new Contravariance<object>();

        ICovariance<dynamic> c3 = new Covariance<string>();
        IContravariance<string> c4 = new Contravariance<dynamic>();

        ICovariance<object> c5 = new Covariance<dynamic>();
        IContravariance<dynamic> c6 = new Contravariance<object>();

        // The following statements do not compile.
        //ICovariance<string> c7 = new Covariance<dynamic>();
        //IContravariance<dynamic> c8 = new Contravariance<string>();

        // However, these do.
        string s = new Covariance<dynamic>().Method();
        new Contravariance<string>().Method((dynamic)s);       
    }
}

```

The first two statements with `c1` and `c2` demonstrate that basic covariance and contravariance are working. I then use `c3` and `c4` to show that `dynamic` can be used as a generic type parameter in the same fashion.

The statements with `c5` and `c6` reveal that a conversion from `dynamic` to `object` is always valid. This isn't really too surprising, since `object` is an ancestor of all other types.

The final experiment with `c7` and `c8` is where I start to become confused. It implies that methods that return `dynamic` objects are not substitutes for methods that return `string` ones, and similarly that methods that accept `string` objects cannot take `dynamic` ones. The final two statements with the assignment and method call show this is clearly not the case, hence my confusion.

I thought about this a little, and wondered if this is to prevent programmers from using `ICovariance<dynamic>` as a stepping stone between type conversions that would result in run-time errors, such as:

```
ICovariance<dynamic> c9 = new Covariance<Exception>();
ICovariance<string> c10 = c9;
// While this is definitely not allowed:
ICovariance<string> c11 = new Covariance<Exception>();

```

However, this is unconvincing in the case of `dynamic` since we lose type-safety anyway:

```
dynamic v1 = new Exception();
string  v2 = v1;

```

Put another way, the question is **"Why does the semantics of `dynamic` differ between assignment and covariance/contravariance with generics?"**