通用接口约束

Question

I have a question about generics and the use of interfaces cast when creating concret classes:

namespace MyNamespace
{
    interface ITest
    {

    }

    class Timpl : ITest
    {

    }

    class Test<T> where T : ITest
    {
        public T get()
        {
            return default(T);
        }
    }

    class MyClass
    {
        public MyClass()
        {
            Test<ITest> s = new Test<Timpl>(); //Does not compile
        }
    }
}

I read up on co- and contravariant, but I must be missing something, or it has nothing to do what I'm trying, or it just doesnt work what I'm trying to do.

I though I could make the cast from Test to Test because TImple inherits from ITest.

Answer 1

It should be

class Test<T> where T : ITest
{
    public T get()
    {
        return default(T);
    }
}

Then create an instance of Test like

var s = new Test<Timpl>();

EDIT:

Based on the comment below. Ok, now you are dealing with covariance and contravariance. If you need to specify

Test<ITest> s = new Test<Timpl>();

then it can't work because only generic type parameters of interfaces and delegates can be marked as covariant or contravariant.

However, you could solve it by making Test implement an interface.

interface ITestClass<out T>
{
    T get();
}

class Test<T> : ITestClass<T> where T : ITest
{
    public T get()
    {
        return default(T);
    }
}

ITestClass<ITest> s = new Test<Timpl>(); // Does compile

Answer 2

try this.

namespace MyNamespace
{
    interface ITest
    {
    }

    class Timpl : ITest
    {
    }

    class Test<T> where T : ITest
    {
        public T get()
        {
            return default(T);
        }
    }

    public class mycls : ITest
    {
    }

    class MyClass
    {
        public MyClass()
        {
            Test<mycls> s = new Test<mycls>(); //will compile
        }
    }
}

Answer 3

I think I understand your problem. You can read about covariance and contravariance at the following MSDN link : http://msdn.microsoft.com/en-us/library/vstudio/ee207183.aspx

My Solution to your problem looks like this

interface ITest { }

class TImpl:ITest
{

}

interface ITest<out T>
{
    T get();
}

class Test<T>:ITest<T> 
          where T:ITest
{
    public T get()
    {
        return default(T);
    }
}

As you can see , I've added and interface over your Test class and I've marked the Type argument, T, as out. Now you can do the following:

 ITest<ITest> t = new Test<TImpl>();

I hope this helps