如何在异步存储库方法中返回空IQueryable

Question

假设我有一个简单的存储库类,有一个GetByNames方法

public class MyRepo
{
    private readonly MyDbContext _db;

    public MyRepo(MyDbContext db)
    {
        _db = db;
    }

    public IQueryable<MyObject> GetByNames(IList<string> names)
    {
        if (names== null || !names.Any())
        {
            return Enumerable.Empty<MyObject>().AsQueryable();
        }

        return _db.MyObjects.Where(a => names.Contains(a.Name));
    }
}

现在当我使用异步EntityFramework ToListAsync()扩展时

var myObjects = awawit new MyRepo(_db).GetByNames(names).ToListAsync();

如果我传入空列表或null,它会爆炸,因为Enumerable.Empty<MyObject>().AsQueryable()没有实现IDbAsyncEnumerable<MyObject>接口.

源IQueryable未实现IDbAsyncEnumerable.只有实现IDbAsyncEnumerable的源才能用于Entity Framework异步操作.有关详细信息,请参阅http://go.microsoft.com/fwlink/?LinkId=287068.

所以我的问题是,如何在没有访问数据库的情况下返回一个IQueryable<>实现的空IDbAsyncEnumerable？

Answer 1

我最终实现了一个扩展方法,它返回实现的包装器IDbAsyncEnumerable.它基于这个用于模拟异步代码的样板实现.

使用这种扩展方法我可以使用

return Enumerable.Empty<MyObject>().AsAsyncQueryable();

这很棒.

执行:

using System;
using System.Collections;
using System.Collections.Generic;
using System.Data.Entity.Infrastructure;
using System.Linq;
using System.Linq.Expressions;
using System.Threading;
using System.Threading.Tasks;

namespace MyProject.MyDatabase.Extensions
{
    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>: IDbAsyncEnumerable<T>, IQueryable<T>
    {
        private readonly IQueryable<T> _source;

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

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

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

        IDbAsyncEnumerator IDbAsyncEnumerable.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;
    }
}

Answer 2

如果您不想访问数据库，您很可能必须提供自己的IQuerable执行IDbAsyncEnumerable. 但我不认为这太难了。在所有枚举器中，仅返回nullforCurrent和falsefor MoveNext。只是Dispose什么也不做。尝试一下。Enumerable.Empty<MyObject>().AsQueryable()与数据库无关，它肯定没有实现IDbAsyncEnumerable。根据this ，您需要一个可以实现的实现。