Discussion: Allow GetEnumerator method to be implemented via extension methods

[ghord]

In C#, for foreach loop to work on type it requires public GetEnumerator method. I propose to relax this requirement to allow extension methods to implement GetEnumerator. This would be especially usefull for generic types, where you can define extension method only for subset of the type parameters.

Use cases:

public class TupleExtensions
{
    public static IEnumerator<T> GetEnumerator<T>(this ValueTuple<T, T, T, T> tuple) { ... }
    public static IEnumerator<T> GetEnumerator<T>(this ValueTuple<T, T, T> tuple) { ... }
    public static IEnumerator<T> GetEnumerator<T>(this ValueTuple<T, T,> tuple) { ... }
}

foreach(var item in (1, 2, 3, 4))
{
   // item is an int here
}

public class OptionExtensions
{
    public static IEnumerator<T> GetEnumerator<T>(this Option<IEnumerable<T>> option) { ... }
}


var x = Option<int>(3);
foreach(var value in x) // compiler error
{
}

var y = Option<IEnumerable<int>>(new[] { 1, 3, 4 });
foreach(var value in y)
{
    //value is an int here
}

[ghord]

First use case would also benefit from #186 to avoid unnecessary copying.

[svick]

I'm not sure your Option<T> example will work without further changes. If I write y.GetEnumerator(), I get the following error:

CS0411 The type arguments for method 'OptionExtensions.GetEnumerator<T, TValue>(Option<T>)' cannot be inferred from the usage. Try specifying the type arguments explicitly.

[ghord]

@svick You are right, I've updated the use case so that it works without problems

[jnm2]

@alrz's use case from dotnet/roslyn#16159:

static IEnumerable<(T, U)> GetEnumerator<T, U>(
    this (IEnumerable<T> xs, IEnumerable<U> ys) source)
    => source.xs.Zip(source.ys, (x, y) => (x, y));

foreach(var (x, y) in (new int[1], new byte[2])) { }

[CyrusNajmabadi]

I would champion this. Effectively, this is saying "use the pattern based approach for 'foreach' that we use in other places, like Deconstruct, Linq, etc."

'foreach' is already pattern based in that it doesn't expect you to have to actually implement IEnumerable or IEnumerator. But it wasn't extended enough to support extensions. It would be nice to just make this possible.

[Richiban]

This would be wonderful since, currently, certain things are only possible to write with extension methods. The primary example of this is methods available only to specific generic instantiations, such as the tuple example (where (string, string) and (int, int) are enumerable but (string, int) is not).

[Thaina]

@Richiban Even though I think (string, int) would still be iteratable as object

[V0ldek]

Is this issue dead? With the introduction of IAsyncEnumerable in C#8 this becomes even more valuable, as current pattern for await foreach mirrors the pattern of foreach, so it doesn't take into account extension methods. It would be great to be able to turn an external dependency that wasn't modernized to C#8 and cleanly turn it into an IAsyncEnumerable with just an extension method,.

[333fred]

I'm willing to champion this. I'll work on writing up a more complete spec.

[333fred]

I've submitted #3194 as a formal proposal for this.

[333fred]

Cleaning up the discussion: this is still championed in #3194. We just shouldn't have 2 things in the language version planning areas.