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的包装器。它基于此boilerplate implementation用于模拟异步代码。

使用此扩展方法，我可以使用

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实现。但我不认为这太难了。在所有枚举者中，只需为null返回Current，为false返回MoveNext。在Dispose中什么都不做。试试吧。 Enumerable.Empty<MyObject>().AsQueryable()与数据库无关，它绝对不会实现IDbAsyncEnumerable。根据{{3}}，你需要一个实现。

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

2 个答案: