diff --git a/src/EFCore/EntityFrameworkEnumerableExtensions.cs b/src/EFCore/EntityFrameworkEnumerableExtensions.cs
deleted file mode 100644
index 574dcfee82c..00000000000
--- a/src/EFCore/EntityFrameworkEnumerableExtensions.cs
+++ /dev/null
@@ -1,440 +0,0 @@
-// Copyright (c) .NET Foundation. All rights reserved.
-// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
-
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Threading;
-using System.Threading.Tasks;
-using JetBrains.Annotations;
-using Microsoft.EntityFrameworkCore.Extensions.Internal;
-using Microsoft.EntityFrameworkCore.Utilities;
-
-// ReSharper disable once CheckNamespace
-namespace Microsoft.EntityFrameworkCore
-{
-    public static class EntityFrameworkEnumerableExtensions
-    {
-        #region ToList/Array
-
-        /// <summary>
-        ///     Asynchronously creates a <see cref="List{T}" /> from an <see cref="IAsyncEnumerable{T}" /> by enumerating it
-        ///     asynchronously.
-        /// </summary>
-        /// <remarks>
-        ///     Multiple active operations on the same context instance are not supported.  Use 'await' to ensure
-        ///     that any asynchronous operations have completed before calling another method on this context.
-        /// </remarks>
-        /// <typeparam name="TSource">
-        ///     The type of the elements of <paramref name="source" />.
-        /// </typeparam>
-        /// <param name="source">
-        ///     An <see cref="IAsyncEnumerable{T}" /> to create a list from.
-        /// </param>
-        /// <param name="cancellationToken">
-        ///     A <see cref="CancellationToken" /> to observe while waiting for the task to complete.
-        /// </param>
-        /// <returns>
-        ///     A task that represents the asynchronous operation.
-        ///     The task result contains a <see cref="List{T}" /> that contains elements from the input sequence.
-        /// </returns>
-        public static async Task<List<TSource>> ToListAsync<TSource>(
-            [NotNull] this IAsyncEnumerable<TSource> source,
-            CancellationToken cancellationToken = default)
-        {
-            var list = new List<TSource>();
-            await foreach (var element in source.WithCancellation(cancellationToken))
-            {
-                list.Add(element);
-            }
-
-            return list;
-        }
-
-        /// <summary>
-        ///     Asynchronously creates an array from an <see cref="IAsyncEnumerable{T}" /> by enumerating it asynchronously.
-        /// </summary>
-        /// <remarks>
-        ///     Multiple active operations on the same context instance are not supported.  Use 'await' to ensure
-        ///     that any asynchronous operations have completed before calling another method on this context.
-        /// </remarks>
-        /// <typeparam name="TSource">
-        ///     The type of the elements of <paramref name="source" />.
-        /// </typeparam>
-        /// <param name="source">
-        ///     An <see cref="IAsyncEnumerable{T}" /> to create an array from.
-        /// </param>
-        /// <param name="cancellationToken">
-        ///     A <see cref="CancellationToken" /> to observe while waiting for the task to complete.
-        /// </param>
-        /// <returns>
-        ///     A task that represents the asynchronous operation.
-        ///     The task result contains an array that contains elements from the input sequence.
-        /// </returns>
-        public static async Task<TSource[]> ToArrayAsync<TSource>(
-            [NotNull] this IAsyncEnumerable<TSource> source,
-            CancellationToken cancellationToken = default)
-            => (await source.ToListAsync(cancellationToken)).ToArray();
-
-        #endregion
-
-        #region ToDictionary
-
-        /// <summary>
-        ///     Creates a <see cref="Dictionary{TKey, TValue}" /> from an <see cref="IAsyncEnumerable{T}" /> by enumerating it
-        ///     asynchronously
-        ///     according to a specified key selector function.
-        /// </summary>
-        /// <remarks>
-        ///     Multiple active operations on the same context instance are not supported.  Use 'await' to ensure
-        ///     that any asynchronous operations have completed before calling another method on this context.
-        /// </remarks>
-        /// <typeparam name="TSource">
-        ///     The type of the elements of <paramref name="source" />.
-        /// </typeparam>
-        /// <typeparam name="TKey">
-        ///     The type of the key returned by <paramref name="keySelector" /> .
-        /// </typeparam>
-        /// <param name="source">
-        ///     An <see cref="IAsyncEnumerable{T}" /> to create a <see cref="Dictionary{TKey, TValue}" /> from.
-        /// </param>
-        /// <param name="keySelector"> A function to extract a key from each element. </param>
-        /// <param name="cancellationToken">
-        ///     A <see cref="CancellationToken" /> to observe while waiting for the task to complete.
-        /// </param>
-        /// <returns>
-        ///     A task that represents the asynchronous operation.
-        ///     The task result contains a <see cref="Dictionary{TKey, TSource}" /> that contains selected keys and values.
-        /// </returns>
-        public static Task<Dictionary<TKey, TSource>> ToDictionaryAsync<TSource, TKey>(
-            [NotNull] this IAsyncEnumerable<TSource> source,
-            [NotNull] Func<TSource, TKey> keySelector,
-            CancellationToken cancellationToken = default)
-            => ToDictionaryAsync(source, keySelector, e => e, comparer: null, cancellationToken);
-
-        /// <summary>
-        ///     Creates a <see cref="Dictionary{TKey, TValue}" /> from an <see cref="IAsyncEnumerable{T}" /> by enumerating it
-        ///     asynchronously
-        ///     according to a specified key selector function and a comparer.
-        /// </summary>
-        /// <remarks>
-        ///     Multiple active operations on the same context instance are not supported.  Use 'await' to ensure
-        ///     that any asynchronous operations have completed before calling another method on this context.
-        /// </remarks>
-        /// <typeparam name="TSource">
-        ///     The type of the elements of <paramref name="source" />.
-        /// </typeparam>
-        /// <typeparam name="TKey">
-        ///     The type of the key returned by <paramref name="keySelector" /> .
-        /// </typeparam>
-        /// <param name="source">
-        ///     An <see cref="IAsyncEnumerable{T}" /> to create a <see cref="Dictionary{TKey, TValue}" /> from.
-        /// </param>
-        /// <param name="keySelector"> A function to extract a key from each element. </param>
-        /// <param name="comparer">
-        ///     An <see cref="IEqualityComparer{TKey}" /> to compare keys.
-        /// </param>
-        /// <param name="cancellationToken">
-        ///     A <see cref="CancellationToken" /> to observe while waiting for the task to complete.
-        /// </param>
-        /// <returns>
-        ///     A task that represents the asynchronous operation.
-        ///     The task result contains a <see cref="Dictionary{TKey, TSource}" /> that contains selected keys and values.
-        /// </returns>
-        public static Task<Dictionary<TKey, TSource>> ToDictionaryAsync<TSource, TKey>(
-            [NotNull] this IAsyncEnumerable<TSource> source,
-            [NotNull] Func<TSource, TKey> keySelector,
-            [NotNull] IEqualityComparer<TKey> comparer,
-            CancellationToken cancellationToken = default)
-            => ToDictionaryAsync(source, keySelector, e => e, comparer, cancellationToken);
-
-        /// <summary>
-        ///     Creates a <see cref="Dictionary{TKey, TValue}" /> from an <see cref="IAsyncEnumerable{T}" /> by enumerating it
-        ///     asynchronously
-        ///     according to a specified key selector and an element selector function.
-        /// </summary>
-        /// <remarks>
-        ///     Multiple active operations on the same context instance are not supported.  Use 'await' to ensure
-        ///     that any asynchronous operations have completed before calling another method on this context.
-        /// </remarks>
-        /// <typeparam name="TSource">
-        ///     The type of the elements of <paramref name="source" />.
-        /// </typeparam>
-        /// <typeparam name="TKey">
-        ///     The type of the key returned by <paramref name="keySelector" /> .
-        /// </typeparam>
-        /// <typeparam name="TElement">
-        ///     The type of the value returned by <paramref name="elementSelector" />.
-        /// </typeparam>
-        /// <param name="source">
-        ///     An <see cref="IAsyncEnumerable{T}" /> to create a <see cref="Dictionary{TKey, TValue}" /> from.
-        /// </param>
-        /// <param name="keySelector"> A function to extract a key from each element. </param>
-        /// <param name="elementSelector"> A transform function to produce a result element value from each element. </param>
-        /// <param name="cancellationToken">
-        ///     A <see cref="CancellationToken" /> to observe while waiting for the task to complete.
-        /// </param>
-        /// <returns>
-        ///     A task that represents the asynchronous operation.
-        ///     The task result contains a <see cref="Dictionary{TKey, TElement}" /> that contains values of type
-        ///     <typeparamref name="TElement" /> selected from the input sequence.
-        /// </returns>
-        public static Task<Dictionary<TKey, TElement>> ToDictionaryAsync<TSource, TKey, TElement>(
-            [NotNull] this IAsyncEnumerable<TSource> source,
-            [NotNull] Func<TSource, TKey> keySelector,
-            [NotNull] Func<TSource, TElement> elementSelector,
-            CancellationToken cancellationToken = default)
-            => ToDictionaryAsync(source, keySelector, elementSelector, comparer: null, cancellationToken);
-
-        /// <summary>
-        ///     Creates a <see cref="Dictionary{TKey, TValue}" /> from an <see cref="IAsyncEnumerable{T}" /> by enumerating it
-        ///     asynchronously
-        ///     according to a specified key selector function, a comparer, and an element selector function.
-        /// </summary>
-        /// <remarks>
-        ///     Multiple active operations on the same context instance are not supported.  Use 'await' to ensure
-        ///     that any asynchronous operations have completed before calling another method on this context.
-        /// </remarks>
-        /// <typeparam name="TSource">
-        ///     The type of the elements of <paramref name="source" />.
-        /// </typeparam>
-        /// <typeparam name="TKey">
-        ///     The type of the key returned by <paramref name="keySelector" /> .
-        /// </typeparam>
-        /// <typeparam name="TElement">
-        ///     The type of the value returned by <paramref name="elementSelector" />.
-        /// </typeparam>
-        /// <param name="source">
-        ///     An <see cref="IAsyncEnumerable{T}" /> to create a <see cref="Dictionary{TKey, TValue}" /> from.
-        /// </param>
-        /// <param name="keySelector"> A function to extract a key from each element. </param>
-        /// <param name="elementSelector"> A transform function to produce a result element value from each element. </param>
-        /// <param name="comparer">
-        ///     An <see cref="IEqualityComparer{TKey}" /> to compare keys.
-        /// </param>
-        /// <param name="cancellationToken">
-        ///     A <see cref="CancellationToken" /> to observe while waiting for the task to complete.
-        /// </param>
-        /// <returns>
-        ///     A task that represents the asynchronous operation.
-        ///     The task result contains a <see cref="Dictionary{TKey, TElement}" /> that contains values of type
-        ///     <typeparamref name="TElement" /> selected from the input sequence.
-        /// </returns>
-        public static async Task<Dictionary<TKey, TElement>> ToDictionaryAsync<TSource, TKey, TElement>(
-            [NotNull] this IAsyncEnumerable<TSource> source,
-            [NotNull] Func<TSource, TKey> keySelector,
-            [NotNull] Func<TSource, TElement> elementSelector,
-            [NotNull] IEqualityComparer<TKey> comparer,
-            CancellationToken cancellationToken = default)
-        {
-            Check.NotNull(source, nameof(source));
-            Check.NotNull(keySelector, nameof(keySelector));
-            Check.NotNull(elementSelector, nameof(elementSelector));
-            Check.NotNull(comparer, nameof(comparer));
-
-            var d = new Dictionary<TKey, TElement>(comparer);
-            await foreach (var element in source.WithCancellation(cancellationToken))
-            {
-                d.Add(keySelector(element), elementSelector(element));
-            }
-
-            return d;
-        }
-
-        #endregion
-
-        #region ToLookup
-
-        /// <summary>
-        ///     Creates a <see cref="ILookup{TKey, TValue}" /> from an <see cref="IAsyncEnumerable{T}" /> by enumerating it
-        ///     asynchronously
-        ///     according to a specified key selector function.
-        /// </summary>
-        /// <remarks>
-        ///     Multiple active operations on the same context instance are not supported.  Use 'await' to ensure
-        ///     that any asynchronous operations have completed before calling another method on this context.
-        /// </remarks>
-        /// <typeparam name="TSource">
-        ///     The type of the elements of <paramref name="source" />.
-        /// </typeparam>
-        /// <typeparam name="TKey">
-        ///     The type of the key returned by <paramref name="keySelector" /> .
-        /// </typeparam>
-        /// <param name="source">
-        ///     An <see cref="IAsyncEnumerable{T}" /> to create a <see cref="ILookup{TKey, TValue}" /> from.
-        /// </param>
-        /// <param name="keySelector"> A function to extract a key from each element. </param>
-        /// <param name="cancellationToken">
-        ///     A <see cref="CancellationToken" /> to observe while waiting for the task to complete.
-        /// </param>
-        /// <returns>
-        ///     A task that represents the asynchronous operation.
-        ///     The task result contains a <see cref="ILookup{TKey, TSource}" /> that contains selected keys and values.
-        /// </returns>
-        public static Task<ILookup<TKey, TSource>> ToLookupAsync<TSource, TKey>(
-            [NotNull] this IAsyncEnumerable<TSource> source,
-            [NotNull] Func<TSource, TKey> keySelector,
-            CancellationToken cancellationToken = default)
-            => ToLookupAsync(source, keySelector, e => e, comparer: null, cancellationToken);
-
-        /// <summary>
-        ///     Creates a <see cref="ILookup{TKey, TValue}" /> from an <see cref="IAsyncEnumerable{T}" /> by enumerating it
-        ///     asynchronously
-        ///     according to a specified key selector function and a comparer.
-        /// </summary>
-        /// <remarks>
-        ///     Multiple active operations on the same context instance are not supported.  Use 'await' to ensure
-        ///     that any asynchronous operations have completed before calling another method on this context.
-        /// </remarks>
-        /// <typeparam name="TSource">
-        ///     The type of the elements of <paramref name="source" />.
-        /// </typeparam>
-        /// <typeparam name="TKey">
-        ///     The type of the key returned by <paramref name="keySelector" /> .
-        /// </typeparam>
-        /// <param name="source">
-        ///     An <see cref="IAsyncEnumerable{T}" /> to create a <see cref="ILookup{TKey, TValue}" /> from.
-        /// </param>
-        /// <param name="keySelector"> A function to extract a key from each element. </param>
-        /// <param name="comparer">
-        ///     An <see cref="IEqualityComparer{TKey}" /> to compare keys.
-        /// </param>
-        /// <param name="cancellationToken">
-        ///     A <see cref="CancellationToken" /> to observe while waiting for the task to complete.
-        /// </param>
-        /// <returns>
-        ///     A task that represents the asynchronous operation.
-        ///     The task result contains a <see cref="ILookup{TKey, TSource}" /> that contains selected keys and values.
-        /// </returns>
-        public static Task<ILookup<TKey, TSource>> ToLookupAsync<TSource, TKey>(
-            [NotNull] this IAsyncEnumerable<TSource> source,
-            [NotNull] Func<TSource, TKey> keySelector,
-            [NotNull] IEqualityComparer<TKey> comparer,
-            CancellationToken cancellationToken = default)
-            => ToLookupAsync(source, keySelector, e => e, comparer, cancellationToken);
-
-        /// <summary>
-        ///     Creates a <see cref="ILookup{TKey, TValue}" /> from an <see cref="IAsyncEnumerable{T}" /> by enumerating it
-        ///     asynchronously
-        ///     according to a specified key selector and an element selector function.
-        /// </summary>
-        /// <remarks>
-        ///     Multiple active operations on the same context instance are not supported.  Use 'await' to ensure
-        ///     that any asynchronous operations have completed before calling another method on this context.
-        /// </remarks>
-        /// <typeparam name="TSource">
-        ///     The type of the elements of <paramref name="source" />.
-        /// </typeparam>
-        /// <typeparam name="TKey">
-        ///     The type of the key returned by <paramref name="keySelector" /> .
-        /// </typeparam>
-        /// <typeparam name="TElement">
-        ///     The type of the value returned by <paramref name="elementSelector" />.
-        /// </typeparam>
-        /// <param name="source">
-        ///     An <see cref="IAsyncEnumerable{T}" /> to create a <see cref="ILookup{TKey, TValue}" /> from.
-        /// </param>
-        /// <param name="keySelector"> A function to extract a key from each element. </param>
-        /// <param name="elementSelector"> A transform function to produce a result element value from each element. </param>
-        /// <param name="cancellationToken">
-        ///     A <see cref="CancellationToken" /> to observe while waiting for the task to complete.
-        /// </param>
-        /// <returns>
-        ///     A task that represents the asynchronous operation.
-        ///     The task result contains a <see cref="ILookup{TKey, TElement}" /> that contains values of type
-        ///     <typeparamref name="TElement" /> selected from the input sequence.
-        /// </returns>
-        public static Task<ILookup<TKey, TElement>> ToLookupAsync<TSource, TKey, TElement>(
-            [NotNull] this IAsyncEnumerable<TSource> source,
-            [NotNull] Func<TSource, TKey> keySelector,
-            [NotNull] Func<TSource, TElement> elementSelector,
-            CancellationToken cancellationToken = default)
-            => ToLookupAsync(source, keySelector, elementSelector, comparer: null, cancellationToken);
-
-        /// <summary>
-        ///     Creates a <see cref="ILookup{TKey, TValue}" /> from an <see cref="IAsyncEnumerable{T}" /> by enumerating it
-        ///     asynchronously
-        ///     according to a specified key selector function, a comparer, and an element selector function.
-        /// </summary>
-        /// <remarks>
-        ///     Multiple active operations on the same context instance are not supported.  Use 'await' to ensure
-        ///     that any asynchronous operations have completed before calling another method on this context.
-        /// </remarks>
-        /// <typeparam name="TSource">
-        ///     The type of the elements of <paramref name="source" />.
-        /// </typeparam>
-        /// <typeparam name="TKey">
-        ///     The type of the key returned by <paramref name="keySelector" /> .
-        /// </typeparam>
-        /// <typeparam name="TElement">
-        ///     The type of the value returned by <paramref name="elementSelector" />.
-        /// </typeparam>
-        /// <param name="source">
-        ///     An <see cref="IAsyncEnumerable{T}" /> to create a <see cref="ILookup{TKey, TValue}" /> from.
-        /// </param>
-        /// <param name="keySelector"> A function to extract a key from each element. </param>
-        /// <param name="elementSelector"> A transform function to produce a result element value from each element. </param>
-        /// <param name="comparer">
-        ///     An <see cref="IEqualityComparer{TKey}" /> to compare keys.
-        /// </param>
-        /// <param name="cancellationToken">
-        ///     A <see cref="CancellationToken" /> to observe while waiting for the task to complete.
-        /// </param>
-        /// <returns>
-        ///     A task that represents the asynchronous operation.
-        ///     The task result contains a <see cref="ILookup{TKey, TElement}" /> that contains values of type
-        ///     <typeparamref name="TElement" /> selected from the input sequence.
-        /// </returns>
-        public static Task<ILookup<TKey, TElement>> ToLookupAsync<TSource, TKey, TElement>(
-            [NotNull] this IAsyncEnumerable<TSource> source,
-            [NotNull] Func<TSource, TKey> keySelector,
-            [NotNull] Func<TSource, TElement> elementSelector,
-            [NotNull] IEqualityComparer<TKey> comparer,
-            CancellationToken cancellationToken = default)
-        {
-            Check.NotNull(source, nameof(source));
-            Check.NotNull(keySelector, nameof(keySelector));
-            Check.NotNull(elementSelector, nameof(elementSelector));
-            Check.NotNull(comparer, nameof(comparer));
-
-            throw new NotImplementedException("ToLookupAsync");
-        }
-
-        #endregion
-
-        #region ForEach
-
-        /// <summary>
-        ///     Asynchronously enumerates the query results and performs the specified action on each element.
-        /// </summary>
-        /// <remarks>
-        ///     Multiple active operations on the same context instance are not supported.  Use 'await' to ensure
-        ///     that any asynchronous operations have completed before calling another method on this context.
-        /// </remarks>
-        /// <typeparam name="T">
-        ///     The type of the elements of <paramref name="source" />.
-        /// </typeparam>
-        /// <param name="source">
-        ///     An <see cref="IAsyncEnumerable{T}" /> to enumerate.
-        /// </param>
-        /// <param name="action"> The action to perform on each element. </param>
-        /// <param name="cancellationToken">
-        ///     A <see cref="CancellationToken" /> to observe while waiting for the task to complete.
-        /// </param>
-        /// <returns> A task that represents the asynchronous operation. </returns>
-        public static async Task ForEachAsync<T>(
-            [NotNull] this IAsyncEnumerable<T> source,
-            [NotNull] Action<T> action,
-            CancellationToken cancellationToken = default)
-        {
-            Check.NotNull(action, nameof(action));
-
-            await foreach (var element in source.WithCancellation(cancellationToken))
-            {
-                action(element);
-            }
-        }
-
-        #endregion
-    }
-}
diff --git a/src/EFCore/EntityFrameworkQueryableExtensions.cs b/src/EFCore/EntityFrameworkQueryableExtensions.cs
index 7aba45cc4bd..aa007437677 100644
--- a/src/EFCore/EntityFrameworkQueryableExtensions.cs
+++ b/src/EFCore/EntityFrameworkQueryableExtensions.cs
@@ -2125,10 +2125,18 @@ public static Task<bool> ContainsAsync<TSource>(
         ///     A task that represents the asynchronous operation.
         ///     The task result contains a <see cref="List{T}" /> that contains elements from the input sequence.
         /// </returns>
-        public static Task<List<TSource>> ToListAsync<TSource>(
+        public static async Task<List<TSource>> ToListAsync<TSource>(
             [NotNull] this IQueryable<TSource> source,
             CancellationToken cancellationToken = default)
-            => source.AsAsyncEnumerable().ToListAsync(cancellationToken);
+        {
+            var list = new List<TSource>();
+            await foreach (var element in source.AsAsyncEnumerable().WithCancellation(cancellationToken))
+            {
+                list.Add(element);
+            }
+
+            return list;
+        }
 
         /// <summary>
         ///     Asynchronously creates an array from an <see cref="IQueryable{T}" /> by enumerating it asynchronously.
@@ -2150,10 +2158,10 @@ public static Task<List<TSource>> ToListAsync<TSource>(
         ///     A task that represents the asynchronous operation.
         ///     The task result contains an array that contains elements from the input sequence.
         /// </returns>
-        public static Task<TSource[]> ToArrayAsync<TSource>(
+        public static async Task<TSource[]> ToArrayAsync<TSource>(
             [NotNull] this IQueryable<TSource> source,
             CancellationToken cancellationToken = default)
-            => source.AsAsyncEnumerable().ToArrayAsync(cancellationToken);
+            => (await source.ToListAsync(cancellationToken)).ToArray();
 
         #endregion
 
@@ -2728,12 +2736,7 @@ public static Task<Dictionary<TKey, TSource>> ToDictionaryAsync<TSource, TKey>(
             [NotNull] this IQueryable<TSource> source,
             [NotNull] Func<TSource, TKey> keySelector,
             CancellationToken cancellationToken = default)
-        {
-            Check.NotNull(source, nameof(source));
-            Check.NotNull(keySelector, nameof(keySelector));
-
-            return source.AsAsyncEnumerable().ToDictionaryAsync(keySelector, cancellationToken);
-        }
+            => ToDictionaryAsync(source, keySelector, e => e, comparer: null, cancellationToken);
 
         /// <summary>
         ///     Creates a <see cref="Dictionary{TKey, TValue}" /> from an <see cref="IQueryable{T}" /> by enumerating it
@@ -2769,13 +2772,7 @@ public static Task<Dictionary<TKey, TSource>> ToDictionaryAsync<TSource, TKey>(
             [NotNull] Func<TSource, TKey> keySelector,
             [NotNull] IEqualityComparer<TKey> comparer,
             CancellationToken cancellationToken = default)
-        {
-            Check.NotNull(source, nameof(source));
-            Check.NotNull(keySelector, nameof(keySelector));
-            Check.NotNull(comparer, nameof(comparer));
-
-            return source.AsAsyncEnumerable().ToDictionaryAsync(keySelector, comparer, cancellationToken);
-        }
+            => ToDictionaryAsync(source, keySelector, e => e, comparer, cancellationToken);
 
         /// <summary>
         ///     Creates a <see cref="Dictionary{TKey, TValue}" /> from an <see cref="IQueryable{T}" /> by enumerating it
@@ -2813,13 +2810,7 @@ public static Task<Dictionary<TKey, TElement>> ToDictionaryAsync<TSource, TKey,
             [NotNull] Func<TSource, TKey> keySelector,
             [NotNull] Func<TSource, TElement> elementSelector,
             CancellationToken cancellationToken = default)
-        {
-            Check.NotNull(source, nameof(source));
-            Check.NotNull(keySelector, nameof(keySelector));
-            Check.NotNull(elementSelector, nameof(elementSelector));
-
-            return source.AsAsyncEnumerable().ToDictionaryAsync(keySelector, elementSelector, cancellationToken);
-        }
+            => ToDictionaryAsync(source, keySelector, elementSelector, comparer: null, cancellationToken);
 
         /// <summary>
         ///     Creates a <see cref="Dictionary{TKey, TValue}" /> from an <see cref="IQueryable{T}" /> by enumerating it
@@ -2855,7 +2846,7 @@ public static Task<Dictionary<TKey, TElement>> ToDictionaryAsync<TSource, TKey,
         ///     The task result contains a <see cref="Dictionary{TKey, TElement}" /> that contains values of type
         ///     <typeparamref name="TElement" /> selected from the input sequence.
         /// </returns>
-        public static Task<Dictionary<TKey, TElement>> ToDictionaryAsync<TSource, TKey, TElement>(
+        public static async Task<Dictionary<TKey, TElement>> ToDictionaryAsync<TSource, TKey, TElement>(
             [NotNull] this IQueryable<TSource> source,
             [NotNull] Func<TSource, TKey> keySelector,
             [NotNull] Func<TSource, TElement> elementSelector,
@@ -2865,185 +2856,14 @@ public static Task<Dictionary<TKey, TElement>> ToDictionaryAsync<TSource, TKey,
             Check.NotNull(source, nameof(source));
             Check.NotNull(keySelector, nameof(keySelector));
             Check.NotNull(elementSelector, nameof(elementSelector));
-            Check.NotNull(comparer, nameof(comparer));
-
-            return source.AsAsyncEnumerable().ToDictionaryAsync(keySelector, elementSelector, comparer, cancellationToken);
-        }
-
-        #endregion
 
-        #region ToLookup
-
-        /// <summary>
-        ///     Creates a <see cref="ILookup{TKey, TValue}" /> from an <see cref="IQueryable{T}" /> by enumerating it
-        ///     asynchronously
-        ///     according to a specified key selector function.
-        /// </summary>
-        /// <remarks>
-        ///     Multiple active operations on the same context instance are not supported.  Use 'await' to ensure
-        ///     that any asynchronous operations have completed before calling another method on this context.
-        /// </remarks>
-        /// <typeparam name="TSource">
-        ///     The type of the elements of <paramref name="source" />.
-        /// </typeparam>
-        /// <typeparam name="TKey">
-        ///     The type of the key returned by <paramref name="keySelector" /> .
-        /// </typeparam>
-        /// <param name="source">
-        ///     An <see cref="IQueryable{T}" /> to create a <see cref="ILookup{TKey, TValue}" /> from.
-        /// </param>
-        /// <param name="keySelector"> A function to extract a key from each element. </param>
-        /// <param name="cancellationToken">
-        ///     A <see cref="CancellationToken" /> to observe while waiting for the task to complete.
-        /// </param>
-        /// <returns>
-        ///     A task that represents the asynchronous operation.
-        ///     The task result contains a <see cref="ILookup{TKey, TSource}" /> that contains selected keys and values.
-        /// </returns>
-        public static Task<ILookup<TKey, TSource>> ToLookupAsync<TSource, TKey>(
-            [NotNull] this IQueryable<TSource> source,
-            [NotNull] Func<TSource, TKey> keySelector,
-            CancellationToken cancellationToken = default)
-        {
-            Check.NotNull(source, nameof(source));
-            Check.NotNull(keySelector, nameof(keySelector));
-
-            return source.AsAsyncEnumerable().ToLookupAsync(keySelector, cancellationToken);
-        }
-
-        /// <summary>
-        ///     Creates a <see cref="ILookup{TKey, TValue}" /> from an <see cref="IQueryable{T}" /> by enumerating it
-        ///     asynchronously
-        ///     according to a specified key selector function and a comparer.
-        /// </summary>
-        /// <remarks>
-        ///     Multiple active operations on the same context instance are not supported.  Use 'await' to ensure
-        ///     that any asynchronous operations have completed before calling another method on this context.
-        /// </remarks>
-        /// <typeparam name="TSource">
-        ///     The type of the elements of <paramref name="source" />.
-        /// </typeparam>
-        /// <typeparam name="TKey">
-        ///     The type of the key returned by <paramref name="keySelector" /> .
-        /// </typeparam>
-        /// <param name="source">
-        ///     An <see cref="IQueryable{T}" /> to create a <see cref="ILookup{TKey, TValue}" /> from.
-        /// </param>
-        /// <param name="keySelector"> A function to extract a key from each element. </param>
-        /// <param name="comparer">
-        ///     An <see cref="IEqualityComparer{TKey}" /> to compare keys.
-        /// </param>
-        /// <param name="cancellationToken">
-        ///     A <see cref="CancellationToken" /> to observe while waiting for the task to complete.
-        /// </param>
-        /// <returns>
-        ///     A task that represents the asynchronous operation.
-        ///     The task result contains a <see cref="ILookup{TKey, TSource}" /> that contains selected keys and values.
-        /// </returns>
-        public static Task<ILookup<TKey, TSource>> ToLookupAsync<TSource, TKey>(
-            [NotNull] this IQueryable<TSource> source,
-            [NotNull] Func<TSource, TKey> keySelector,
-            [NotNull] IEqualityComparer<TKey> comparer,
-            CancellationToken cancellationToken = default)
-        {
-            Check.NotNull(source, nameof(source));
-            Check.NotNull(keySelector, nameof(keySelector));
-            Check.NotNull(comparer, nameof(comparer));
-
-            return source.AsAsyncEnumerable().ToLookupAsync(keySelector, comparer, cancellationToken);
-        }
-
-        /// <summary>
-        ///     Creates a <see cref="ILookup{TKey, TValue}" /> from an <see cref="IQueryable{T}" /> by enumerating it
-        ///     asynchronously
-        ///     according to a specified key selector and an element selector function.
-        /// </summary>
-        /// <remarks>
-        ///     Multiple active operations on the same context instance are not supported.  Use 'await' to ensure
-        ///     that any asynchronous operations have completed before calling another method on this context.
-        /// </remarks>
-        /// <typeparam name="TSource">
-        ///     The type of the elements of <paramref name="source" />.
-        /// </typeparam>
-        /// <typeparam name="TKey">
-        ///     The type of the key returned by <paramref name="keySelector" /> .
-        /// </typeparam>
-        /// <typeparam name="TElement">
-        ///     The type of the value returned by <paramref name="elementSelector" />.
-        /// </typeparam>
-        /// <param name="source">
-        ///     An <see cref="IQueryable{T}" /> to create a <see cref="ILookup{TKey, TValue}" /> from.
-        /// </param>
-        /// <param name="keySelector"> A function to extract a key from each element. </param>
-        /// <param name="elementSelector"> A transform function to produce a result element value from each element. </param>
-        /// <param name="cancellationToken">
-        ///     A <see cref="CancellationToken" /> to observe while waiting for the task to complete.
-        /// </param>
-        /// <returns>
-        ///     A task that represents the asynchronous operation.
-        ///     The task result contains a <see cref="ILookup{TKey, TElement}" /> that contains values of type
-        ///     <typeparamref name="TElement" /> selected from the input sequence.
-        /// </returns>
-        public static Task<ILookup<TKey, TElement>> ToLookupAsync<TSource, TKey, TElement>(
-            [NotNull] this IQueryable<TSource> source,
-            [NotNull] Func<TSource, TKey> keySelector,
-            [NotNull] Func<TSource, TElement> elementSelector,
-            CancellationToken cancellationToken = default)
-        {
-            Check.NotNull(source, nameof(source));
-            Check.NotNull(keySelector, nameof(keySelector));
-            Check.NotNull(elementSelector, nameof(elementSelector));
-
-            return source.AsAsyncEnumerable().ToLookupAsync(keySelector, elementSelector, cancellationToken);
-        }
-
-        /// <summary>
-        ///     Creates a <see cref="ILookup{TKey, TValue}" /> from an <see cref="IQueryable{T}" /> by enumerating it
-        ///     asynchronously
-        ///     according to a specified key selector function, a comparer, and an element selector function.
-        /// </summary>
-        /// <remarks>
-        ///     Multiple active operations on the same context instance are not supported.  Use 'await' to ensure
-        ///     that any asynchronous operations have completed before calling another method on this context.
-        /// </remarks>
-        /// <typeparam name="TSource">
-        ///     The type of the elements of <paramref name="source" />.
-        /// </typeparam>
-        /// <typeparam name="TKey">
-        ///     The type of the key returned by <paramref name="keySelector" /> .
-        /// </typeparam>
-        /// <typeparam name="TElement">
-        ///     The type of the value returned by <paramref name="elementSelector" />.
-        /// </typeparam>
-        /// <param name="source">
-        ///     An <see cref="IQueryable{T}" /> to create a <see cref="ILookup{TKey, TValue}" /> from.
-        /// </param>
-        /// <param name="keySelector"> A function to extract a key from each element. </param>
-        /// <param name="elementSelector"> A transform function to produce a result element value from each element. </param>
-        /// <param name="comparer">
-        ///     An <see cref="IEqualityComparer{TKey}" /> to compare keys.
-        /// </param>
-        /// <param name="cancellationToken">
-        ///     A <see cref="CancellationToken" /> to observe while waiting for the task to complete.
-        /// </param>
-        /// <returns>
-        ///     A task that represents the asynchronous operation.
-        ///     The task result contains a <see cref="ILookup{TKey, TElement}" /> that contains values of type
-        ///     <typeparamref name="TElement" /> selected from the input sequence.
-        /// </returns>
-        public static Task<ILookup<TKey, TElement>> ToLookupAsync<TSource, TKey, TElement>(
-            [NotNull] this IQueryable<TSource> source,
-            [NotNull] Func<TSource, TKey> keySelector,
-            [NotNull] Func<TSource, TElement> elementSelector,
-            [NotNull] IEqualityComparer<TKey> comparer,
-            CancellationToken cancellationToken = default)
-        {
-            Check.NotNull(source, nameof(source));
-            Check.NotNull(keySelector, nameof(keySelector));
-            Check.NotNull(elementSelector, nameof(elementSelector));
-            Check.NotNull(comparer, nameof(comparer));
+            var d = new Dictionary<TKey, TElement>(comparer);
+            await foreach (var element in source.AsAsyncEnumerable().WithCancellation(cancellationToken))
+            {
+                d.Add(keySelector(element), elementSelector(element));
+            }
 
-            return source.AsAsyncEnumerable().ToLookupAsync(keySelector, elementSelector, comparer, cancellationToken);
+            return d;
         }
 
         #endregion
@@ -3068,11 +2888,18 @@ public static Task<ILookup<TKey, TElement>> ToLookupAsync<TSource, TKey, TElemen
         ///     A <see cref="CancellationToken" /> to observe while waiting for the task to complete.
         /// </param>
         /// <returns> A task that represents the asynchronous operation. </returns>
-        public static Task ForEachAsync<T>(
+        public static async Task ForEachAsync<T>(
             [NotNull] this IQueryable<T> source,
             [NotNull] Action<T> action,
             CancellationToken cancellationToken = default)
-            => source.AsAsyncEnumerable().ForEachAsync(action, cancellationToken);
+        {
+            Check.NotNull(action, nameof(action));
+
+            await foreach (var element in source.AsAsyncEnumerable().WithCancellation(cancellationToken))
+            {
+                action(element);
+            }
+        }
 
         #endregion
 
diff --git a/src/EFCore/Query/Internal/QueryCompiler.cs b/src/EFCore/Query/Internal/QueryCompiler.cs
index 7c717864fa0..71402a6ad49 100644
--- a/src/EFCore/Query/Internal/QueryCompiler.cs
+++ b/src/EFCore/Query/Internal/QueryCompiler.cs
@@ -105,7 +105,7 @@ public virtual Func<QueryContext, TResult> CompileQueryCore<TResult>(
             IModel model,
             bool async)
         {
-            return database.CompileQuery2<TResult>(query, async);
+            return database.CompileQuery<TResult>(query, async);
         }
 
         /// <summary>
diff --git a/src/EFCore/Storage/Database.cs b/src/EFCore/Storage/Database.cs
index 42af355f022..753397d9bb9 100644
--- a/src/EFCore/Storage/Database.cs
+++ b/src/EFCore/Storage/Database.cs
@@ -67,7 +67,7 @@ public abstract Task<int> SaveChangesAsync(
             IList<IUpdateEntry> entries,
             CancellationToken cancellationToken = default);
 
-        public virtual Func<QueryContext, TResult> CompileQuery2<TResult>(Expression query, bool async)
+        public virtual Func<QueryContext, TResult> CompileQuery<TResult>(Expression query, bool async)
         {
             return Dependencies.QueryCompilationContextFactory
                 .Create(async)
diff --git a/src/EFCore/Storage/IDatabase.cs b/src/EFCore/Storage/IDatabase.cs
index 62518de7c16..eb5727c3385 100644
--- a/src/EFCore/Storage/IDatabase.cs
+++ b/src/EFCore/Storage/IDatabase.cs
@@ -50,6 +50,6 @@ Task<int> SaveChangesAsync(
             [NotNull] IList<IUpdateEntry> entries,
             CancellationToken cancellationToken = default);
 
-        Func<QueryContext, TResult> CompileQuery2<TResult>([NotNull] Expression query, bool async);
+        Func<QueryContext, TResult> CompileQuery<TResult>([NotNull] Expression query, bool async);
     }
 }
diff --git a/test/EFCore.Specification.Tests/Query/GearsOfWarQueryTestBase.cs b/test/EFCore.Specification.Tests/Query/GearsOfWarQueryTestBase.cs
index 1546e65a3f5..e93957540c5 100644
--- a/test/EFCore.Specification.Tests/Query/GearsOfWarQueryTestBase.cs
+++ b/test/EFCore.Specification.Tests/Query/GearsOfWarQueryTestBase.cs
@@ -698,11 +698,6 @@ await AssertQuery<Gear>(
             await AssertQuery<Gear>(
                 isAsync,
                 gs => gs.Where(g => ((short)g.Rank & (short)1) == 1));
-
-            // Issue#15950
-            //await AssertQuery<Gear>(
-            //    isAsync,
-            //    gs => gs.Where(g => ((char)g.Rank & '\x0001') == '\x0001'));
         }
 
         [ConditionalTheory]
diff --git a/test/EFCore.Specification.Tests/TestUtilities/QueryableExtensions.cs b/test/EFCore.Specification.Tests/TestUtilities/QueryableExtensions.cs
index dd5446f7348..2194486dfee 100644
--- a/test/EFCore.Specification.Tests/TestUtilities/QueryableExtensions.cs
+++ b/test/EFCore.Specification.Tests/TestUtilities/QueryableExtensions.cs
@@ -18,5 +18,16 @@ public static Task<List<TSource>> ToListAsync<TSource>(this IQueryable source, C
         {
             return ((IQueryable<TSource>)source).ToListAsync(cancellationToken);
         }
+
+        public static async Task<List<TSource>> ToListAsync<TSource>(this IAsyncEnumerable<TSource> source, CancellationToken cancellationToken = default)
+        {
+            var list = new List<TSource>();
+            await foreach (var element in source.WithCancellation(cancellationToken))
+            {
+                list.Add(element);
+            }
+
+            return list;
+        }
     }
 }
diff --git a/test/EFCore.Tests/Extensions/QueryableExtensionsTest.cs b/test/EFCore.Tests/Extensions/QueryableExtensionsTest.cs
index 0b6fb4bca6e..c480f8819b3 100644
--- a/test/EFCore.Tests/Extensions/QueryableExtensionsTest.cs
+++ b/test/EFCore.Tests/Extensions/QueryableExtensionsTest.cs
@@ -305,13 +305,6 @@ public async Task Extension_methods_throw_on_non_async_source()
             await SourceNonAsyncEnumerableTest<int>(() => Source().ToDictionaryAsync(e => e, e => e, ReferenceEqualityComparer.Instance));
             await SourceNonAsyncEnumerableTest<int>(
                 () => Source().ToDictionaryAsync(e => e, e => e, ReferenceEqualityComparer.Instance, new CancellationToken()));
-            await SourceNonAsyncEnumerableTest<int>(() => Source().ToLookupAsync(e => e));
-            await SourceNonAsyncEnumerableTest<int>(() => Source().ToLookupAsync(e => e, e => e));
-            await SourceNonAsyncEnumerableTest<int>(() => Source().ToLookupAsync(e => e, ReferenceEqualityComparer.Instance));
-            await SourceNonAsyncEnumerableTest<int>(() => Source().ToLookupAsync(e => e, ReferenceEqualityComparer.Instance));
-            await SourceNonAsyncEnumerableTest<int>(() => Source().ToLookupAsync(e => e, e => e, ReferenceEqualityComparer.Instance));
-            await SourceNonAsyncEnumerableTest<int>(
-                () => Source().ToLookupAsync(e => e, e => e, ReferenceEqualityComparer.Instance, new CancellationToken()));
             await SourceNonAsyncEnumerableTest<int>(() => Source().ToListAsync());
 
             Assert.Equal(