Enable the use of Collection Expressions in IAsyncEnumerables.

[Foxtrek64]

I was going to create a new API proposal for this but I realized that I'm not exactly sure what the API design would look like, so I'm making this a discussion instead.

Currently, collection expression initializers ([]) are allowed as return types for methods which return an IEnumerable<>. This is not allowed for IAsyncEnumerable<>, despite the types being used very similarly.

namespace System.Collections.Generic;

public sealed class FileService
{
    public IAsyncEnumerable<string> EnumerateLines(string filePath)
    {
        ArgumentException.ThrowIfNullOrWhiteSpace(filePath);

        FileInfo file = new(filePath);

        if (file is { Exists: false } or { Length: 0 })
        {
            return []; // CS9174: Cannot initialize type 'IAsyncEnumerable<string>' with a collection expression because the type is not constructable.
        }

        return EnumerateCore(file);
    }
}

While the error is entirely correct (you cannot construct an instance of an interface), the exact same code works in a synchronous context.

namespace System.Collections.Generic;

public sealed class FileService
{
    public IEnumerable<string> EnumerateLines(string filePath)
    {
        ArgumentException.ThrowIfNullOrWhiteSpace(filePath);

        FileInfo file = new(filePath);

        if (file is { Exists: false } or { Length: 0 })
        {
            return []; // No error!
        }

        return EnumerateCore(file);
    }
}

I would expect that this behavior should work regardless of whether you're using IEnumerable<> or IAsyncEnumerable<> due to their similarities in both behavior and purpose.

Currently, developers are required to return a concrete type. There are currently three options availble to them:

1. If EF Core has been added to the project, Array.Empty<T>().AsAsyncEnumerable() becomes available.
2. If System.Linq.Async has been added to the project, AsyncEnumerable.Empty<T>() becomes available.
3. If neither are added, developers are required to provide their own custom type implements IAsyncEnumerable<> and IAsyncEnumerator<> and return an instance of that type (preferably a reusable static instance).

Edit: It seems there is an upcoming fourth option. C# 10 Preview 1 has added several methods for working with AsyncEnumerable directly to the base LINQ library. This should allow for a solution like option 1, but without additional dependencies.

[stephentoub]

#111715

[Foxtrek64]

Thanks Stephen! This is exactly what I was looking for.