EF6：将 reference/lookup 数据与 IQueryable 结合使用

Question

我想在查询中使用列表中的预加载查找数据。我需要 return 作为 IQueryable 的查询，因为它在网格中使用并被分页（此处未包含）。我需要从查找中加载标签以避免连接（更多在实际代码中）。

我知道我可以执行 ToList() 并 post 处理它，但我需要 IQueryable。这是代码：

// Run in intialization other code...
var contactLookups = new ContactsDbContext();
List<StatusType> _statusTypes = contactLookups.StatusTypes.ToList();


    public IQueryable GetQuery()
    {
        var contactsCtx = new ContactsDbContext();
        IQueryable query = contactsCtx.Select(contact => new
        {
            Id = contact.Id,
            FullName = contact.FirstName + " " + contact.LastName,
            CompanyName = contact.CompanyName,
            Status = _statusTypes.FirstOrDefault(l => contact.StatusId == l.Id).Label
        });
        return query;
    }

上面的代码会抛出一个错误，因为 EF/LINQ 无法将内存列表组成 SQL（原因很明显）- 除非是 added/changed.

我想以某种方式 告诉 EF 在 SQL 之后应用查找或类似的东西。我读过关于使用 EF Helper 代码和表达式做类似的事情，但我找不到那篇文章了。

请注意，我对查找本身很灵活。唯一不可协商的是 "contact.StatusId" (int)，但结构的其余部分“_statusTypes.FirstOrDefault(l => contact.StatusId == l.Id)”，就像 List类型，已打开。

感谢任何帮助。

Answer 1

您可以将 EF 的查询包装到您自己的 IQueryable 拦截实现中，在其中您可以在 return 将对象发送到应用程序之前注入内存中查找的值。

这听起来可能很复杂，但实际上实施起来并不难。需要完成以下工作：

将实体中的 Status 属性标记为未映射（使用 Ignore() 和 Fluent API 或 [NotMapped] 属性在属性).
编写 InterceptingQueryable<T>（让我们这样命名）实现 IOrderedQueryable<T>，它包装来自 EF 的 IQueryable<T> 对象（returned您示例中的 Select 方法）。
编写 InterceptingQueryProvider<T> 实现 IQueryProvider<T>，它依次包装从 EF 获得的查询提供程序。
编写 InterceptingEnumerator<T> 实现 IEnumerator<T>，它中继到由 EF 编辑的枚举器对象 return。 此枚举器将在执行 MoveNext 后立即注入 Status 属性的值（可以很容易地概括为填充任何查找属性），以便对象 return由 Current 编辑的内容已全部填充。

以上链连接如下：

InterceptingQueryable 中继到 EF 的查询对象，在构造函数中传递。
InterceptingQueryable.Provider 属性 returns InterceptingQueryProvider.
InterceptingQueryable.GetEnumerator 方法 returns InterceptingEnumerator.
InterceptingQueryProvider.CreateQuery 方法从 EF 查询提供程序获取查询对象，然后 return 它包装在 InterceptingQueryable.
[= 的另一个实例中86=]
InterceptingQueryProvider.Execute 在 EF 查询提供程序上调用 Execute，然后在它获得受查找注入影响的实体的情况下，它会在相同的位置注入查找值InterceptingEnumerator 的方式（提取方法以供重用）。

更新

代码如下：

using System;
using System.Collections;
using System.Collections.Generic;
using System.Linq;
using System.Linq.Expressions;
using System.Text;
using System.Threading.Tasks;

namespace Examples.Queryables
{
    public class InterceptingQueryable<T> : IOrderedQueryable<T>
    {
        private readonly Action<T> _interceptor;
        private readonly IQueryable<T> _underlyingQuery;
        private InterceptingQueryProvider _provider;

        public InterceptingQueryable(Action<T> interceptor, IQueryable<T> underlyingQuery)
        {
            _interceptor = interceptor;
            _underlyingQuery = underlyingQuery;
            _provider = null;
        }
        public IEnumerator<T> GetEnumerator()
        {
            return new InterceptingEnumerator(_interceptor, _underlyingQuery.GetEnumerator());
        }
        IEnumerator IEnumerable.GetEnumerator()
        {
            return GetEnumerator();
        }
        public Expression Expression 
        {
            get { return _underlyingQuery.Expression; }
        }
        public Type ElementType 
        {
            get { return _underlyingQuery.ElementType; }
        }
        public IQueryProvider Provider 
        {
            get
            {
                if ( _provider == null )
                {
                    _provider = new InterceptingQueryProvider(_interceptor, _underlyingQuery.Provider); 
                }
                return _provider;
            }
        }

        private class InterceptingQueryProvider : IQueryProvider
        {
            private readonly Action<T> _interceptor;
            private readonly IQueryProvider _underlyingQueryProvider;

            public InterceptingQueryProvider(Action<T> interceptor, IQueryProvider underlyingQueryProvider)
            {
                _interceptor = interceptor;
                _underlyingQueryProvider = underlyingQueryProvider;
            }
            public IQueryable CreateQuery(Expression expression)
            {
                throw new NotImplementedException();
            }
            public IQueryable<TElement> CreateQuery<TElement>(Expression expression)
            {
                var query = _underlyingQueryProvider.CreateQuery<TElement>(expression);

                if ( typeof(T).IsAssignableFrom(typeof(TElement)) )
                {
                    return new InterceptingQueryable<TElement>((Action<TElement>)(object)_interceptor, query);
                }
                else
                {
                    return query;
                }
            }
            public object Execute(Expression expression)
            {
                throw new NotImplementedException();
            }
            public TResult Execute<TResult>(Expression expression)
            {
                var result = _underlyingQueryProvider.Execute<TResult>(expression);

                if ( result is T )
                {
                    _interceptor((T)(object)result);
                }

                return result;
            }
        }

        private class InterceptingEnumerator : IEnumerator<T>
        {
            private readonly Action<T> _interceptor;
            private readonly IEnumerator<T> _underlyingEnumerator;
            private bool _hasCurrent;

            public InterceptingEnumerator(Action<T> interceptor, IEnumerator<T> underlyingEnumerator)
            {
                _interceptor = interceptor;
                _underlyingEnumerator = underlyingEnumerator;
                _hasCurrent = false;
            }
            public void Dispose()
            {
                _underlyingEnumerator.Dispose();
            }
            public bool MoveNext()
            {
                _hasCurrent = _underlyingEnumerator.MoveNext();

                if ( _hasCurrent )
                {
                    _interceptor(_underlyingEnumerator.Current);
                }

                return _hasCurrent;
            }
            public void Reset()
            {
                _underlyingEnumerator.Reset();
            }
            public T Current 
            {
                get
                {
                    return _underlyingEnumerator.Current;
                }
            }
            object IEnumerator.Current
            {
                get { return Current; }
            }
        }
    }

    public static class QueryableExtensions
    {
        public static IOrderedQueryable<T> InterceptWith<T>(this IQueryable<T> query, Action<T> interceptor)
        {
            return new InterceptingQueryable<T>(interceptor, query);
        }
    }
}

这里是测试 case/example。首先，我们不应该忘记将非映射状态属性添加到联系人实体：

public partial class Contact
{
    [NotMapped]
    public StatusType Status { get; set; }
}

那么，我们可以使用拦截器机制如下：

var contactLookups = contactsCtx.StatusTypes.ToList();

Action<Contact> interceptor = contact => {
    contact.Status = contactLookups.FirstOrDefault(l => contact.StatusId == l.Id);
};

// note that we add InterceptWith(...) to entity set
var someContacts = 
    from c in contactsCtx.Contacts.InterceptWith(interceptor) 
    where c.FullName.StartsWith("Jo")
    orderby c.FullName, c.CompanyName
    select c;

Console.WriteLine("--- SOME CONTACTS ---");
foreach ( var c in someContacts )
{
    Console.WriteLine(
        "{0}: {1}, {2}, {3}={4}", 
        c.Id, c.FullName, c.CompanyName, c.StatusId, c.Status.Name);
}

打印：

--- SOME CONTACTS ---
1: John Smith, Acme Corp, 3=Status Three
3: Jon Snow, The Wall, 2=Status Two

查询被翻译成：

SELECT 
    [Extent1].[Id] AS [Id], 
    [Extent1].[FullName] AS [FullName], 
    [Extent1].[CompanyName] AS [CompanyName], 
    [Extent1].[StatusId] AS [StatusId]
    FROM [dbo].[Contacts] AS [Extent1]
    WHERE [Extent1].[FullName] LIKE 'Jo%'
    ORDER BY [Extent1].[FullName] ASC, [Extent1].[CompanyName] ASC

Answer 2

与无法在数据库端处理整个查询的明显缺点相比，我不确定避免连接的好处是什么，但是您所要求的可以通过尽可能多地实现使用 Linq to Entities 尽可能（过滤、排序、分组、投影），然后将其转换为 IEnumerable 并使用 Linq To Objects 完成其余工作。您始终可以使用 Enumerable.AsQueryable 在 IEnumerable 上切换到 IQueryable 实现。像这样

public IQueryable GetQuery()
{
    var db = new ContactsDbContext();
    var query = db.Contacts.Select(contact => new
    {
        Id = contact.Id,
        FullName = contact.FirstName + " " + contact.LastName,
        CompanyName = contact.CompanyName,
        StatusId = contact.StatusId
    })
    .AsEnumerable()
    .Select(contact => new
    {
        Id = contact.Id,
        FullName = contact.FullName,
        CompanyName = contact.CompanyName,
        Status = _statusTypes.FirstOrDefault(l => contact.StatusId == l.Id).Label
    })
    .AsQueryable();
    return query;
}

EF6：将 reference/lookup 数据与 IQueryable 结合使用

EF6: Use reference/lookup data with IQueryable

c#

linq

lookup

iqueryable

entity-framework-6