Question

I have a doubt, i’ve searched a lot about it and i haven’t found nothing that can explain.

I can have a property referencing an interface inside my class, and make use of DI to fill these property. For example:

public interface ITest {
    void DoSomething();
}

public class Test {
    ITest _test;

    public Test(Itest _test)
    {
        this._test = test;
    }
}

The problem is, if I have an generic interface, and my class don’t make use of generics, when i create these property a compile error is raised

public interface ITest<T> {
    void DoSomething(T parameter);
}

public class Test {
    ITest<T> _test; //error (Type cant be found)

    public Test(Itest<T> _test)
    {
        this._test = test;
    }
}

Is this possible?

Answer 1

Your Test class needs to be generic too – otherwise there’s no way of knowing what kind of ITest<T> the _test variable refers to. How would you know how to call _test.DoSomething()? The type parameter of Test doesn’t have to be T, of course:

public class Test<TFoo> {
    ITest<TFoo> _test;

    public Test(ITest<TFoo> _test)
    {
        this._test = test;
    }
}

You’d then construct it as:

ITest<string> x = ...;
Test<string> test = new Test<string>(x);

Type safety would stop you from writing:

Test<int> test = new Test<int>(x);

because you can’t construct a Test<int> from an ITest<string>.

Alternatively, your Test class may only need to take one specific kind of ITest, and therefore not be generic at all:

public class Test {
    ITest<Guid> _test;

    public Test(ITest<Guid> _test)
    {
        this._test = test;
    }
}

It all depends on what you’re trying to achieve.

EDIT: As noted in comments, if your Test class doesn’t use any of the aspects of ITest<T> which rely on T, you might want to create a non-generic base interface:

public interface ITest {
    void DoSomethingBland();
}

public interface ITest<T> : ITest {
    void DoSomethingSpecific(T foo);
}

Then you could make your class just depend on the non-generic ITest interface instead of ITest<T>.