Comment puis-je ajouter une expression Where générée dynamiquement pour un objet navigable dans ma requête Linq-To-SQL?

Mon client aimerait avoir une méthode d'envoi sur un tableau de valeurs de champ (chaîne), valeur (chaîne) et comparaison (enum) afin de récupérer leurs données .

.Lambda #Lambda3<System.Func`2[ClassroomEntity,System.Boolean]>(ClassroomEntity $var1)
{
    $var1.LeadTeacherName == "Sharon Candelariatest"
}

Mon entreprise et moi n'avons jamais tenté de faire quelque chose de tel auparavant, c'est donc à mon équipe de trouver une solution viable. C'est le résultat de travailler sur une solution avec une semaine ou deux de recherche.

Ce qui fonctionne: Partie 1

J'ai créé un service qui est capable de récupérer les données de notre tableau Salle de classe . La récupération des données est effectuée dans Entity Framework Core au moyen de LINQ-to-SQL. La façon dont j'ai écrit ci-dessous fonctionne si l'un des champs fournis dans le filtre n'existe pas pour Classroom mais existe pour son organisation associée (le client voulait être capable de rechercher parmi les adresses des organisations) et a une propriété navigable.

.Call Microsoft.EntityFrameworkCore.EntityFrameworkQueryableExtensions.AsNoTracking(.Call System.Linq.Queryable.Where(
        .Call System.Linq.Queryable.Where(
            .Constant<Microsoft.EntityFrameworkCore.Query.Internal.EntityQueryable`1[ClassroomEntity]>(Microsoft.EntityFrameworkCore.Query.Internal.EntityQueryable`1[ClassroomEntity]),
            '(.Lambda #Lambda1<System.Func`2[ClassroomEntity,System.Boolean]>)),
        '(.Lambda #Lambda2<System.Func`2[ClassroomEntity,System.Boolean]>)))

.Lambda #Lambda1<System.Func`2[ClassroomEntity,System.Boolean]>(ClassroomEntity $x)
{
    ($x.ClassroomId).HasValue
}

.Lambda #Lambda2<System.Func`2[ClassroomEntity,System.Boolean]>(ClassroomEntity $x)
{
    ($x.Organization).City == "Bronx"
}

Ce qui fonctionne: partie 2

La BuildExpression qui existe dans le code est quelque chose que j'ai créé en tant que tel (avec de la place pour l'expansion).

IQueryable<ClassroomEntity>classroomQuery = ClassroomEntity.Where(x => x.ClassroomId.HasValue).Where(x => x.Organization.City == "Atlanta").AsNoTracking();

Le problème / Se déplacer vers ma question

Alors que la jointure interne de la salle de classe et de l ' organisation fonctionne, je préfère pas besoin d'extraire un deuxième ensemble d'entités pour vérifier les valeurs qui sont navigables. Si je saisis une Ville comme nom de filtre, je ferais normalement ceci:

classroomQuery = classroomQuery.Where(x => x.Organization.BuildExpression(filter.Name, filter.Value, filter.Compare));

Cela ne fonctionne pas vraiment ici. P >

J'ai essayé plusieurs méthodes différentes pour obtenir ce que je recherche:

• Une fonction compilée qui renverrait Func , mais lorsqu'elle est passée via LINQ-to-SQL, la requête ne l'inclut pas.
• Je l'ai changé en une expression >, mais mon retour n'a pas renvoyé de valeur booléenne comme j'ai tenté de l'implémenter, donc cela n'a pas fonctionné.
• J'ai changé la façon dont j'implémentais la propriété de navigation, mais aucune de mes fonctions ne lirait la valeur correctement.

En gros, existe-t-il un moyen d'implémenter ce qui suit de manière à ce que LINQ-to-SQL à partir d'Entity Framework Core fonctionne? D'autres options sont également les bienvenues.

classroomQuery = classroomQuery.Where(x => x.Organization.City == "Atlanta");

Edit 01:

Lorsque vous utilisez l'expression sans le générateur dynamique comme ceci:

public static IQueryable<T> BuildExpression<T>(this IQueryable<T> source, string columnName, string value, QueryableFilterCompareEnum? compare = QueryableFilterCompareEnum.Equal) {
    var param = Expression.Parameter(typeof(T));

    // Get the field/column from the Entity that matches the supplied columnName value
    // If the field/column does not exists on the Entity, throw an exception; There is nothing more that can be done
    MemberExpression dataField;
    try {
        dataField = Expression.Property(param, propertyName);
    } catch (ArgumentException ex) {
        if (ex.ParamName == "propertyName") {
            throw new ArgumentException($"Queryable selection does not have a \"{propertyName}\" field.", ex.ParamName);
        } else {
            throw new ArgumentException(ex.Message);
        }
    }

    ConstantExpression constant = !string.IsNullOrWhiteSpace(value)
        ? Expression.Constant(value.Trim(), typeof(string))
        : Expression.Constant(value, typeof(string));

    BinaryExpression binary = GetBinaryExpression(dataField, constant, compare);
    Expression<Func<T, bool>> lambda = (Expression<Func<T, bool>>)Expression.Lambda(binary, param)
    return source.Where(lambda);
}

private static Expression GetBinaryExpression(MemberExpression member, ConstantExpression constant, QueryableFilterCompareEnum? comparisonOperation) {
    switch (comparisonOperation) {
        case QueryableFilterCompareEnum.NotEqual:
            return Expression.Equal(member, constant);
        case QueryableFilterCompareEnum.GreaterThan:
            return Expression.GreaterThan(member, constant);
        case QueryableFilterCompareEnum.GreaterThanOrEqual:
            return Expression.GreaterThanOrEqual(member, constant);
        case QueryableFilterCompareEnum.LessThan:
            return Expression.LessThan(member, constant);
        case QueryableFilterCompareEnum.LessThanOrEqual:
            return Expression.LessThanOrEqual(member, constant);
        case QueryableFilterCompareEnum.Equal:
        default:
            return Expression.Equal(member, constant);
        }
    }
}

Le débogage se lit comme suit:

public async Task<IEnumerable<IExportClassroom>> GetClassroomsAsync(
    IEnumerable<QueryableFilter> queryableFilters = null) {
    var filters = queryableFilters?.ToList();

    IQueryable<ClassroomEntity> classroomQuery = ClassroomEntity.All().AsNoTracking();

    // The organization table may have filters searched against it
    // If any are, the organization table should be inner joined to all filters are used
    IQueryable<OrganizationEntity> organizationQuery = OrganizationEntity.All().AsNoTracking();
    var joinOrganizationQuery = false;

    // Loop through the supplied queryable filters (if any) to construct a dynamic LINQ-to-SQL queryable
    if (filters?.Count > 0) {
        foreach (var filter in filters) {
            try {
                classroomQuery = classroomQuery.BuildExpression(filter.Name, filter.Value, filter.Compare);
            } catch (ArgumentException ex) {
                if (ex.ParamName == "propertyName") {
                    organizationQuery = organizationQuery.BuildExpression(filter.Name, filter.Value, filter.Compare);
                    joinOrganizationQuery = true;
                } else {
                    throw new ArgumentException(ex.Message);
                }
            }
        }
    }

    // Inner join the classroom and organization queriables (if necessary)
    var query = joinOrganizationQuery
        ? classroomQuery.Join(organizationQuery, classroom => classroom.OrgId, org => org.OrgId, (classroom, org) => classroom)
        : classroomQuery;

    query = query.OrderBy(x => x.ClassroomId);

    IEnumerable<IExportClassroom> results = await query.Select(ClassroomMapper).ToListAsync();
    return results;
}

J'ai essayé avec le constructeur dynamique d'obtenir l'enseignant de Classroom, ce qui m'a donné un débogage de:

public class QueryableFilter {
    public string Name { get; set; }
    public string Value { get; set; }
    public QueryableFilterCompareEnum? Compare { get; set; }
}

Je n'arrive toujours pas à comprendre comment obtenir ($ var1.Organization) comme entité à partir de laquelle je lis. p >