Expose loader IQueryable on ILazyLoader

[arti1zz]

Hi,

I have entity which contains other entities inside. I'm using ILazyLoader to load them when needed, but I want to filter them. How can I filter them?

Lets say I have:

 public class Lesson : EntityBase
    {
	    private readonly ILazyLoader _lazyLoader;

	    public Lesson(ILazyLoader lazyLoader)
	    {
		    _lazyLoader = lazyLoader;
	    }

            [Required]
		public List<Topic> Topics
		{
			get => _lazyLoader.Load(this, ref _topics);
			set => _topics = value;
		}

              private List<Topic> _topics;

I want to access lesson.Grades, but my grades should be filtered by IsValid field.

At the moment it will load all the grades.

I understand I can do _lazyLoader.Load(this, ref _topics).Where(x => x.IsValid).ToList();, but I want filter in database level

Is this possible?

Include provider and version information

EF Core version: 3.1.1
Database provider: Microsoft.EntityFrameworkCore.SqlServer
Target framework: Core 3.1

[ajcvickers]

Note for triage: we should consider exposing the underlying queryable on ILazyLoader.

@arti1zz There isn't currently a way to do this with ILazyLoader, but you can inject the DbContext to achieve this--see example code below. Note, however, that this does introduce a strong coupling of your entity types to DbContext.

public class Lesson
{
    private readonly DbContext _context;

    public Lesson()
    {
    }

    public Lesson(DbContext context)
    {
        _context = context;
    }

    public int Id { get; set; }

    [Required]
    public List<Topic> Topics
    {
        get
        {
            if (_topics == null
                && _context != null)
            {
                var collectionEntry = _context.Entry(this).Collection(e => e.Topics);
                collectionEntry.Query().Where(e => e.IsValid).Load();
                collectionEntry.IsLoaded = true;
            }

            return _topics;
        }
        set => _topics = value;
    }

    private List<Topic> _topics;
}

public class Topic
{
    public int Id { get; set; }
    
    public bool IsValid { get; set; }
}

public class Program
{
    public static void Main()
    {
        using (var context = new SomeDbContext())
        {
            context.Database.EnsureDeleted();
            context.Database.EnsureCreated();

            context.Add(
                new Lesson
                {
                    Topics = new List<Topic>
                    {
                        new Topic(),
                        new Topic {IsValid = true}
                    }
                });
        
            context.SaveChanges();
        }
        
        using (var context = new SomeDbContext())
        {
            var lesson = context.Lessons.Single();
            Console.WriteLine(lesson.Topics.Count);
        }
    }
}

public class SomeDbContext : DbContext
{
    public DbSet<Lesson> Lessons { get; set; }
    public DbSet<Topic> Topics { get; set; }

    private static ILoggerFactory ContextLoggerFactory
        => LoggerFactory.Create(b => b.AddConsole().SetMinimumLevel(LogLevel.Information));

    protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
        => optionsBuilder
            .UseSqlServer(Your.ConnectionString)
            .EnableSensitiveDataLogging()
            .UseLoggerFactory(ContextLoggerFactory);
}

[arti1zz]

@ajcvickers thanks for info. Hopefully we will see this upgrade!

[arti1zz]

I have found more delicate solution if you don't want to parse soft deleted entities ever.

on context OnModelCreating you could do something like

builder.Entity<Topic>().HasQueryFilter(x => x.IsValid);