LINQ to Entities调用仓储方法报错，寻求单查询解决方案

这个问题的核心是EF无法将自定义的MemberRepository.Get方法翻译成SQL——LINQ to Entities只能识别它内置的LINQ运算符和表达式树，自定义方法调用不在其识别范围内。我们需要调整Member仓储的逻辑，把查询逻辑以EF能理解的形式暴露出来，同时保持仓储分离的设计。

步骤1：重构MemberRepository，封装可复用的查询逻辑 #

我们把Member的映射和查询逻辑拆分为可复用的静态成员，这样既保留仓储的职责，又能让Person仓储直接使用这些逻辑构建EF可识别的查询：

public class MemberRepository : Interfaces.IRepository<IMemberBase, string>
{
    private Data.LSAEntities entities { get; set; }
    public MemberRepository(Data.LSAEntities entities)
    {
        this.entities = entities;
    }

    // 1. 封装从tblMember到IMember的投影表达式（EF能识别）
    internal static Expression<Func<tblMember, IMember>> MapToMember = t => 
        new Member()
        {
            MemberID = t.MemberID,
            // 这里保留你原来的所有属性映射逻辑
            // 比如关联tblDataOptions的逻辑可以调整为嵌套查询：
            StatusText = entities.tblDataOptions
                .FirstOrDefault(o => o.DataName == "MemberStatus" && o.DataValue == t.Status)
                ?.DisplayName
        };

    // 2. 封装完整的Member基础查询（包含关联表逻辑）
    internal static IQueryable<IMember> GetMemberQuery(Data.LSAEntities entities)
    {
        return from t in entities.tblMembers
               let statusOptions = entities.tblDataOptions.Where(o => o.DataName == "MemberStatus")
               select new Member()
               {
                   MemberID = t.MemberID,
                   // 这里复制你原来Get方法里的完整映射逻辑
                   Status = statusOptions.FirstOrDefault(o => o.DataValue == t.Status)?.DisplayName,
                   // 其他属性...
               };
    }

    // 保留原有的Get方法，供单独查询Member使用
    public IQueryable<IMember> Get(Expression<Func<tblMember, bool>> predicate)
    {
        return entities.tblMembers.Where(predicate).Select(MapToMember);
    }
}

步骤2：修改PersonRepository，复用Member的查询逻辑 #

现在Person仓储可以直接使用MemberRepository提供的IQueryable或表达式树，构建EF能合并的嵌套查询：

方案A：使用预定义的Member查询

public class PersonRepository : IRepository<IPerson, int>
{
    private Data.LSAEntities entities { get; set; }
    public PersonRepository(Data.LSAEntities entities)
    {
        this.entities = entities;
    }

    public IQueryable<IPerson> Get(int key)
    {
        // 获取Member的完整查询（包含关联表）
        var memberQuery = MemberRepository.GetMemberQuery(entities);

        return from p in entities.tblPersons
               where p.PersonId == key
               select new Person()
               {
                   PersonId = p.PersonId,
                   // 其他Person属性映射...
                   // 嵌套查询：EF会自动将这部分合并到主SQL中
                   Member = memberQuery.FirstOrDefault(m => m.MemberID == p.MemberId)
               };
    }

    // 支持异步查询（直接用EF的异步扩展方法）
    public async Task<IPerson> GetAsync(int key)
    {
        var memberQuery = MemberRepository.GetMemberQuery(entities);

        return await (from p in entities.tblPersons
                      where p.PersonId == key
                      select new Person()
                      {
                          PersonId = p.PersonId,
                          // 其他属性...
                          Member = memberQuery.FirstOrDefault(m => m.MemberID == p.MemberId)
                      }).FirstOrDefaultAsync();
    }
}

方案B：使用投影表达式（更灵活）

如果不需要完整的关联查询，只需要基础映射，也可以直接用投影表达式：

public IQueryable<IPerson> Get(int key)
{
    return from p in entities.tblPersons
           where p.PersonId == key
           select new Person()
           {
               PersonId = p.PersonId,
               // 其他属性...
               Member = entities.tblMembers
                   .Where(m => m.MemberID == p.MemberId)
                   .Select(MemberRepository.MapToMember)
                   .FirstOrDefault()
           };
}

为什么这样可行？ #

• 所有逻辑都是基于EF能识别的LINQ表达式和实体集，没有自定义方法调用，EF可以将整个查询翻译成单个SQL语句，实现嵌套查询，避免两次数据库访问。
• 仓储分离的设计得以保留：Member的映射和复杂查询逻辑仍完全由MemberRepository负责，PersonRepository不需要关心Member的底层表结构，只需要复用暴露出来的查询逻辑。
• 异步支持：因为返回的是IQueryable，你可以直接使用EF的FirstOrDefaultAsync、ToListAsync等异步扩展方法，完美支持异步调用。

内容的提问来源于stack exchange，提问作者Christopher Steven