Suggestion: Add syntactic sugar for IEnumerable property { get { yield return Something(); } }

[Enderlook]

Just a humble idea:

Imagine that you want to make a property of IEnumerable, like this one:

public class MyClass
{
	public IEnumerable<string> MyProperty {
		get {
			yield return GetSomething();
			yield return GetOtherthing();
		}
	}
}

Everything is fine, but what if you only want to return a single element?
Like:

public class MyClass
{
	public IEnumerable<string> MyProperty {
		get {
			yield return GetSomething();
		}
	}
}

It's quite long.

You can reduce it as:

public class MyClass
{
	public IEnumerable<string> MyProperty { get { yield return GetSomething(); } }
}

But then it makes a bit difficult to read.

Another thing you can do is:

public class MyClass
{
	public IEnumerable<string> MyProperty => new string[] { GetSomething() };
}

But you are adding an array, which also increases noise, some readers may wonder why the array, and it's only executed when you call the property (not each time you use the IEnumerable).

Wouldn't be nice if you could just do?

public class MyClass
{
	public IEnumerable<string> MyProperty => GetSomething();
}

And the compiler infers that and translate it to one of the examples above (which one is something that the development team should decide).

Maybe that could produce ambiguity in some obscure cases, like:

public class ObscureClass : IEnumerable<string>, IEnumerable
{
    private string value;
    
    public ObscureClass(String value) => this.value = value;
    
    private IEnumerable<String> GetCharactersAsStrings() => value.ToCharArray().Select(e => e.ToString());
    
    IEnumerator<string> IEnumerable<string>.GetEnumerator() => GetCharactersAsStrings().GetEnumerator();
    
    IEnumerator IEnumerable.GetEnumerator() => GetCharactersAsStrings().GetEnumerator();

    public static implicit operator string(ObscureClass instance) => instance.value;
}

public class MyClass
{
	public IEnumerable<string> MyProperty => new ObscureClass("Hi");
	/* Ambiguity: should this be translated as?
	 * public IEnumerable<string> MyProperty { get { return new ObscureClass("Hi"); } }
	 * Or:
	 * public IEnumerable<string> MyProperty { get { yield return new ObscureClass("Hi"); } }
	 */
}

In order to prevent that the yield keyword could be used instead:

public class MyClass
{
	public IEnumerable<string> MyProperty => new OscureClass("Hi");
	/* Equal to:
	 * public IEnumerable<string> MyProperty { get { return new OscureClass("Hi"); } }
	 */
	
	public IEnumerable<string> MyProperty => yield new OscureClass("Hi");
	/* Equal to:
	 * public IEnumerable<string> MyProperty { get { yield return new OscureClass("Hi"); } }
	 */
}

Just an idea.

[CyrusNajmabadi]

You can just add an extension for this:

public static IEnumerable<T> ToEnumerable<T>(this T value)
{
    yield return value;
}

// ...

public IEnumerable<string> MyProperty => GetSomething().ToEnumerable();

[Enderlook]

Of course @CyrusNajmabadi, but that produces some minor issues:

1. Comfort: for every project, you must create a class with that extension method on it or make a package which you must install in every project.
2. Usability: that is not a built-in method from .Net, which means every project would make its own extension. If you use 3rd party code, you would have several times the same extension method but in different classes/namespaces.
3. Performance: not a great issue, but that add an additional method call.

Instead, if the compiler does that:

• It will be clean and easy to read.
• It will be universal, no need to implement it on each project.
• You will save a method call.

[HaloFour]

This would be a breaking change if the return value of the method is both T and IEnumerable<T>.

You can take it up with the Runtime repo to see if they are interested in adding Enumerable.Once<T>(T) or something of the like.

[Enderlook]

@HaloFour to avoid the breaking change couldn't be used the keyword yield or that would still produce the problem?

[jnm2]

public IEnumerable<string> MyProperty => new[] { GetSomething() }; hasn't been mentioned.

[CyrusNajmabadi]

Instead, if the compiler does that:

The compiler needing to add a full language feature to save form typign a single method call doesn't seem useful enough for such an extremely narrow case. How often are you yielding exactly one element? It's not common enough or difficult enough to warrant a language feature here.

[CyrusNajmabadi]

@jnm2 it was mentioned in the OP. Or perhaps you mean the inferred-type version of the array?

[Enderlook]

Oh, well, so the complexity of the task is not worth.
I'm not very accustomed to raise issues... should now I close it?

[jnm2]

Yes, the inferred-type version is next to no extra syntax.

[quinmars]

Just a side note:

public IEnumerable<string> MyProperty { get { yield return GetSomething(); } }

and

public IEnumerable<string> MyProperty => new string[] { GetSomething() };

are not equivalent. In the first case GetSomething() is executed on each iteration of the IEnumerable, in the second case it is only executed when the MyProperty accessor is called.