IAsyncEnumerable with (readonly) ref struct

[DemoBytom]

I noticed that IAsyncEnumerable<T> now allows ref structs:

runtime/src/libraries/System.Private.CoreLib/src/System/Collections/Generic/IAsyncEnumerable.cs

Lines 10 to 13 in 29013d8

	public interface IAsyncEnumerable<out T>
	#if NET9_0_OR_GREATER
	where T : allows ref struct
	#endif

So I tried using it with readonly ref struct:

internal readonly ref struct Foo
{
    public Foo(
        ReadOnlySpan<byte> blob)
        => Blob = blob;

    public readonly ReadOnlySpan<byte> Blob;
}

[Fact]
public async Task TestAsyncEnumerable()
{
    var foos = GetFoo();
    await foreach (var foo in foos)
    {
        //do something with foo
    }

    static async IAsyncEnumerable<Foo> GetFoo()
    {
        var bytes = new byte[] { 1, 2, 3, 4 };
        await Task.CompletedTask;

        yield return new Foo(bytes);
    }
}

But that results in an exception when GetFoo() is called:

System.TypeLoadException : A ByRef or ByRef-like type cannot be used as the type for an instance field in a non-ByRef-like type.

So, is it possible to use ref structs in an IAsyncEnumberable, and if not why has the allows ref struct been added to it?

[stephentoub]

I'd expect you to get a compilation error with your code; I just tried it and get error CS9267: Element type of an iterator may not be a ref struct or a type parameter allowing ref structs.

IAsyncEnumerable<T> does allow for ref struct Ts, but that doesn't mean async iterators support them, just that it's possible to construct an implementation of the interface that does, in particular when Current on the enumerator can manufacture the ref struct. The ref struct can't be stored onto a class, so async iterators don't support ref struct Ts... the yielded value is stored on a field on the class.

[huoyaoyuan]

An example is a wrapper like this:

    class Wrapper(IAsyncEnumerable<string> source) : IAsyncEnumerable<ReadOnlySpan<char>>
    {
        public IAsyncEnumerator<ReadOnlySpan<char>> GetAsyncEnumerator(CancellationToken cancellationToken = default)
            => new AsyncEnumerator(source.GetAsyncEnumerator(cancellationToken));

        class AsyncEnumerator(IAsyncEnumerator<string> source) : IAsyncEnumerator<ReadOnlySpan<char>>
        {
            public ValueTask<bool> MoveNextAsync() => source.MoveNextAsync();

            public ReadOnlySpan<char> Current => source.Current.AsSpan().Trim();

            public ValueTask DisposeAsync() => source.DisposeAsync();
        }
    }

[colejohnson66]

I still think if the only usage of the ref struct is in the yield return line (or more generally, doesn’t cross an await), then it would still work. Because then the ref struct isn’t crossing an async/boxing boundary.

[stephentoub]

I still think if the only usage of the ref struct is in the yield return line (or more generally, doesn’t cross an await), then it would still work. Because then the ref struct isn’t crossing an async/boxing boundary.

The caller accesses Current on the enumerator. Where do you think the state it accesses lives?

[colejohnson66]

Ah yes, good point. That would mean the IAsyncEnumerable<T> would need to be a ref struct. My bad.

[DemoBytom]

I'd expect you to get a compilation error with your code; I just tried it and get error CS9267: Element type of an iterator may not be a ref struct or a type parameter allowing ref structs.

For whatever reason I do not get any errors/warnings at compile time, neither in VS nor in cmd. Only the provided exception at runtime.

But thank you for the explanation. I didn't think about the async context being a class and where the yielded values are stored. Makes sense now.