A way to autogenerate struct enumerators

[AderitoSilva]

A recurrent pain point I often find when implementing collections is with writing struct enumerators for them.

When implementing a collection's GetEnumerator() method, I return a custom enumerator implemented as a struct, similarly to List<T>.Enumerator. This benefits me with an allocationless enumerator, but at the cost of me having to write more code and more unit tests. Most of that code is boilerplate, thus I often find myself thinking "If this could be automated somehow...". That's why I opened this discussion.

Honestly, this is more to raise the idea in the air, so it can be evolved, than a concrete idea by itself. Because I'm not fully aware of every technical constraint each solution could introduce, I'm unable to give you an ellaborate idea.

Ideally, I wish I could just have a way of using the yield keyword in the GetEnumerator() method, and maybe mark the method with some attribute or return some special type, and then have a struct enumerator generated for me automatically. But I'm not sure if this would be feasible or have some drawbacks, given the nature of structs.

I also have no idea how common this pain point is for other devs. To me, it is a bit of an annoyance, given that I frequently need to write custom collections specialized to my domains, and I really want to get the benefit of struct based enumerators, specially in heavy-use enumerators.

Finally, I'm also not 100% sure if this is already possible and if I just missed some .NET news at some point. If it is, I'm probably sounding somewhat dumb.

And, I hope this is the right repo to post this in, as there are several .NET related repos. Please forgive me if it is not.

Anyway, I'm happy to share with you this little thing that I wish could be improved.

[huoyaoyuan]

Starting from recent versions, struct enumerators are less impactful. Given the following example:

        public static int Sum(MyClass c)
        {
            int sum = 0;
            foreach (int i in c)
                sum += i;
            return sum;
        }

    public sealed class MyClass(int[] arr) : IEnumerable<int>
    {
        IEnumerator IEnumerable.GetEnumerator() => GetEnumerator();

        public IEnumerator<int> GetEnumerator() => new Enumerator(arr);

        public sealed class Enumerator(int[] arr) : IEnumerator<int>
        {
            private int index = -1;

            public int Current => arr[index];

            object IEnumerator.Current => Current;

            public bool MoveNext() => ++index < arr.Length;

            public void Reset() => index = -1;

            public void Dispose() { }
        }
    }

For such simple case, since the classes are sealed, escape analysis can successfully cancel the allocation of Enumerator:

; Method CSPlayground.Program:Sum(CSPlayground.MyClass):int (FullOpts)
G_M000_IG01:                ;; offset=0x0000
       push     rbp
       sub      rsp, 32
       lea      rbp, [rsp+0x20]

G_M000_IG02:                ;; offset=0x000A
       xor      eax, eax
       mov      rcx, gword ptr [rcx+0x08]
       mov      edx, 0xFFFFFFFF
       mov      r8d, dword ptr [rcx+0x08]
       jmp      SHORT G_M000_IG04
       align    [5 bytes for IG03]

G_M000_IG03:                ;; offset=0x0020
       cmp      edx, r8d
       jae      SHORT G_M000_IG06
       add      eax, dword ptr [rcx+4*rdx+0x10]

G_M000_IG04:                ;; offset=0x0029
       inc      edx
       cmp      r8d, edx
       jg       SHORT G_M000_IG03

G_M000_IG05:                ;; offset=0x0030
       add      rsp, 32
       pop      rbp
       ret      

G_M000_IG06:                ;; offset=0x0036
       call     CORINFO_HELP_RNGCHKFAIL
       int3     
; Total bytes of code: 60

However, for yield return case the allocation is not canceled.

---

Ideally, I wish I could just have a way of using the yield keyword in the GetEnumerator() method, and maybe mark the method with some attribute or return some special type, and then have a struct enumerator generated for me automatically.

This would require quite different behaviour. struct enumerators are required to be present in public signature (List<T>.Enumerator is public), while yield return generates a private type and return it as IEnumerator<T> interface. I recall some discussions about this, but can't find it.

[AderitoSilva]

I wasn't aware of that behavior with sealed classes; that is really nice to know, and I will want to dig deeper into that when I find some time. Still, in that case I would still be writing the enumerator class manually, which is what I would like to avoid.

I wonder if it would be already feasible to generate a public enumerator struct using convention-based code generators for methods containing yield keywords, without requiring changes in the compiler itself. That is sort of what was on my mind when I mentioned decorating the method with a specific attribute.

[huoyaoyuan]

I wonder if it would be already feasible to generate a public enumerator struct using convention-based code generators for methods containing yield keywords, without requiring changes in the compiler itself.

This wouldn't be really practical. The code can only be written in the original yield form, and the source generator has to generate whatever the compiler generates for the yield state machine and change class to struct. It also has to learn any language feature involved.

[BlinD-HuNTeR]

Please take a look at this post from the csharplang repository. There is a NuGet package that does exactly what you want!

After installing the package, the syntax to use the feature is very simple: You just need to declare a struct, that implements IEnumerator<T>, and contains a static iterator method, whose return type is the struct itself:

public struct MyIterator : IEnumerator<int>
{
    public static MyIterator Create()
    {
        yield return 1;
        yield return 2;
        yield return 3;
    }
}

More details can be found in the post I mentioned. When compiling your code with that package installed, the compiler-generated state machine will be changed to a struct, and it will also generate the IEnumerator<T> members on your type, delegating to the internal state machine.

[AderitoSilva]

That discussion is very interesting, and it exactly covers my pain point.

That package actually seems like a great approach! I will gonna try it! Thank you for doing that! Are there any limitations to how the yield keyword can be used inside the static method I should keep an eye on?

[BlinD-HuNTeR]

There are no limitations to the usage of yield. The only limitations are in the declaration of the struct and its method:

• The struct must contain no members, other than the static iterator method. It must also be non-partial.
• The static iterator method can have any name, but it cannot be generic (the containing struct can be generic).
• The static iterator method may have parameters, except ref parameters and byref-like types. This is already a limitation of the language for iterators. (In theory, if you declared the struct as a ref struct, it should be possible to take byref-like parameters, but I haven't added support for that yet.)