由于 IDbAsyncEnumerable 错误，无法使用实体框架查询数据库答案

【问题标题】：Not able to query database using Entity Framework because of IDbAsyncEnumerable error由于 IDbAsyncEnumerable 错误，无法使用实体框架查询数据库
【发布时间】：2018-08-26 00:10:27
【问题描述】：

最初，我收到此错误：

发生 System.InvalidOperationException
HResult=-2146233079
Message=源 IQueryable 没有实现 IDbAsyncEnumerable。只有实现 IDbAsyncEnumerable 的源才能用于实体框架异步操作。有关详细信息，请参阅http://go.microsoft.com/fwlink/?LinkId=287068。

Source=EntityFramework

堆栈跟踪：在 System.Data.Entity.QueryableExtensions.AsDbAsyncEnumerable[T]（IQueryable1 source) at System.Data.Entity.QueryableExtensions.ToListAsync[TSource](IQueryable1 源）
在 C:\Projects\MyApp\MyAppModel\Cpr.Apps.Tam.Model\Utilities\DataSnapshot.cs:160 行中的 Cpr.Apps.Tam.Model.Utilities.DataSnapshot`1.d__18.MoveNext() 处

内部异常：

所以我尝试使用此代码（参见IDbAsyncEnumerable not implemented 中的@Tony O'Hagan's 答案，来自他引用的页面https://msdn.microsoft.com/en-us/data/dn314429#async）：

这里是源代码：

public static class AsyncQueryableExtensions
{
    public static IQueryable<TElement> AsAsyncQueryable<TElement>(this IEnumerable<TElement> source)
    {
        return new DbAsyncEnumerable<TElement>(source);
    }

    public static IDbAsyncEnumerable<TElement> AsDbAsyncEnumerable<TElement>(this IEnumerable<TElement> source)
    {
        return new DbAsyncEnumerable<TElement>(source);
    }

    public static EnumerableQuery<TElement> AsAsyncEnumerableQuery<TElement>(this IEnumerable<TElement> source)
    {
        return new DbAsyncEnumerable<TElement>(source);
    }

    public static IQueryable<TElement> AsAsyncQueryable<TElement>(this Expression expression)
    {
        return new DbAsyncEnumerable<TElement>(expression);
    }

    public static IDbAsyncEnumerable<TElement> AsDbAsyncEnumerable<TElement>(this Expression expression)
    {
        return new DbAsyncEnumerable<TElement>(expression);
    }

    public static EnumerableQuery<TElement> AsAsyncEnumerableQuery<TElement>(this Expression expression)
    {
        return new DbAsyncEnumerable<TElement>(expression);
    }
}

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

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

    public IQueryable CreateQuery(Expression expression)
    {
        return new DbAsyncEnumerable<TEntity>(expression);
    }

    public IQueryable<TElement> CreateQuery<TElement>(Expression expression)
    {
        return new DbAsyncEnumerable<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 DbAsyncEnumerable<T> : EnumerableQuery<T>, IDbAsyncEnumerable<T>, IQueryable<T>
{
    public DbAsyncEnumerable(IEnumerable<T> enumerable)
        : base(enumerable)
    { }

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

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

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

    IQueryProvider IQueryable.Provider
    {
        get { return new DbAsyncQueryProvider<T>(this); }
    }
}

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

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

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

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

    public T Current
    {
        get { return _inner.Current; }
    }

    object IDbAsyncEnumerator.Current
    {
        get { return Current; }
    }
}

请注意，我收到以下错误：

System.NullReferenceException 未被用户代码处理 HResult=-2147467261 消息=对象引用未设置为对象的实例。
Source=匿名托管的 DynamicMethods 程序集

堆栈跟踪：
在 lambda_method(Closure , DefectSummary )
在 System.Linq.Enumerable.WhereListIterator1.MoveNext() at System.Linq.Enumerable.<DistinctIterator>d__641.MoveNext()
在 System.Linq.Buffer1..ctor(IEnumerable1 来源）
在 System.Linq.OrderedEnumerable1.<GetEnumerator>d__1.MoveNext() at System.Linq.Enumerable.<DistinctIterator>d__641.MoveNext()
在 System.Linq.Enumerable.d__251.MoveNext() at MyApp.Model.Utilities.DbAsyncEnumerator1.MoveNextAsync(CancellationToken cancelToken) 在 C:\Projects\MyApp\Model\Utilities\AsyncQueryableExtensions.cs:line 125
在 System.Data.Entity.Infrastructure.IDbAsyncEnumerableExtensions.d__5`1.MoveNext() InnerException：

有没有人有任何建议来确定我如何找到导致异常的空值？它发生在这个函数中：

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

当我检查 _inner 时，我不清楚变量的哪一部分导致了 null 错误：

-       _inner  {System.Linq.Enumerable.<TakeIterator>d__25<MyApp.Model.Entities.DefectSummary>}    System.Collections.Generic.IEnumerator<MyApp.Model.Entities.DefectSummary> {System.Linq.Enumerable.<TakeIterator>d__25<MyApp.Model.Entities.DefectSummary>}
+       Non-Public members      
-       Results View    Expanding the Results View will enumerate the IEnumerable   
-       Data    {System.Collections.ListDictionaryInternal} System.Collections.IDictionary {System.Collections.ListDictionaryInternal}
        Count   0   int
        IsFixedSize false   bool
        IsReadOnly  false   bool
        IsSynchronized  false   bool
-       Keys    {System.Collections.ListDictionaryInternal.NodeKeyValueCollection}  System.Collections.ICollection {System.Collections.ListDictionaryInternal.NodeKeyValueCollection}
+       Non-Public members      
-       Results View    Expanding the Results View will enumerate the IEnumerable   
        Empty   "Enumeration yielded no results"    string
        SyncRoot    {object}    object
+       Values  {System.Collections.ListDictionaryInternal.NodeKeyValueCollection}  System.Collections.ICollection {System.Collections.ListDictionaryInternal.NodeKeyValueCollection}
+       Non-Public members      
+       Results View    Expanding the Results View will enumerate the IEnumerable   
        HResult -2147467261 int
        HelpLink    null    string
+       InnerException  null    System.Exception
        Message "Object reference not set to an instance of an object." string
        Source  "Anonymously Hosted DynamicMethods Assembly"    string
        StackTrace  "   at lambda_method(Closure , DefectSummary )\r\n   at System.Linq.Enumerable.WhereListIterator`1.MoveNext()\r\n   at System.Linq.Enumerable.<DistinctIterator>d__64`1.MoveNext()\r\n   at System.Linq.Buffer`1..ctor(IEnumerable`1 source)\r\n   at System.Linq.OrderedEnumerable`1.<GetEnumerator>d__1.MoveNext()\r\n   at System.Linq.Enumerable.<DistinctIterator>d__64`1.MoveNext()\r\n   at System.Linq.Enumerable.<TakeIterator>d__25`1.MoveNext()\r\n   at System.Linq.SystemCore_EnumerableDebugView`1.get_Items()"   string
+       TargetSite  {Boolean lambda_method(System.Runtime.CompilerServices.Closure, MyApp.Model.Entities.DefectSummary)}    System.Reflection.MethodBase {System.Reflection.Emit.DynamicMethod.RTDynamicMethod}
+       Static members      
+       Non-Public members

更新：

仅供参考，这是设置查询的更高级别的函数：

    public IQueryable<Defect> GetLoadQuery()
    {
        IQueryable<Defect> query = null;
        // Call to stored procedure GetDefects
        var defectList = DbContext.GetDefects(null, null).ToList();
        var defects = new List<Defect>();

        using (IDefectDataService dataService = ServiceLocator.Current.GetInstance<IDefectDataService>())
        {
            foreach (var i in defectList)
            {
                dataService.DefectId = i.NotificationNo;
                NotificationLinearAsset notificationLam = dataService.GetNotificationLinearAsset();
                decimal? startPoint = notificationLam.StartPoint;
                decimal? endPoint = notificationLam.EndPoint;
                defects .Add(new Defect()
                {
                    NotificationNo = i.NotificationNo,
                    Priority = i.Priority,
                    ReportedBy = i.ReportedBy,
                    MeasuringDocument = i.MeasuringDocument,
                    AssetTypeDescription = i.AssetTypeDescription,
                    StartPoint = startPoint,
                    EndPoint = endPoint,
                    Description = i.Description,
                    AssetId = i.AssetId,
                });
            }
            query = defectSummaries.AsQueryable();
            // Other code here for filtering results...
        }

        return query.AsAsyncQueryable();
    }

更新 2：

变得更加奇怪了，因为如果我注释掉这两行，查询就会起作用并返回结果：

                //StartPoint = startPoint,
                //EndPoint = endPoint,

但是当我在foreach 中放置一个条件断点以在startPoint 或endPoint 为空时停止时，调试器永远不会停止。

更新 3：

感谢您的建议，@Ivan Stoev。请注意，我今天执行了另一项测试，除了取消注释 StartPoint/EndPoint 之外没有更改任何代码，并且它没有错误，所以我不确定为什么会这样。也许某些东西被缓存在 Visual Studio 中？

【问题讨论】：

根据异常堆栈跟踪，异常源自Where lambda 委托，因此请检查您的此处的其他代码以获取过滤结果...。

标签： c# entity-framework

【解决方案1】：

解决了这个问题，而不是使用存储过程结果，它创建一个GetDefect_Result 类型，然后将其转换为Defect 类型以供上述foreach 循环中的MVVM 应用程序使用，我改为创建了一个视图并使用直接映射到Defect 类型结果的该视图的结果。此解决方案还涉及删除对 IDbAsyncEnumerable 的所有引用。

    public IQueryable<Defect> GetLoadQuery()
    {
        IDbSet<Defect> dbSet = DbContext.Defects;

        IQueryable<Defect> query = dbSet.AsQueryable();

        // Other code here for filtering results...
        return query;
    }

仅供参考，我曾想使用存储过程，因为我使用的数据库通常无法优化视图，如果它有子视图，但最终我能够通过向关联表添加更多索引来使用视图提高数据库性能。

【讨论】：