多对多使用 LinqKit 和 EF Core 和 Generic 类

Question

I'm currently converting an EF project to EF Core but I don't know how or whether it is possible to:

a) Use LinqKit on Many-To-Many with EF Core

b) Use a) with a Generic class

I'm currently using the following class:

    protected virtual IQueryable<TEntity> GetQueryable(
        Expression<Func<TEntity, bool>> filter = null,
        Func<IQueryable<TEntity>, IOrderedQueryable<TEntity>> orderBy = null,
        string includeProperties = null,
        bool isCollection = false,
        int? skip = null,
        int? take = null)
    {
        IQueryable<TEntity> query = this.Context.Set<TEntity>();

        if (filter != null)
        {
            query = query.AsExpandable().Where(filter);
        }

        if (includeProperties != null)
        {
            foreach (var includeProperty in includeProperties.Split
                (new[] { ',' }, StringSplitOptions.RemoveEmptyEntries))
            {
                query = query.Include(includeProperty);
            }
        }

        if (orderBy != null)
        {
            query = orderBy(query);
        }

        if (skip.HasValue)
        {
            query = query.Skip(skip.Value);
        }

        if (take.HasValue)
        {
            query = query.Take(take.Value);
        }

        return query;
    }

In EF 6, I would set the type of my generic class to a main Entity I wanted to deal with and if it had a many to many, I would simply set the IncludeProperties to the child Entity.

For example:

var test = GetQueryable<Company>(null, "Users");

This would returns all companies and return all the users associated with each relevant company.

LinqKit would then come in to add additional filters, orders, etc...

But I cannot figure out how to use this with a Many to Many relation in EF Core.

I've seen an example where you do something similar to this:

this.Context.Companies.Include("CompanyUsers")
                      .ThenInclude("Users")
                      .ToListAsynch()

And the above looks like what I need but I need to use it to be generic and I need to apply filters with LinqKit or some other way but I need to set filters, sorting, paging, etc... dynamically.

Any ideas?

Thanks

UPDATE-1:

My many-to-many relation class is defined as follows:

public class CompanyUsers
{
    public Guid UserId { get; set; }

    public User User { get; set; }

    public Guid CompanyId { get; set; }

    public Company Company { get; set; }
}

The reason I'm adding this is that while my table of users is called "Users" the navigation property is called User and as suggested by Dennis, I should specify the Many-To-Many class (CompanyUsers) followed by the navigation property (User) so rather than being:

var test = GetQueryable<Company>(null, "CompanyUsers.Users");

it should be defined as instead:

var test = GetQueryable<Company>(null, "CompanyUsers.User");

Note the s was removed to match the navigation property rather than the table.

Answer 1

The simplest solution would be to use the string overload of the Include .*

var test = GetQueryable<Company>(null, "CompanyUsers.User");

*I don't recommend using magic strings. You should consider writing an method that returns this based on the models properties.