Query over interface properties using EntityFramework and LinqKit

Question

I'm using EntityFramework and LinqKit to build expressions trees which get translated into SQL. Also we use the specification pattern to organize our queries.

There is a need in almost all of our domain objects to execute a query by description, but in some of those classes the property is called "Name", in others "Description", etc.

So initially was defined a interface as follow:

public interface IDescritible
{
    string Description { get; }
}

The problem appeared when I tried to use it implemented explicitly in a class and made a generic query upon that:

public class Foo : IDescritible
{
    public string Name { get; set; }

    string IDescritible.Description
    {
        get { return this.Name; }
    }
}

public class DescriptionMatch<T> : AbstractSpecification<T> 
    where T : IDescritible
{
    public string Query { get; set; }

    public DescriptionMatch(string query)
    {
        this.Query = query;
    }

    public override Expression<Func<T, bool>> IsSatisfiedBy()
    {
        return x => x.Description.Contains(Query);
    }
}

When run, the EntityFramework is unable to translate the property get (a method call) into a SQL expression.

Then I tried to define a Expression in the class as follows:

public interface IDescritible<T> where T: IDescritible<T>
{
    Expression<Func<T, string>> DescriptionExpression { get; }
}

public class Foo : IDescritible<Foo>
{
    public string Name { get; set; }

    public Expression<Func<Foo, string>> DescriptionExpression
    {
        get { return x => x.Name; }
    }
}

public class DescriptionMatch<T> : AbstractSpecification<T> where T : IDescritible<T>
{
    public string Query { get; set; }

    public DescriptionMatch(string query)
    {
        this.Query = query;
    }

    public override Expression<Func<T, bool>> IsSatisfiedBy()
    {
        Expression<Func<T, bool>> combinedExpression = x => x.DescriptionExpression.Invoke(x).Contains(this.Query);
        return combinedExpression.Expand();
    }
}

But when it executes the .Expand() a exception is thrown: Unable to cast object of type 'System.Linq.Expressions.PropertyExpression' to type 'System.Linq.Expressions.LambdaExpression'.

Then I found out that LinqKit only support expanding local defined expressions (as stated on this question) and that there are some unoficial code write to solve those issues (answers on this question).

But when I modified the LinqKit library to try either one of the proposed solutions in second question it started to throw: variable 'x' of type 'Foo' referenced from scope '', but it is not defined.

Maybe that was caused by the fact that I don't have a instance of Foo yet? Only got the generic type parameter, and that's why I can't define my expression on a local variable. Maybe there is a way to define as a static expression somehow "attached" into class? But then I would not be able to use it in a generic query, there will be no interface...

There is a way to modify LinqKit so I can build expressions defined on a explicit implementation of a interface? Or there is another way to make a generic query upon properties explicitly implemented? Or any other solution or things to look into?

There is no need to use neither LinqKit or specification pattern for that, but EntityFramework is mandatory, what is important is to have a interface/any other way that support "pointing out" which property is the description property and make a generic Expression upon that.

Thank you in advance!

Answer 1

The easiest way to do it is to make the following change

public class DescriptionMatch<T> : AbstractSpecification<T> where T : IDescritible<T>, new()

Then you can get an instance by simply newing up a T (which EF), using the expression and otherwise discarding the object

public interface IDescritible<T> where T : IDescritible<T>
{
    Expression<Func<T, string>> DescriptionExpression { get; }
}

public class Foo : IDescritible<Foo>
{
    public string Name { get; set; }

    public Expression<Func<Foo, string>> DescriptionExpression
    {
        get { return x => x.Name; }
    }
}

public abstract class AbstractSpecification<T>
{
    public abstract Expression<Func<T, bool>> IsSatisfiedBy();
}

public class DescriptionMatch<T> : AbstractSpecification<T> 
    where T : IDescritible<T>, new()
{
    public string Query { get; set; }

    public DescriptionMatch(string query)
    {
        this.Query = query;
    }

    public override Expression<Func<T, bool>> IsSatisfiedBy()
    {
        Expression<Func<T, string>> lambda = new T().DescriptionExpression;
        return Expression.Lambda<Func<T, bool>>(
            Expression.Call(
                lambda.Body,
                "Contains",
                Type.EmptyTypes,
                Expression.Constant(
                    this.Query,
                    typeof(string)
                )
            ),
            lambda.Parameters
        );
    }
}

public class ExpressionReplacer : ExpressionVisitor
{
    private readonly Expression _toBeReplaced;
    private readonly Expression _replacement;

    public ExpressionReplacer(Expression toBeReplaced, Expression replacement)
    {
        if (toBeReplaced.Type != replacement.Type)
        {
            throw new ArgumentException();
        }
        this._toBeReplaced = toBeReplaced;
        this._replacement = replacement;
    }

    public override Expression Visit(Expression node)
    {
        return Object.ReferenceEquals(node, this._toBeReplaced) ? this._replacement : base.Visit(node);
    }
}