commas for multiple yield returns

[ZacharyPatten]

If we could use commas for multiple yield returns it would save a bit of syntax.

Before (current):

using System.Collections.Generic;

class SomeClass
{
    string A;
    string B;
    string C;
    string D;
    string E;
    string F;
    string G;
    string H;

    public IEnumerable<string> Fields
    {
        get
        {
            yield return A;
            yield return B;
            yield return C;
            yield return D;
            yield return E;
            yield return F;
            yield return G;
            yield return H;
        }
    }
}

After:

using System.Collections.Generic;

class SomeClass
{
    string A;
    string B;
    string C;
    string D;
    string E;
    string F;
    string G;
    string H;

    public IEnumerable<string> Fields => yield return A, B, C, D, E, F, G, H;
}

[jnm2]

How does this compare with the shorter => new[] { A, B, C, D, E, F, G, H }; in terms of performance?

[ZacharyPatten]

📄 Benchmark Source Code (T4 Template) _[Expand]

<#@ template debug="false" hostspecific="false" language="C#" #>
<#@ assembly name="System.Core" #>
<#@ import namespace="System.Linq" #>
<#@ import namespace="System.Text" #>
<#@ import namespace="System.Collections.Generic" #>
<#@ output extension=".cs" #>
using System;
using System.Collections.Generic;
using BenchmarkDotNet.Attributes;

BenchmarkDotNet.Running.BenchmarkRunner.Run<Benchmarks>();

[MemoryDiagnoser]
public class Benchmarks
{
	int temp;

	[GlobalCleanup]
	public void GlobalCleanup()
	{
		Console.WriteLine(temp);
	}

<# int[] generations = { 1, 10, 100, 1000, 10000 }; #>
<# Random random = new Random(7); #>

	#region Fields
<# for (int i = 0; i < generations[generations.Length - 1]; i++) { #>
	int _<#= i #> = <#= random.Next() #>;
<# } #>
	#endregion

<# foreach (int i in generations) { #>

	[Benchmark]
	public void YieldReturn<#= i #>()
	{
		foreach (int i in YieldReturn<#= i #>Method())
		{
			temp = i;
		}
	}

	internal IEnumerable<int> YieldReturn<#= i #>Method()
	{
		#region yield returns
<# for (int j = 0; j < i; j++) { #>
		yield return _<#= j #>;
<# } #>
		#endregion
	}

	[Benchmark]
	public void Array<#= i #>()
	{
		foreach (int i in Array<#= i #>Method())
		{
			temp = i;
		}
	}
	
	internal IEnumerable<int> Array<#= i #>Method() => new int[]
		{
			#region array values
<# for (int j = 0; j < i; j++) { #>
			_<#= j #>,
<# } #>
			#endregion
		};
<# } #>
}

📄 Benchmark Results _[Expand]

BenchmarkDotNet=v0.13.1, OS=Windows 10.0.19042.1165 (20H2/October2020Update)
Intel Core i7-4790K CPU 4.00GHz (Haswell), 1 CPU, 8 logical and 4 physical cores
.NET SDK=6.0.100-preview.7.21379.14
  [Host]     : .NET 5.0.9 (5.0.921.35908), X64 RyuJIT
  DefaultJob : .NET 5.0.9 (5.0.921.35908), X64 RyuJIT

Method	Mean	Error	StdDev	Median	Gen 0	Allocated
YieldReturn1	22.20 ns	0.067 ns	0.059 ns	22.23 ns	0.0095	40 B
Array1	16.29 ns	0.352 ns	0.616 ns	15.93 ns	0.0153	64 B
YieldReturn10	64.46 ns	1.290 ns	1.850 ns	63.68 ns	0.0095	40 B
Array10	55.22 ns	0.269 ns	0.210 ns	55.21 ns	0.0229	96 B
YieldReturn100	476.04 ns	3.847 ns	3.410 ns	476.07 ns	0.0095	40 B
Array100	449.39 ns	7.028 ns	6.574 ns	446.36 ns	0.1087	456 B
YieldReturn1000	11,649.25 ns	47.420 ns	42.037 ns	11,638.46 ns	-	40 B
Array1000	4,744.39 ns	93.707 ns	224.516 ns	4,683.36 ns	0.9689	4,056 B
YieldReturn10000	188,919.99 ns	2,277.845 ns	2,130.697 ns	188,473.02 ns	-	40 B
Array10000	60,141.30 ns	541.715 ns	422.936 ns	60,208.25 ns	9.5215	40,057 B

Benchmark Takeaways:

• yield return ... allocates less memory than new[] { ... }
• yield return ... is faster than new[] { ... } on smaller sizes of data (which is where this syntax would be used)
• yield return ... is slower than new[] { ... }

I haven't looked at the IL yet or dug any deeper than this.
@jnm2

[jnm2]

That's cool! Isn't yield return slower than new[] for every size shown in your benchmark?

[ZacharyPatten]

oof... I misread my own results... was in hurry... will fix comments once back at pc

[Rekkonnect]

To add further to this, it would be nice if there was a way to yield return a collection of elements. For example,

IEnumerable<T> Concat<T>(IEnumerable<T> a, IEnumerable<T> b)
{
    yield return a;
    yield return b;
}

The syntax would obviously have to differ to indicate that a collection is being iterated and each of its elements are being yield returned, instead of the collection being returned as a single element.

Some ideas for that syntax:

• yield return many
• yield return in

[jnm2]

yield return foreach

[znakeeye]

Or let's borrow from Javascript:

yield* x;