Method with same name and signature but different return type in C#

Question

I had an interview where I was asked the following:

Question: A method with same name and signature but different return type. Is it possible and what is this type called he asked me.

Can someone please tell me the following:

1. Is above thing possible in any scenarios (Like one in base class and one in derived class atleast ?) If so what type is it ? Like compile or runtime polymorphism ?

2. In compile time polymorphism, what if the return types of methods are also different along with signature ? But only the name of function is same. Is it compile time polymorphism still ?

3. In overriding, what if I have different return type but the method name and signature are same ? Is it possible ? (He asked me this question, I answered wronglY :() Please help me.

Thank you

Answer 1

I assume the question is about return type covariance

It allows a method to return a more-derived type than the one declared in a base type e.g.

public interface ISomeInterface
{
    object GetValue();
}

public class SomeClass : ISomeInterface
{
    public string GetValue() { return "Hello world"; }
}

This is supported in Java but not in C#. The above will not compile since the return type of SomeClass.GetValue is string not object.

Note that you cannot overload methods based on return-type alone i.e. the following is not valid:

public class SomeClass
{
    public int GetValue() { return 1; }
    public string GetValue() { return "abc"; }
}

You could do something similar using interfaces although you would need to implement them explicitly to disambiguate:

public interface IValue<T> { T GetValue(); }
public class SomeClass : IValue<int>, IValue<string>
{
    string IValue<string>.GetValue() { return "abc"; }
    int IValue<int>.GetValue() { return 1; }
}

If the names are the same but the parameters are different then this is method overloading. This is a form of polymorphism (ad-hoc polymorphism). Overloads are resolved statically at compile-type (unless you're using dynamic in which case they are deferred to run-time).

You can overload on both the number of parameters and their type, so the following are all valid:

public void DoSomething(int value) { }
public void DoSomething(string value) { }
public void DoSomething(int value, string value) { }

Note that you can vary the return type of these methods - methods cannot only be overloaded based on their return type alone but they can differ if their parameter lists are different.

Again this is return type covariance and is not supported in C#.

Answer 2

In C#, you cannot have methods like

int Foo() { return 1; }

void Foo() { return; }

They must vary by more than return type.

If the arguments are different, then you're good to go.

int Foo(string x) { return 1; }

void Foo(double x) { return; }

Answer 3

Though return type covariance is not supported in C#, it is possible to emulate it by using explicit implementation and method hiding. That is a pattern which is used thoroughly in the ADO.NET APIs.

E.g.:

public interface ISomeValue { }
public abstract class SomeValueBase : ISomeValue { }
public class SomeValueImpl : SomeValueBase { }

public interface ISomeObject { ISomeValue GetValue(); }

public abstract class SomeObjectBase : ISomeObject
{
    ISomeValue ISomeObject.GetValue() { return GetValue(); }
    public SomeValueBase GetValue() { return GetValueImpl(); }

    protected abstract SomeValueBase GetValueImpl();
}

public class SomeObjectImpl : SomeObjectBase
{
    protected override SomeValueBase GetValueImpl() { return GetValue(); }
    public new SomeValueImpl GetValue() { return null; }
}

By doing that, the net result of calling GetValue() is that it will always match the most specific available type.