我如何使用表达式 <Func<T> &gt;在linq语句中，如果我的导航属性是单个项目？

Question

I have an expression that maps the database object from another system to a standard object that I can use across any system.

Ex:

private static Expression<Func<excessive_location, MyLocation>> LocationMap =
    l => new MyLocation()
        {
            Id = l.unique_id,
            Code = l.location_code,
            Active = l.active

            ...Other properties
        }

This works exactly as I expect in the following situation

public IEnumerable<MyLocation> GetActiveLocations()
        {
            return otherSystem.location_table
                .Select(LocationMap)
                .Where(l => l.Active == true)
                .ToList();
        }

But I cant seem to figue out a way to make it work as part of another expression

private static Expression<Func<excessive_user, User>> UserMap =
    e => new User()
        {
            Id = e.unique_id,
            FirstName = e.fname,
            LastName = e.lname,
            Location = e.excessive_location
                .Select(LocationMap)  // will not work since
                                      // e.excessive_location is not a collection
        };

I know I can compile it to a function but then it will have to execute for every user out of thousands. What is the proper way to make this work?

Answer 1

In order to achieve the goal, you'll need some expression helpers.

Let me first show you the resulting code:

private static Expression<Func<excessive_location, MyLocation>> LocationMap =
    l => new MyLocation()
    {
        Id = l.unique_id,
        Code = l.location_code,
        Active = l.active
    };

private static Expression<Func<excessive_user, User>> UserMap =
    Utils.Expr((excessive_user u) => new User
    {
        Id = u.unique_id,
        FirstName = u.fname,
        LastName = u.lname
    })
    .BindMemberInit(u => u.Location, 
        Utils.Expr((excessive_user u) => u.excessive_location).Bind(LocationMap));

Now the helpers.

The first one called Expr is a simple method that allows you to define expression without local variable.

The second one called Bind allows you to bind expression to another expression accessor.

So having

(excessive_user u) => u.excessive_location

and

(excessive_location l) => new MyLocation { Id = l.unique_id, .... }

you can make

(excessive_user u) => new MyLocation { Id = u.excessive_location.inique_id, ...}

The third one called BindMemberInit allows you to add new member initialization to the existing new { ... } expression.

The last one called ReplaceParameter allows you to replace expression parameter with another expression.

Here is the full code:

public static class Utils
{
    public static Expression<Func<T, TResult>> Expr<T, TResult>(Expression<Func<T, TResult>> e) { return e; }

    public static Expression<Func<TOuter, TResult>> Bind<TOuter, TInner, TResult>(this Expression<Func<TOuter, TInner>> source, Expression<Func<TInner, TResult>> resultSelector)
    {
        var body = resultSelector.Body.ReplaceParameter(resultSelector.Parameters[0], source.Body);
        return Expression.Lambda<Func<TOuter, TResult>>(body, source.Parameters);
    }

    public static Expression<Func<TSource, TTarget>> BindMemberInit<TSource, TTarget, TMember, TValue>(this Expression<Func<TSource, TTarget>> expression, Expression<Func<TTarget, TMember>> member, Expression<Func<TSource, TValue>> value)
    {
        var binding = Expression.Bind(
            ((MemberExpression)member.Body).Member,
            value.Body.ReplaceParameter(value.Parameters[0], expression.Parameters[0]));
        var body = (MemberInitExpression)expression.Body;
        return expression.Update(body.Update(body.NewExpression, body.Bindings.Concat(new[] { binding })), expression.Parameters);
    }

    static Expression ReplaceParameter(this Expression expression, ParameterExpression source, Expression target)
    {
        return new ParameterReplacer { Source = source, Target = target }.Visit(expression);
    }

    class ParameterReplacer : ExpressionVisitor
    {
        public ParameterExpression Source;
        public Expression Target;
        protected override Expression VisitParameter(ParameterExpression node)
        {
            return node == Source ? Target : base.VisitParameter(node);
        }
    }
}

Answer 2

So what we need here is a two methods. One to compose one expression with another, that is to take an expression that computes a value, another expression that takes that output and computes a new value, and creates a new expression that takes the input of the first and produces the output of the second, using both expressions.

We'll start by creating an expression to get the location from a user:

Expression<Func<excessive_user, excessive_location>> locationProjection = 
    user => user.excessive_location;

Then we'll compose that with your expression to turn the location into a MyLocation :

Expression<Func<excessive_user, MyLocation>> mappedLocationProject = 
    locationProjection.Compose(LoactionMap);

Next we'll need a very similar, but slightly different method that can combine two expressions together, being able to take an expression, and another that takes the same input, and the output of the original, and produces a new output.

This method would allow us to write the following:

mappedLocationProject.Combine((user, location) => new User()
        {
            Id = user.unique_id,
            FirstName = user.fname,
            LastName = user.lname,
            Location = location
        };

Here's the method to compose expressions:

public static Expression<Func<TFirstParam, TResult>>
    Compose<TFirstParam, TIntermediate, TResult>(
    this Expression<Func<TFirstParam, TIntermediate>> first,
    Expression<Func<TIntermediate, TResult>> second)
{
    var param = Expression.Parameter(typeof(TFirstParam), "param");

    var newFirst = first.Body.Replace(first.Parameters[0], param);
    var newSecond = second.Body.Replace(second.Parameters[0], newFirst);

    return Expression.Lambda<Func<TFirstParam, TResult>>(newSecond, param);
}

And here's the implementation of Combine :

public static Expression<Func<TFirstParam, TResult>>
    Combine<TFirstParam, TIntermediate, TResult>(
    this Expression<Func<TFirstParam, TIntermediate>> first,
    Expression<Func<TFirstParam, TIntermediate, TResult>> second)
{
    var param = Expression.Parameter(typeof(TFirstParam), "param");

    var newFirst = first.Body.Replace(first.Parameters[0], param);
    var newSecond = second.Body.Replace(second.Parameters[0], param)
        .Replace(second.Parameters[1], newFirst);

    return Expression.Lambda<Func<TFirstParam, TResult>>(newSecond, param);
}

They both use the following method to replace all instances of one expression with another:

internal class ReplaceVisitor : ExpressionVisitor
{
    private readonly Expression from, to;
    public ReplaceVisitor(Expression from, Expression to)
    {
        this.from = from;
        this.to = to;
    }
    public override Expression Visit(Expression node)
    {
        return node == from ? to : base.Visit(node);
    }
}
public static Expression Replace(this Expression expression,
    Expression searchEx, Expression replaceEx)
{
    return new ReplaceVisitor(searchEx, replaceEx).Visit(expression);
}