how to handle EF core Include & ThenInclude

[michelguilhen]

how would you guys avoid Application Layer depending on Microsoft.EntityFrameworkCore when dealing with Include statements on your queries?

I'm working with the IApplicationDbContext interface and I don't see a way of handling these object JOIN situations without querying for each separately or handling this inside repositories.

[danielbecroft]

If you're using the IApplicationDbContext<> as a dependency, IMO there's no additional "layer violation" by adding a dependency on the Microsoft.EntityFrameworkCore package/namespace for the purposes of the .Include / .ThenInclude extension methods. It's not exposing any additional information about the internals about the data persistence.

[neozhu]

@michelguilhen
I share my code and project:https://github.com/neozhu/CleanArchitectureWithBlazorServer, hope this helps:

public abstract class Specification<T> : ISpecification<T> where T : class, IEntity
{
    public Expression<Func<T, bool>> Criteria { get; set; }
    public List<Func<IQueryable<T>, IIncludableQueryable<T, object>>> Includes { get; } = new();
    public List<string> IncludeStrings { get; } = new();

    protected virtual void AddInclude(Func<IQueryable<T>, IIncludableQueryable<T, object>> includeExpression)
    {
        Includes.Add(includeExpression);
    }

    protected virtual void AddInclude(string includeString)
    {
        IncludeStrings.Add(includeString);
    }

    public Expression<Func<T, bool>> And(Expression<Func<T, bool>> query)
    {
        return Criteria = Criteria == null ? query : Criteria.And(query);
    }

    public Expression<Func<T, bool>> Or(Expression<Func<T, bool>> query)
    {
        return Criteria = Criteria == null ? query : Criteria.Or(query);
    }
}


public class DocumentsWithPaginationQuery : PaginationFilter, ICacheableRequest<PaginatedData<DocumentDto>>
{

    public DocumentListView ListView { get; set; } = DocumentListView.All;
    public string TenantId { get; set; }
    public DocumentsWithPaginationQuery(string tenantId)
    {
        TenantId = tenantId;
    }
    public string CacheKey => $"{nameof(DocumentsWithPaginationQuery)},{this},{TenantId}";
    public MemoryCacheEntryOptions? Options => DocumentCacheKey.MemoryCacheEntryOptions;

}
public class DocumentsQueryHandler : IRequestHandler<DocumentsWithPaginationQuery, PaginatedData<DocumentDto>>
{
    private readonly ICurrentUserService _currentUserService;
 
    private readonly IApplicationDbContext _context;
    private readonly IMapper _mapper;

    public DocumentsQueryHandler(
        ICurrentUserService currentUserService,
  
        IApplicationDbContext context,
        IMapper mapper
        )
    {
        _currentUserService = currentUserService;
        _context = context;
        _mapper = mapper;
    }
    public async Task<PaginatedData<DocumentDto>> Handle(DocumentsWithPaginationQuery request, CancellationToken cancellationToken)
    {
        var userid = _currentUserService.UserId;
        var data = await _context.Documents
            .Specify(new DocumentsQuery(userid,request.TenantId,request.Keyword))
            .OrderBy($"{request.OrderBy} {request.SortDirection}")
            .ProjectTo<DocumentDto>(_mapper.ConfigurationProvider)
            .PaginatedDataAsync(request.PageNumber, request.PageSize);

        return data;
    }
    
    internal class DocumentsQuery : Specification<Document>
    {
        public DocumentsQuery(string userId,string tenantId,string? keyword)
        {
            AddInclude(x=>x.Include(x=>x.Owner).ThenInclude(x=>x.Superior));
            AddInclude(x => x.Include(x=>x.Editor).ThenInclude(x=>x.Superior));
            this.Criteria = p => (p.CreatedBy == userId && p.IsPublic == false) || p.IsPublic == true;
            And(x => x.TenantId == tenantId);
            if (!string.IsNullOrEmpty(keyword))
            {
                And(x => x.Title.Contains(keyword) || x.Description.Contains(keyword) || x.Content.Contains(keyword));
            }
        }
    }

    
}