Entity Framework Core：使用 AsNoTracking 过滤 Include 时的奇怪行为

Question

I don't know if it is expected to be this way but I thought it is strange since changes the query results.

When I execute the query below I get my entity with only 2 "Mensagens" entity because i'm filtering only the actives so it's right, I have 2 active entities on my database and 1 inactive.

return await context.Lancamentos
            .Include(x => x.UsuarioCriacao)
            .Include(x => x.Mensagens.Where(m => m.Ativo))
            .ThenInclude(m => m.MensagemMedias)
            .ThenInclude(m => m.MediaWhatsapp)
            .ThenInclude(m => m.TipoMediaWhatsapp)
            .Include(x => x.Mensagens.Where(m => m.Ativo))
            .ThenInclude(x => x.TemplateMensagem)
            .ThenInclude(t => t.Medias)
            .ThenInclude(m => m.MediaWhatsapp)
            .ThenInclude(m => m.TipoMediaWhatsapp)
            .AsNoTracking()
            .FirstOrDefaultAsync(l => l.Id == id && l.Ativo);

But if I execute the exact same command just removing the AsNoTracking() line it gives me the 3 records, both active and inactive.

But the inactive one EF doesn't fetch the ThenInclude below. It changes the behaviour.

With AsNoTracking it filters the data according to the filter I used on Include

Without AsNoTracking it bring me all the data but it filters if it will load or not the ThenInclude objects.

Does anyone know if this is a normal behaviour and why does it behaves like this?

Answer 1

When handling with complex query like that I used to use Linq instead of Lambda to be sure I'm make me clear enough to my colleagues and to myself in the future.

To understand what's going on with your query I should say the identation matters a lot. For example, is that what I am understanding from your query:

return await context.Lancamentos
            .Include(x => x.UsuarioCriacao)
            .Include(x => x.Mensagens.Where(m => m.Ativo))
                .ThenInclude(m => m.MensagemMedias)
                    .ThenInclude(m => m.MediaWhatsapp)
                        .ThenInclude(m => m.TipoMediaWhatsapp)
            .Include(x => x.Mensagens.Where(m => m.Ativo))
                .ThenInclude(x => x.TemplateMensagem)
                    .ThenInclude(t => t.Medias)
                        .ThenInclude(m => m.MediaWhatsapp)
                            .ThenInclude(m => m.TipoMediaWhatsapp)
                                .AsNoTracking()
            .FirstOrDefaultAsync(l => l.Id == id && l.Ativo);

And I feel like it's what you really want is something like that:

return await (context.Lancamentos
            .Include(x => x.UsuarioCriacao)
            .Include(x => x.Mensagens.Where(m => m.Ativo))
                .ThenInclude(m => m.MensagemMedias)
                    .ThenInclude(m => m.MediaWhatsapp)
                        .ThenInclude(m => m.TipoMediaWhatsapp)
            .Include(x => x.Mensagens.Where(m => m.Ativo))
                .ThenInclude(x => x.TemplateMensagem)
                    .ThenInclude(t => t.Medias)
                        .ThenInclude(m => m.MediaWhatsapp)
                            .ThenInclude(m => m.TipoMediaWhatsapp))
            .AsNoTracking()
            .FirstOrDefaultAsync(l => l.Id == id && l.Ativo);

The difference could be explained by the different contexts between the first message restrictions and the second one. One of the messages is being retrieved twice because one of it's instance is in and the other one is outside the ef context.

You should check again the docs about the ThenInclude and the AsNoTracking extension methods to be sure you are using it in the right way.