Add include on DbContext level

Question

I want to implement something similar to lazy loading, but don't understand how to implement that. I want to force entity framework core include navigation property for all queries for type which implements my interface

public interface IMustHaveOrganisation
{
    Guid OrganisationId { get; set; }
    Organisation Organisation { get; set; }
}

public class MyEntity : IMustHaveOrganisation {
    public Guid OrganisationId { get; set; }
    public virtual Organisation Organisation { get; set; }
}

Without lazy loading I need to add .Include(x=>x.Organisation) to each query literally , and I can't use implementation of lazy loading provided by Microsoft. I need kind of custom implementation of that with loading just one property. Or even force DbContext somehow to Include that property, it also fine for me.

How can I achieve that?

Answer 1

For those who are new to this thread, you can now use the AutoInclude fluent configuration to force EF to include a navigation property. Read the doc.

modelBuilder.Entity<MyEntity>().Navigation(e => e.Organisation).AutoInclude();

Answer 2

You can make this work by rewriting the expression tree, before it gets translated by EF Core.

To make this work in a way, where you don't have to specify anything additional in the query, you can hook into the very beginning of the query pipeline and inject the Include() call as needed.

This can be done, by specifying a custom IQueryTranslationPreprocessorFactory implementation.

The following fully working console project demonstrates this approach:

using System.Diagnostics;
using System.Linq;
using System.Linq.Expressions;
using Microsoft.EntityFrameworkCore;
using Microsoft.EntityFrameworkCore.Query;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Logging;

namespace IssueConsoleTemplate
{
    public class Organisation
    {
        public int OrganisationId { get; set; }
        public string Name { get; set; }
    }

    public interface IMustHaveOrganisation
    {
        int OrganisationId { get; set; }
        Organisation Organisation { get; set; }
    }

    public class MyEntity : IMustHaveOrganisation
    {
        public int MyEntityId { get; set; }
        public string Name { get; set; }
        
        public int OrganisationId { get; set; }
        public virtual Organisation Organisation { get; set; }
    }

    public class CustomQueryTranslationPreprocessorFactory : IQueryTranslationPreprocessorFactory
    {
        private readonly QueryTranslationPreprocessorDependencies _dependencies;
        private readonly RelationalQueryTranslationPreprocessorDependencies _relationalDependencies;

        public CustomQueryTranslationPreprocessorFactory(
            QueryTranslationPreprocessorDependencies dependencies,
            RelationalQueryTranslationPreprocessorDependencies relationalDependencies)
        {
            _dependencies = dependencies;
            _relationalDependencies = relationalDependencies;
        }

        public virtual QueryTranslationPreprocessor Create(QueryCompilationContext queryCompilationContext)
            => new CustomQueryTranslationPreprocessor(_dependencies, _relationalDependencies, queryCompilationContext);
    }

    public class CustomQueryTranslationPreprocessor : RelationalQueryTranslationPreprocessor
    {
        public CustomQueryTranslationPreprocessor(
            QueryTranslationPreprocessorDependencies dependencies,
            RelationalQueryTranslationPreprocessorDependencies relationalDependencies,
            QueryCompilationContext queryCompilationContext)
            : base(dependencies, relationalDependencies, queryCompilationContext)
        {
        }

        public override Expression Process(Expression query)
        {
            query = new DependenciesIncludingExpressionVisitor().Visit(query);
            return base.Process(query);
        }
    }
    
    public class DependenciesIncludingExpressionVisitor : ExpressionVisitor
    {
        protected override Expression VisitConstant(ConstantExpression node)
        {
            // Call Include("Organisation"), if SomeEntity in a
            // DbSet<SomeEntity> implements IMustHaveOrganisation.
            if (node.Type.IsGenericType &&
                node.Type.GetGenericTypeDefinition() == typeof(Microsoft.EntityFrameworkCore.Query.Internal.EntityQueryable<>) &&
                node.Type.GenericTypeArguments.Length == 1 &&
                typeof(IMustHaveOrganisation).IsAssignableFrom(node.Type.GenericTypeArguments[0]))
            {
                return Expression.Call(
                    typeof(EntityFrameworkQueryableExtensions),
                    nameof(EntityFrameworkQueryableExtensions.Include),
                    new[] {node.Type.GenericTypeArguments[0]},
                    base.VisitConstant(node),
                    Expression.Constant(nameof(IMustHaveOrganisation.Organisation)));
            }

            return base.VisitConstant(node);
        }
    }

    public class Context : DbContext
    {
        public DbSet<MyEntity> MyEntities { get; set; }
        public DbSet<Organisation> Organisations { get; set; }

        protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
        {
            // Register the custom IQueryTranslationPreprocessorFactory implementation.
            // Since this is a console program, we need to create our own
            // ServiceCollection for this.
            // In an ASP.NET Core application, the AddSingleton call can just be added to
            // the general service configuration method.
            var serviceProvider = new ServiceCollection()
                .AddEntityFrameworkSqlServer()
                .AddSingleton<IQueryTranslationPreprocessorFactory, CustomQueryTranslationPreprocessorFactory>()
                .AddScoped(
                    s => LoggerFactory.Create(
                        b => b
                            .AddConsole()
                            .AddFilter(level => level >= LogLevel.Information)))
                .BuildServiceProvider();

            optionsBuilder
                .UseInternalServiceProvider(serviceProvider) // <-- use our ServiceProvider
                .UseSqlServer(@"Data Source=.\MSSQL14;Integrated Security=SSPI;Initial Catalog=62849896")
                .EnableSensitiveDataLogging()
                .EnableDetailedErrors();
        }

        protected override void OnModelCreating(ModelBuilder modelBuilder)
        {
            modelBuilder.Entity<MyEntity>(
                entity =>
                {
                    entity.HasData(
                        new MyEntity {MyEntityId = 1, Name = "First Entity", OrganisationId = 1 },
                        new MyEntity {MyEntityId = 2, Name = "Second Entity", OrganisationId = 1 },
                        new MyEntity {MyEntityId = 3, Name = "Third Entity", OrganisationId = 2 });
                });

            modelBuilder.Entity<Organisation>(
                entity =>
                {
                    entity.HasData(
                        new Organisation {OrganisationId = 1, Name = "First Organisation"},
                        new Organisation {OrganisationId = 2, Name = "Second Organisation"});
                });
        }
    }

    internal static class Program
    {
        private static void Main()
        {
            using var context = new Context();

            context.Database.EnsureDeleted();
            context.Database.EnsureCreated();

            var myEntitiesWithOrganisations = context.MyEntities
                .OrderBy(i => i.MyEntityId)
                .ToList();
            
            Debug.Assert(myEntitiesWithOrganisations.Count == 3);
            Debug.Assert(myEntitiesWithOrganisations[0].Name == "First Entity");
            Debug.Assert(myEntitiesWithOrganisations[0].Organisation.Name == "First Organisation");
        }
    }
}

Even though no explicit Include() is being made in the query in Main(), the following SQL is being generated, that does join and retrieve the Organisation entities:

SELECT [m].[MyEntityId], [m].[Name], [m].[OrganisationId], [o].[OrganisationId], [o].[Name]
FROM [MyEntities] AS [m]
INNER JOIN [Organisations] AS [o] ON [m].[OrganisationId] = [o].[OrganisationId]
ORDER BY [m].[MyEntityId]