Method overloading return values

Question

In C# I need to be able to define a method but have it return one or two return types. The compiler gives me an error when I try to do it, but why isn't it smart enough to know which method I need to call?

int x = FunctionReturnsIntOrString();

Why would the compiler prevent me from having two functions with different return types?

Answer 1

The return type is not part of the method's signature, only the name and the parameter types. Because of this, you can't have two methods that only differ by the return type. One way to get around this would be for your method to return an object, then the calling code must cast it to either an int or string.

However, it might be better to create two different methods, or create a class to return from the method that can either contain an int or a string.

Answer 2

Have you though about using generics to return the correct type.

public T SomeFunction<T>()
{
    return T
}

int x = SomeFunction<int>();
string y = SomeFunction<string>();

Note: This code has not been tested

Answer 3

In C# there is no overridin return types, IL supports that kind of overriding but C# not...yet.

Answer 4

Because sometimes it really cannot tell which one it should then use (your example it could, but not all cases are that clear-cut):

void SomeMethod(int x) { ... }
void SomeMethod(string x) { ... }

In this context, if you call SomeMethod(FunctionReturnsIntOrString()) what should the compiler do?

Answer 5

While it may be obvious in this particular scenario, there are many scenarios where this is in fact not obvious. Lets take the following API for an example

class Bar { 
  public static int Foo();
  public static string Foo();
}

It's simply not possible for the compiler to know which Foo to call in the following scenarios

void Ambiguous() {
  Bar.Foo();
  object o = Bar.Foo();
  Dog d = (Dog)(Bar.Foo());
  var x = Bar.Foo();
  Console.WriteLine(Bar.Foo());
}

These are just a few quick samples. More contrived and evil problems surely exist.

Answer 6

Function differing only with return values do not qualify for the overloading.

int x = FunctionReturnsIntOrString();
doube y = FunctionReturnsIntOrString();

In the above case compiler can identify the correct functions but consider the cases in which return values are not specified, it is ambiguous.

FunctionReturnsIntOrString();   //int version
FunctionReturnsIntOrString();   //double version

Compiler cannot resolve the overloaded methods here.

Answer 7

I think you want to seriously reconsider what you're doing and how, but you CAN do this:

int i = FunctionReturnsIntOrString<int>();
string j = FunctionReturnsIntOrString<string>();

by implementing it like this:

private T FunctionReturnsIntOrString<T>()
{
    int val = 1;
    if (typeof(T) == typeof(string) || typeof(T) == typeof(int))
    {
        return (T)(object)val;
    }
    else
    {
        throw new ArgumentException("or some other exception type");
    }
}

but there are sooo many reasons not to.

Answer 8

From the last paragraph of section 1.6.6 of the C# 3.0 language specification:

The signature of a method must be unique in the class in which the method is declared. The signature of a method consists of the name of the method, the number of type parameters and the number, modifiers, and types of its parameters. The signature of a method does not include the return type.

In IL two methods can differ by return type alone, but outside of reflection there is no means to call a method that differs only be return type.

Answer 9

You are also not required to assign a value to a called method. For example:

int FunctionReturnsIntOrString() {return 0;}
string FunctionReturnsIntOrString() {return "some string";}

//some code
//...

int integer = FunctionReturnsIntOrString(); //It probably could have figured this one out

FunctionReturnsIntOrString(); //this is valid, which method would it call?