function return type feature request

[masteroleary]

Properties have this magic convention in the setter called "value" which is not explicitly typed in the set arguments.

        private string _someString { get; set; }
        public string SomeString  { 
        get { return _someString; } 
        set 
            {
                _someString = value;
            }
        }

Currently we need to explicitly define the return object with the function body

        public MyObj MyFunction()
        {
            MyObj toReturn = null;
            if (SomethingIsTrue)
            {
                toReturn = new MyObj (); 
            } 
            return toReturn ;
        }

Functions already know the return type so there should be a similar convention with the magic "value"

        public MyObj MyFunction()
        {
            if (SomethingIsTrue)
            {
                value = new MyObj ();  
            } 
            return; // This either returns null since value has not been instantiated or returns whatever "value" was set to
        }

[svick]

What's wrong with directly returning right the value?

public MyObj MyFunction()
{
    if (SomethingIsTrue)
    {
        return new MyObj (); 
    }
    return null;
}

My primary issue with this is that it makes it too easy to forget to return a value: Today, if I write return; in a non-void function, it's a compile error. With this proposal, it would presumably return default, which is likely a bug.

Also, what happens if something called value already exists, e.g. a field?

[kindasimple]

Make C# VB Again!

[HaloFour]

That's not even good practice in VB since VB.NET added a proper Return keyword. Remains mostly for legacy migration purposes.

[Unknown6656]

How about

public MyObj MyFunction() => SomethingIsTrue ? new MyObj() : null;

?

---

I know, this is not applicable in the general case ....
But what about the case (as @svick said), when a field/variable/function/.... is already called value? And is it that much effort to type the five characters after typing return? ^^

[sirgru]

I actually like the idea the function already knows its return type so we don't have to declare the result. There was a proposal floating around to re-use the value keyword.

public MyObj MyFunction() {
            if (SomethingIsTrue)
            {
                value = new MyObj (); 
            } 
            return value;
        }

also, in a case where we are dealing with lists, Intellisense should know to pop-up the types when pressing = on example below:

public List<MyObj> MyFunction() {
            value = new List<MyObj>();
            if (SomethingIsTrue)
            {
                value.Add(new MyObj ()); 
            } 
            return value;
        }

[HaloFour]

@sirgru

What exactly would be returned in the first example? To remain consistent with the rest of the language that should be a compiler error as value is not definitely assigned. And that doesn't explain why you wouldn't just return from the function at the point that you know the result instead of allowing the function to continue to flow. In languages where a feature like this does exist, like VB, that is a known vector for common bugs, where the function value is assigned but the function continues to execute resulting in that value being reassigned to a wrong value:

Public Function MyFunction() As Integer
    If SomethingIsTrue Then
        MyFunction = 1
    End If
    MyFunction = 2 ' oops!
End Function

[alrz]

A prototype is available at dotnet/roslyn with vbc.exe.

Seriously though, the fact that this feature exists in VB for compat reasons clearly shows that it's not a good idea to be duplicated in C#.

[sirgru]

@HaloFour The return type would be default(T) of the return type of function, implicitly assigned by the compiler before the function body. There can be plenty of examples where we want to result.Add(anotherValue) so returning immediately is not always an option.

[jnm2]

If implicit return locals were ever added to C#, I would request a diagnostic and quick fix to replace it with clean code so that I could force the diagnostic to error level for every project. I wouldn't want anyone to accidentally use it.