Generics and Interface issue

Question

Given the following class and interface:

public class Test<T> { } public interface ITesting<T> { Test<T> LoadTest(); }

I can add a class with the following:

public class TestManager : ITesting<object> { #region ITesting public Test<object> LoadTest() { return new Test<object>(); } #endregion }

Which works fine and throws no errors. If I try to replace that class with the following:

public class TestDerived : Test<object> { } public class TestDerivedManager : ITesting<object> { #region ITesting public TestDerived LoadTest() { return new TestDerived(); } #endregion }

I now get the following error:

 Error 'TestDerivedManager' does not implement interface member 'ITesting.LoadTest()'. 'TestDerivedManager.LoadTest()' cannot implement 'ITesting.LoadTest()' because it does not have the matching return type of 'Test'.

But to me it seems like this should work as TestDerived is Test<object>. I'm obviously not understanding something correctly here. Could someone possible point me to details on why this is incorrect? And possibly what I might do to correct it?

I note that this behaviour has nothing whatsoever to do with generics. If you had interface I { Animal M(); } class C : I { public Giraffe M() { return new Giraffe(); } } you'd get the same error. — Eric Lippert
– Eric Lippert, Commented May 13, 2013 at 15:00

Eric Lippert · Accepted Answer · 2013-05-13 14:13:24Z

The feature you want is called return type covariance. It is a feature of c++ but not of c#, so you'll have to do what the error says.

I recommend you make an explicit interface implementation that calls your public method. That way you get the best of both worlds.

Daniel Hilgarth · Accepted Answer · 2013-05-13 13:43:53Z

A TestDerived is a Test<object>, yes, but a Test<object> is not a TestDerived.

The contract says that ITesting<object> has a method that can return any Test<object>. Not just one special case (TestDerived).

To make your code work, change it as follows:

public class TestDerivedManager : ITesting<object> { public Test<object> LoadTest() { return new TestDerived(); } }

juharr · Accepted Answer · 2013-05-13 13:41:28Z

Change the return type of the method back to Test<object> and it should work. The return type is part of the contract when implementing an interface. You can still return the TestDerived since it is a Test<object>.

It would but I don't think it explains why it doesn't work when TestDerived is actually Test<Object>

Jeremy Todd · Accepted Answer · 2013-05-13 14:21:08Z

What you're looking for is called "return type covariance," and unfortunately is not supported by C#. You can't override (or implement) a method with a different return type than the original signature, even if that return type derives from the original return type.

What you can do (which may or may not be a good idea) is implement the interface explicitly and have that call a public method that returns the narrower type you're looking for:

public class TestDerived : Test<object> { } public class TestDerivedManager : ITesting<object> { public TestDerived LoadTest() { return new TestDerived(); } Test<object> ITesting<object>.LoadTest() { return this.LoadTest(); } }

That adds an extra layer of complication to your implementation, but it also gives you the public contract you're looking for, along with compatibility with the interface.

Fendy · Accepted Answer · 2013-05-13 14:16:52Z

Everyone has good technical answer but no one explain why. So I think I will give an illustration about interface.

The general way of interface programming is you should implement the exact method or property described in interface. Let's say that you has interface:

public interface ITesting<T> { Test<T> LoadTest(); }

The usage of this interface in your consumer should be like this:

ITesting<object> testingLoader = GetTestingLoader(); Test<object> testingLoader.LoadTest();

If you access the object by using the interface, you don't know the implementation. You only know that the interface ITesting<T> will return Test<T> for the LoadTest() method.

It will come into sense when you see the consumer example above. You (and the compiler) don't (and won't) know that the interface ITesting<object> has a method Test<object> LoadTest() unless you declare it. And what will happen if you try to use an object that is implemented ITesting<object> but has no Test<object> LoadTest() method? It will error won't it?

This is following the LSV principle.

Erhm, no, you are wrong. Talking about LSP: I should be able to treat a TestDerivedManager object as a ITesting<object>, call LoadTest on it and get a Test<object> (as the interface specifies). The implementation returns a TestDerived, which is a Test<object>. So all is well, no LSP violation, and the code should just work. No erroring. Only caveat: some languages support it, but not C#.

Collectives™ on Stack Overflow

Generics and Interface issue

5 Answers 5

Comments

Comments

1 Comment

Comments

1 Comment

Hot Network Questions

Collectives™ on Stack Overflow

5 Answers 5

Comments

Comments

1 Comment

Comments

1 Comment

Related