also fixed dbSet.ToListAsync and variants

Author: koenbeuk

src/ExpressiveSharp.EntityFrameworkCore/ExpressiveDbSet.cs

@@ -17,7 +17,9 @@ public class ExpressiveDbSet<TEntity> : DbSet<TEntity>, IExpressiveQueryable<TEn
     private readonly DbSet<TEntity> _inner;
     private readonly IQueryable<TEntity> _queryable;
 
-    public ExpressiveDbSet(DbSet<TEntity> inner)
+    // Constructed only via AsExpressiveDbSet() (through InternalExpressiveDbSet) so every
+    // instance is the async-capable runtime subclass. See InternalExpressiveDbSet.
+    private protected ExpressiveDbSet(DbSet<TEntity> inner)
     {
         _inner = inner;
         _queryable = inner;

src/ExpressiveSharp.EntityFrameworkCore/Extensions/DbSetExtensions.cs

@@ -1,4 +1,5 @@
 using ExpressiveSharp.EntityFrameworkCore;
+using ExpressiveSharp.EntityFrameworkCore.Infrastructure.Internal;
 
 // ReSharper disable once CheckNamespace — intentionally in Microsoft.EntityFrameworkCore for discoverability
 namespace Microsoft.EntityFrameworkCore;
@@ -7,5 +8,5 @@ public static class DbSetExtensions
 {
     public static ExpressiveDbSet<TEntity> AsExpressiveDbSet<TEntity>(this DbSet<TEntity> dbSet)
         where TEntity : class
-        => new(dbSet);
+        => new InternalExpressiveDbSet<TEntity>(dbSet);
 }

src/ExpressiveSharp.EntityFrameworkCore/Infrastructure/Internal/InternalExpressiveDbSet.cs

@@ -0,0 +1,25 @@
+using Microsoft.EntityFrameworkCore;
+
+namespace ExpressiveSharp.EntityFrameworkCore.Infrastructure.Internal;
+
+/// <summary>
+/// The concrete runtime instance produced by <c>AsExpressiveDbSet()</c>. It implements
+/// <see cref="IAsyncEnumerable{T}"/> — satisfied by the inherited
+/// <see cref="ExpressiveDbSet{TEntity}.GetAsyncEnumerator"/> — so EF Core's streaming async
+/// terminals (<c>ToListAsync</c>/<c>ToArrayAsync</c>/...), which runtime-cast the source to
+/// <see cref="IAsyncEnumerable{T}"/>, work directly on the set.
+/// <para>
+/// The interface lives here rather than on the public <see cref="ExpressiveDbSet{TEntity}"/> so
+/// callers never hold a static type that is both <see cref="IQueryable{T}"/> and
+/// <see cref="IAsyncEnumerable{T}"/> — which on .NET 10 makes those terminals ambiguous between
+/// <c>System.Linq.AsyncEnumerable</c> and EF Core's extensions. This mirrors EF Core's own
+/// public <c>DbSet&lt;T&gt;</c> / internal <c>InternalDbSet&lt;T&gt;</c> split.
+/// </para>
+/// </summary>
+internal sealed class InternalExpressiveDbSet<TEntity> : ExpressiveDbSet<TEntity>, IAsyncEnumerable<TEntity>
+    where TEntity : class
+{
+    public InternalExpressiveDbSet(DbSet<TEntity> inner) : base(inner)
+    {
+    }
+}

tests/ExpressiveSharp.EntityFrameworkCore.IntegrationTests/Infrastructure/AsyncQueryableTestBase.cs

@@ -121,6 +121,24 @@ public async Task Include_Where_ToListAsync_LoadsNavigation()
         Assert.IsTrue(results.All(o => o.Customer != null));
     }
 
+    [TestMethod]
+    public async Task ExpressiveDbSet_ToListAsync_DirectTerminal_Executes()
+    {
+        // Streaming terminal directly on the ExpressiveDbSet (no intervening operator to
+        // re-wrap it). ToListAsync casts the source to IAsyncEnumerable<T>.
+        var results = await Context.ExpressiveOrders.ToListAsync();
+
+        Assert.AreEqual(4, results.Count);
+    }
+
+    [TestMethod]
+    public async Task ExpressiveDbSet_ToArrayAsync_DirectTerminal_Executes()
+    {
+        var results = await Context.ExpressiveOrders.ToArrayAsync();
+
+        Assert.AreEqual(4, results.Length);
+    }
+
     [TestMethod]
     public async Task Include_ToListAsync_DirectTerminal_LoadsNavigation()
     {