Lazy Loading EF Core, upload daughter entities and daughters?

Question

I have a Web Api I’m developing using the DotNet Core and EF Cor but is with the Lazy Loading active, only that in some cases I need to load the entities daughters and daughters of daughters, I created a generic repository to perform CRUD on the bench, I can carry the daughters, but the daughters of daughters can’t.

The generic Get function that carries daughters.

public IQueryable<T> Get<T>(Expression<Func<T, bool>> predicate, params string[] include) 
     where T : class
{
        IQueryable<T> result = this._context.Set<T>().Where(predicate);

        foreach (string item in include)
        {
            result = result.Include(item).AsQueryable();
        }

        return result.AsQueryable();
}

Using this function would be

var entidade this.repository.Get<Entity>(x => x.Id == 1, "Filha1", "Filha2")
                 .FirstOrDefault();

entidade.Filha1 // Carrega Corretamente
entidade.Filha2 // Carrega Corretamente
entidade.Filha1.SubFilha1 // Quero conseguir carregar esse nível da entidade

Implementation of the Generic Repository:

using API.Model.Context;
using API.Model.Entities;
using Microsoft.EntityFrameworkCore;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Linq.Expressions;

namespace API.Model.Repositories
{
    public class Repository : IDisposable, IRepository
    {
        private readonly ApiContext _context;

        public Repository(ApiContext context)
        {
            this._context = context;
        }

        public void Add<T>(T obj) where T : class
        {
            this._context.Set<T>().Add(obj);
        }

        public void Delete<T>(Func<T, bool> predicate) where T : class
        {
            this._context.Set<T>().Where(predicate).ToList()
                .ForEach(del => this._context.Set<T>().Remove(del));
        }

        public void Dispose()
        {
            this._context.Dispose();
        }

        public void Edit<T>(T obj) where T : class
        {
            this._context.Entry<T>(obj).State = EntityState.Modified;
        }

        public int ExecuteSql(string psSql, params object[] poParams)
        {
            return _context.Database.ExecuteSqlCommand(psSql, poParams);
        }

        public T Find<T>(params object[] key) where T : class
        {
            return this._context.Set<T>().Find(key);
        }

        public IQueryable<T> Get<T>(Expression<Func<T, bool>> predicate) 
               where T : class
        {
            return this._context.Set<T>().Where(predicate)
                       .AsQueryable();
        }

        public IQueryable<T> Get<T>(Expression<Func<T, bool>> predicate,
                                    params string[] include)
             where T : class
        {
            IQueryable<T> result = this._context.Set<T>().Where(predicate);

            foreach (string item in include)
            {

                result = result.Include(item).AsQueryable();
            }

            return result.AsQueryable();
        }

        public IQueryable<T> GetAll<T>() where T : class
        {
            return this._context.Set<T>();
        }

        public void Save()
        {
            this._context.SaveChanges();
        }
    }
}

Parent Entity

    [Table("Booking")]
    public class Booking
    {
        public int Id { get; set; }
        public virtual ICollection<RoomStay> RoomStay { get; set; }
    }

Entity Filha

    [Table("RoomStay")]
    public class RoomStay
    {
        public int Id { get; set; }
        public int BookingId { get; set; }
        [ForeignKey("BookingId")]
        public virtual Booking Booking { get; set; }

        public int? RoomTypeId { get; set; }
        [ForeignKey("RoomTypeId")]
        public virtual RoomType RoomType { get; set; }

        public virtual ICollection<RoomStayGuest> RoomStayGuest { get; set;                 }
        public virtual ICollection<RoomStayFnrh> RoomStayFnrh { get; set; }
    }

I need to upload Roomtype entities and Roomstayguest and Roomstayfnrh collections

Answer 1

To include several related data levels, use the method ThenInclude().

Examples

_{Entity Framework - Dados Relacionados}

var example = context.Parent
                            .Include(x => x.Child)
                            .ThenInclude(g => g.Grandson)

_{Entity Framework - Chaining of related data}

var example = context.Parent
                            .Include(x => x.Child)
                            .ThenInclude(g => g.Grandson)
                            .ThenInclude(gg => gg.GreatGrandson)

_{Generic method}

public IQueryable<T> Get<T>(Expression<Func<T, bool>> predicate, Func<IQueryable<T>, IIncludableQueryable<T, object>> include = null) 
     where T : class
{
        IQueryable<T> result = this._context.Set<T>().Where(predicate);

        if (include != null)
           result = include(result);

        return result.AsQueryable();
}

_{Use of the generic method}

var example = this.repository.Get<Entity>(
                                           x => x.Id == 1, 
                                           r => r
                                                     .Include(c => c.Child)
                                                     .ThenInclude(g => g.Grandson))
                                                     .FirstOrDefault();

For more information about loading related data, visit: Loading of Related Data

Answer 2

You just put the relationships apart by one point (.), example:

var entidade this.repository.Get<Entity>(x => x.Id == 1, "Filha1.SubFilha1")
                            .FirstOrDefault();

you won’t even need to change the code of repository is just pass this way the name of relationships Filha1.SubFilha1 and so on.

The code Include and Theninclude would be ideal, but, you would have to change the code of your repository so that it can support these methods with some logic other than the current one.

I was asked by @Gabrielcolleta if this works, in the version Entity Framework Core and it’s up to an interesting point to say, yes this works perfectly and is contained in the most current version which is one of the things brought up from the previous version, this method Include with Text (string) solves the relationships of relationships, and I believe it is useful to solve this problem. This Include with Text (string) doesn’t have the ThenInclude as is used in the other which is an expression Lambda.

I need to upload Roomtype entities and Roomstayguest and Roomstayfnrh collections

var entidade this.repository
          .Get<Entity>(x => x.Id == 1, 
                       "RoomStay.RoomType", 
                       "RoomStay.RoomStayGuest",
                       "RoomStay.RoomStayFnrh")
          .FirstOrDefault();

Tests performed with Entity Framework Core 2.0.1

_References:

• Entity Framework Loading Related Entities
• Loading of related data
• Reading Related data - EF Core with ASP.NET Core MVC tutorial (6 of 10)
• When to use Include() with Entity Framework?