Converting .Net Framework 4.7.2 Enumerable Extentions to .NET 6

Question

I'm converting a .NET Framework 4.7.2 project to .NET 6. I'm having trouble figuring out how to convert this properly, or if I should even use it.

The code is from the following post: How to return empty IQueryable in an async repository method

public static class EnumerableExtensions {
    public static IQueryable<T> AsAsyncQueryable<T>(this IEnumerable<T> source) {
        return new AsyncQueryableWrapper<T>(source);
    }

    public static IQueryable<T> AsAsyncQueryable<T>(this IQueryable<T> source) {
        return new AsyncQueryableWrapper<T>(source);
    }
}

internal class AsyncQueryableWrapper<T> : IAsyncEnumerable<T>, IQueryable<T> {
    private readonly IQueryable<T> _source;

    public AsyncQueryableWrapper(IQueryable<T> source) {
        _source = source;
    }

    public AsyncQueryableWrapper(IEnumerable<T> source) {
        _source = source.AsQueryable();
    }

    public IAsyncEnumerator<T> GetAsyncEnumerator(CancellationToken cancellationToken = default) {
        return new AsyncEnumerator<T>(this.AsEnumerable().GetEnumerator());
    }

    IAsyncEnumerator IAsyncEnumerable.GetAsyncEnumerator() {
        return GetAsyncEnumerator();
    }

    public IEnumerator<T> GetEnumerator() {
        return _source.GetEnumerator();
    }

    IEnumerator IEnumerable.GetEnumerator() {
        return GetEnumerator();
    }

    public Expression Expression => _source.Expression;
    public Type ElementType => _source.ElementType;
    public IQueryProvider Provider => new AsyncQueryProvider<T>(_source.Provider);
}

internal class AsyncEnumerable<T> : EnumerableQuery<T>, IDbAsyncEnumerable<T>, IQueryable<T> {
    public AsyncEnumerable(IEnumerable<T> enumerable)
        : base(enumerable) { }

    public AsyncEnumerable(Expression expression)
        : base(expression) { }

    public IDbAsyncEnumerator<T> GetAsyncEnumerator() {
        return new AsyncEnumerator<T>(this.AsEnumerable().GetEnumerator());
    }

    IDbAsyncEnumerator IDbAsyncEnumerable.GetAsyncEnumerator() {
        return GetAsyncEnumerator();
    }

    IQueryProvider IQueryable.Provider => new AsyncQueryProvider<T>(this);
}

internal class AsyncQueryProvider<TEntity> : IDbAsyncQueryProvider {
    private readonly IQueryProvider _inner;

    internal AsyncQueryProvider(IQueryProvider inner) {
        _inner = inner;
    }

    public IQueryable CreateQuery(Expression expression) {
        var t = expression.Type;
        if (!t.IsGenericType) {
            return new AsyncEnumerable<TEntity>(expression);
        }

        var genericParams = t.GetGenericArguments();
        var genericParam = genericParams[0];
        var enumerableType = typeof(AsyncEnumerable<>).MakeGenericType(genericParam);

        return (IQueryable) Activator.CreateInstance(enumerableType, expression);
    }

    public IQueryable<TElement> CreateQuery<TElement>(Expression expression) {
        return new AsyncEnumerable<TElement>(expression);
    }

    public object Execute(Expression expression) {
        return _inner.Execute(expression);
    }

    public TResult Execute<TResult>(Expression expression) {
        return _inner.Execute<TResult>(expression);
    }

    public Task<object> ExecuteAsync(Expression expression, CancellationToken cancellationToken) {
        return Task.FromResult(Execute(expression));
    }

    public Task<TResult> ExecuteAsync<TResult>(Expression expression, CancellationToken cancellationToken) {
        return Task.FromResult(Execute<TResult>(expression));
    }
}

internal class AsyncEnumerator<T> : IDbAsyncEnumerator<T> {
    private readonly IEnumerator<T> _inner;

    public AsyncEnumerator(IEnumerator<T> inner) {
        _inner = inner;
    }

    public void Dispose() {
        _inner.Dispose();
    }

    public Task<bool> MoveNextAsync(CancellationToken cancellationToken) {
        return Task.FromResult(_inner.MoveNext());
    }

    public T Current => _inner.Current;

    object IDbAsyncEnumerator.Current => Current;
}