functionc#-4.0dynamic-datareturn-valuereturn-type

Why is it not possible to declare a function with VAR return type?


In C#, we have var data type but we can't use it as functions return type.
Why this is not possible?

public var myFunction()
{
    var = some operations
}

Solution

  • I believe it's partly due to the design of the compiler. Eric Lippert blogged about why fields can't use implicit typing, and I suspect some of the same arguments hold for methods.

    But you could easily end up with ambiguity anyway. For example:

    var Method1(bool callMethod2)
    {
        return callMethod2 ? Method2() : null;
    }
    
    var Method2()
    {
        return Method1(false);
    }
    

    What should the type be here?

    A simpler example:

    var Method1(bool throwException)
    {
        if (!throwException)
        {
            return Method1(true);
        }
        throw new Exception("Bang!");
    }
    

    Admittedly this sort of ambiguity could simply be disallowed, but I suspect that the design team felt that the added complexity of both design and implementation wasn't worth the benefit. Don't forget that they're running with limited resources - given a choice between var for methods and async/await, I'd pick the latter in a heartbeat. (Admittedly there are other features I'd have picked instead of dynamic, but that's a different matter...)

    Note that return type inference is performed for lambda expressions, so the very idea of it isn't crazy. For example:

    IEnumerable<string> x = new[] { "x", "y", "z" };
    
    var result = x.Select(s => { return s.Length; }); // Long form
    

    There the compiler infers the complete type of the lambda expression when it performs overload resolution on Select, converting it to a Func<string, int>. It's not inconceivable to apply the same ideas to methods - just complicated.