查询主体时获取依赖ID

Answer 1

您可以通过Select 投影所有内容

var result = ctx.ListingModels
   .Select(lm => new // or to DTO
   {
       Id = lm.Id,
       OtherProperty = lm.OtherProperty,
       
       Ids = x.MenuIds.Select(m => m.Id).ToList()
   })
   .ToList();

为了制定更通用的解决方案，我们可以使用注释并定义如何投影此类实体。

在模型定义期间：

builder.Entity<TopicModel>()
    .WithProjection(
        x => x.MenuIds,
        x => x.Menus.Where(y => y.ListingId == x.Id).Select(y => y.Id).ToList()
    );

然后在通用代码中使用：

public virtual List<TModel> GetList(List<int> ids)
{
    var list = _context.Set<TModel>().Where(x => ids.Any(id => id == x.Id))
        .ApplyCustomProjection(_context)
        .ToList();
    return list;
}

ApplyCustomProjection(_context) 将找到先前定义的注释并应用自定义投影。

---

和扩展实现：

public static class ProjectionExtensions
{
    public const string CustomProjectionAnnotation = "custom:member_projection";

    public class ProjectionInfo
    {
        public ProjectionInfo(MemberInfo member, LambdaExpression expression)
        {
            Member = member;
            Expression = expression;
        }

        public MemberInfo Member { get; }
        public LambdaExpression Expression { get; }
    }

    public static EntityTypeBuilder<TEntity> WithProjection<TEntity, TValue>(
        this EntityTypeBuilder<TEntity> entity, 
        Expression<Func<TEntity, TValue>> propExpression, 
        Expression<Func<TEntity, TValue>> assignmentExpression) 
        where TEntity : class
    {
        var annotation = entity.Metadata.FindAnnotation(CustomProjectionAnnotation);
        var projections = annotation?.Value as List<ProjectionInfo> ?? new List<ProjectionInfo>();

        if (propExpression.Body is not MemberExpression memberExpression)
            throw new InvalidOperationException($"'{propExpression.Body}' is not member expression");

        if (memberExpression.Expression is not ParameterExpression)
            throw new InvalidOperationException($"'{memberExpression.Expression}' is not parameter expression. Only single nesting is allowed");

        // removing duplicate
        projections.RemoveAll(p => p.Member == memberExpression.Member);

        projections.Add(new ProjectionInfo(memberExpression.Member, assignmentExpression));
        return entity.HasAnnotation(CustomProjectionAnnotation, projections);
    }

    public static IQueryable<TEntity> ApplyCustomProjection<TEntity>(this IQueryable<TEntity> query, DbContext context)
        where TEntity : class
    {
        var et = context.Model.FindEntityType(typeof(TEntity));
        var projections = et?.FindAnnotation(CustomProjectionAnnotation)?.Value as List<ProjectionInfo>;

        // nothing to do
        if (projections == null || et == null)
            return query;

        var propertiesForProjection = et.GetProperties().Where(p =>
            p.PropertyInfo != null && projections.All(pr => pr.Member != p.PropertyInfo))
            .ToList();

        var entityParam = Expression.Parameter(typeof(TEntity), "e");

        var memberBinding = new MemberBinding[propertiesForProjection.Count + projections.Count];
        for (int i = 0; i < propertiesForProjection.Count; i++)
        {
            var propertyInfo = propertiesForProjection[i].PropertyInfo!;
            memberBinding[i] = Expression.Bind(propertyInfo, Expression.MakeMemberAccess(entityParam, propertyInfo));
        }

        for (int i = 0; i < projections.Count; i++)
        {
            var projection = projections[i];
            var expression = projection.Expression.Body;

            var assignExpression = ReplacingExpressionVisitor.Replace(projection.Expression.Parameters[0], entityParam, expression);

            memberBinding[propertiesForProjection.Count + i] = Expression.Bind(projection.Member, assignExpression);
        }

        var memberInit = Expression.MemberInit(Expression.New(typeof(TEntity)), memberBinding);

        var selectLambda = Expression.Lambda<Func<TEntity, TEntity>>(memberInit, entityParam);

        var newQuery = query.Select(selectLambda);
        return newQuery;
    }
}