Why can't I implement an Interface this way? [duplicate]

Answer 1

From the C# Language Specification:

13.4.4 Interface mapping

For purposes of interface mapping, a class member A matches an interface member B when:

• A and B are methods, and the name, type, and formal parameter lists of A and B are identical.

Note that it does not say anything about inheritance or convertability! The return type must be identical.

Answer 2

Because the interface specifies that the method MUST return an object. A string may inherit from object, but the interface specifies a method that returns the much more generic type.

Keep in mind, though, there's nothing stopping you from doing the following:

public object Moop()
{
    return "Some new string";
}

Answer 3

You are not meeting the contract. However, you can do this with generics:

public interface IMoop<T>
{
    T Moop();
}

public class MoopImplementor : IMoop<string>
{
    public string Moop() { return ""; }
}

Answer 4

C# does not support return type covariance for the purposes of interface implementation or virtual method overrding. See this question for details:

Does C# support return type covariance?

C# does support generic covariance and contravariance of interfaces and delegate types that are constructed wtih reference types for the type arguments as of C# 4.

And C# does support return type covariance when converting a method that returns a reference type to a delegate type whose return type is a compatible reference type. (And similarly it supports parameter type contravariance.)

If this subject interests you, I have written a great many articles discussing various versions of variance that C# does and does not support. See

https://blogs.msdn.microsoft.com/ericlippert/tag/covariance-and-contravariance/

for details.

Answer 5

A reasonable work-around:

public class MoopImplementor : IMoop {
  public string Moop() { ... }
  object IMoop.Moop() { return Moop(); }
}

This allows the public implementation on MoopImplementor to have the more accurate type while still fulfilling the requirements of the interface.