从你发布的链接，我可以确认，伎俩工程，但一个多（或多个一）的关系只。在这种情况下，你的 Post-Attachment 应该是一对多的关系，所以完全适用。以下是您应该具备的查询：

//this should be disabled temporarily
_context.Configuration.LazyLoadingEnabled = false;
var allposts = _context.Posts.Where(t => t.PostAuthor.Id == postAuthorId)
                       .Select(e => new {
                           e,//for later projection
                           e.Comments,//cache Comments
                           //cache filtered Attachments
                           Attachments = e.Attachments.Where(a => a.Owner is Author),
                           e.PostAuthor//cache PostAuthor
                        })
                       .AsEnumerable()
                       .Select(e => e.e).ToList();

efcore5.0即将推出。

var blogs = context.Blogs
    .Include(e => e.Posts.Where(p => p.Title.Contains("Cheese")))
    .ToList();

reference:https用法：//docs.microsoft.com/en-us/ef/core/what is new/ef-core-5.0/whatsnew

拆下 virtual 来自您的关键字 Attachments 防止延迟加载的导航属性： public ICollection<Attachment> Attachments { get; set; } 第一种方法：发出两个单独的查询：一个用于帖子，一个用于附件，其余的由关系修复完成：

List<Post> postsWithAuthoredAttachments = _context.Posts
    .Include(p => p.Comments) 
    .Include(p => p.PostAuthor)
    .Where(p => p.PostAuthor.Id == postAuthorId)
    .ToList();

List<Attachment> filteredAttachments = _context.Attachments
    .Where(a => a.Post.PostAuthor.Id == postAuthorId)
    .Where(a => a.Owner is Author)
    .ToList()

关系修复意味着您可以通过post的导航属性访问这些过滤的附件
第二种方法：对数据库进行一次查询，然后执行内存中的查询：

var query = _context.Posts
    .Include(p => p.Comments) 
    .Include(p => p.PostAuthor)
    .Where(p => p.PostAuthor.Id == postAuthorId)
    .Select(p => new 
        {
            Post = p,
            AuthoredAttachments = p.Attachments
                Where(a => a.Owner is Author)
        }
    );

我只想在这里使用匿名类型

var postsWithAuthoredAttachments = query.ToList()

或者创建viewmodel类以避免匿名类型：

List<MyDisplayTemplate> postsWithAuthoredAttachments = 
     //query as above but use new PostWithAuthoredAttachments in the Select

或者，如果你真的想拆开柱子：

List<Post> postsWithAuthoredAttachments = query.//you could "inline" this variable
    .AsEnumerable() //force the database query to run as is - pulling data into memory
    .Select(p => p) //unwrap the Posts from the in-memory results
    .ToList()

您可以使用扩展方法的这个实现（例如） Include2() . 之后，您可以拨打：

_context.Posts.Include2(post => post.Attachments.Where(a => a.OwnerId == 1))

上面的代码仅包括附件，其中 Attachment.OwnerId == 1 .

试试这个

var allposts = _context.Posts
        .Include(p => p.Comments)
        .Include(a => a.PostAuthor)
        .Where(t => t.PostAuthor.Id == postAuthorId).ToList();

_context.Attachments.Where(o=>o.Owner is Author).ToList();

对于网芯
https://docs.microsoft.com/ru-ru/ef/core/querying/related-data/explicit

var allposts = _context.Posts
        .Include(p => p.Comments)
        .Include(a => a.PostAuthor)
        .Where(t => t.PostAuthor.Id == postAuthorId).ToList();

_context.Entry(allposts)
        .Collection(e => e.Attachments)
        .Query()
        .Where(e=> e.Owner is Author)
        .Load();

它对sql进行了2次查询。

执行查询

{       
    var allposts = _context.Posts
        .Include(p => p.Comments)
        .Include(aa => aa.Attachments)
        .Include(a => a.PostAuthor)
        .AsNoTracking()
        .ToList();

    await allposts.ForEach((FilterByOwner));
}

private async void FilterByOwner(Post post)
{
    post.Attachments = post.Attachments.Where(o => o.Owner is Author);
}

lambda输入 Include() 只能指向属性：

.Include(a => a.Attachments)
.Include(a => a.Attachments.Owner);

你的状况对我来说毫无意义因为 Include() 手段 join 你要么做要么不做。不是有条件的。
您将如何用原始sql编写此代码？
为什么不这样做：

context.Attachments
       .Where(a => a.Owner.Id == postAuthorId &&
                   a.Owner.Type == authorType);

?

假设“a”属于“yourtype”类型，条件include可以通过使用方法扩展来解决，例如。

public static class QueryableExtensions
{
    public static IQueryable<T> ConditionalInclude<T>(this IQueryable<T> source, bool include) where T : YourType
    {
        if (include)
        {
            return source
                .Include(a => a.Attachments)
                .Include(a => a.Attachments.Owner));
        }

        return source;
    }
}

... 然后像你现在使用的一样使用这个。

bool yourCondition;

.ConditionalInclude(yourCondition)