Guidance for returning synchronous IEnumerable<T> as IAsyncEnumerable<T> to satisfy interface specification

[DL444]

Imagine an interface with a method for streaming data items. Typically, the items are fetched from the network so IAsyncEnumerable<T> makes sense. But let's say I also have an in-memory implementation for the interface for local testing, which internally consumes synchronous IEnumerable<T>. In this case I still have to return IAsyncEnumerable<T> to satisfy interface constraints. Something similar to this:

public interface IDataSource
{
    IAsyncEnumerable<Foo> GetFoosAsync();
}

internal sealed class LocalTestDataSource : IDataSource
{
    public IAsyncEnumerable<Foo> GetFoosAsync()
    {
        throw new NotImplementedException();
    }

    private readonly IEnumerable<Foo> foos = Enumerable.Range(0, 100).Select(x => new Foo(x));
}

I can't seem to find an API that allows me to wrap the synchronous enumerable as an asynchronous one. I guess this is intentional because it can create a "sync-over-async" pit of failure. However, in this case it is not relevant because the code is not actually performing any I/O.

Yielding without actually awaiting works, but the resulting code generates CS1998.

// CS1998: This async method lacks 'await' operators and will run synchronously.
public async IAsyncEnumerable<Foo> GetFoosAsync()
{
    foreach (Foo foo in foos)
    {
        yield return foo;
    }
}

What is the recommended course of action in this situation? Some I have considered:

• Go with the code above and silence the warning.
• Depend on System.Linq.Async and use its ToAsyncEnumerable<T>(), which seems a bit overkill.
• Implement custom wrapper that does the job.

[RichardD2]

One option would be to write an explicit async enumerator to wrap the non-async enumerator (option 3 in your list):

public static class AsyncEnumerable
{
    private sealed class AsAsyncEnumeratorWrapper<T>(IEnumerator<T> enumerator) : IAsyncEnumerator<T>
    {
        private readonly IEnumerator<T> _enumerator = enumerator;

        public ValueTask DisposeAsync()
        {
            _enumerator.Dispose();
            return default;
        }

        public ValueTask<bool> MoveNextAsync()
        {
            bool result = _enumerator.MoveNext();
            return new(result);
        }

        public T Current => _enumerator.Current;
    }

    private sealed class AsAsyncEnumerableWrapper<T>(IEnumerable<T> enumerable) : IAsyncEnumerable<T>
    {
        private readonly IEnumerable<T> _enumerable = enumerable;

        public IAsyncEnumerator<T> GetAsyncEnumerator(CancellationToken cancellationToken)
            => new AsAsyncEnumeratorWrapper<T>(_enumerable.GetEnumerator());
    }

    public static IAsyncEnumerable<T> AsAsyncEnumerable<T>(this IEnumerable<T> source)
    {
        ArgumentNullException.ThrowIfNull(source);
        return new AsAsyncEnumerableWrapper<T>(source);
    }
}

Usage:

public IEnumerable<Foo> GetFoos()
{
    foreach (Foo foo in foos)
    {
        yield return foo;
    }
}

public IAsyncEnumerable<Foo> GetFoosAsync() => GetFoos().AsAsyncEnumerable();

[DL444]

I started this discussion to collect alternative solutions, but since none came up so far (like I had imagined), I decided to run a quick benchmark of the two solutions.

Not surprisingly, implementing an explicit synchronous wrapper wins out over just ignoring the warning and let the compiler implement a generic asynchronous state machine. So I'm marking this one as the answer for now.

[MemoryDiagnoser]
[HideColumns("Error", "StdDev", "Median", "RatioSD")]
public class Benchmarks
{
    [GlobalSetup]
    public void Setup() => Random.Shared.NextBytes(bytes);

    [Benchmark]
    public async Task<int> SumBytesImplicitAsync()
    {
        int sum = 0;
        await foreach (byte b in GetBytesImplicitAsync())
        {
            sum += b;
        }
        return sum;
    }

    [Benchmark]
    public async Task<int> SumBytesExplicitAsync()
    {
        int sum = 0;
        await foreach (byte b in GetBytesExplicitAsync())
        {
            sum += b;
        }
        return sum;
    }

#pragma warning disable CS1998 // Async method lacks 'await' operators and will run synchronously
    private async IAsyncEnumerable<byte> GetBytesImplicitAsync()
#pragma warning restore CS1998 // Async method lacks 'await' operators and will run synchronously
    {
        foreach (byte b in bytes)
        {
            yield return b;
        }
    }

    private IAsyncEnumerable<byte> GetBytesExplicitAsync() => new WrappingAsyncEnumerable<byte>(bytes);

    private readonly byte[] bytes = new byte[10240];

    private sealed class WrappingAsyncEnumerable<T>(IEnumerable<T> innerEnumerable) : IAsyncEnumerable<T>
    {
        public IAsyncEnumerator<T> GetAsyncEnumerator(CancellationToken cancellationToken = default)
            => new WrappingAsyncEnumerator<T>(innerEnumerable.GetEnumerator());
    }
    private sealed class WrappingAsyncEnumerator<T>(IEnumerator<T> innerEnumerator) : IAsyncEnumerator<T>
    {
        public T Current => innerEnumerator.Current;

        public ValueTask<bool> MoveNextAsync() => ValueTask.FromResult(innerEnumerator.MoveNext());
        public ValueTask DisposeAsync()
        {
            innerEnumerator.Dispose();
            return ValueTask.CompletedTask;
        }
    }
}

BenchmarkDotNet v0.14.0, macOS Sonoma 14.4.1 (23E224) [Darwin 23.4.0]
Apple M1 Pro, 1 CPU, 10 logical and 10 physical cores
.NET SDK 8.0.401
[Host] : .NET 8.0.8 (8.0.824.36612), Arm64 AOT AdvSIMD
DefaultJob : .NET 8.0.8 (8.0.824.36612), Arm64 RyuJIT AdvSIMD

Method	Mean	Allocated
SumBytesImplicitAsync	150.78 us	168 B
SumBytesExplicitAsync	25.22 us	152 B

[CyrusNajmabadi]

// CS1998: This async method lacks 'await'

In cases like this, I simply ignore that warning. The warning is a notification, to ensure I know what's going on. It's not a blocker.