如何合并Address与Person模型的不同类型Expression谓词？

Problem Statement #

I've built a predicate Expression<Func<Address, bool>> addressPred based on the Address model, and now need to merge it with a Person-based predicate Expression<Func<Person, bool>> personPred. Here are the model definitions:

public class Person 
{ 
    public string Name { get; set; } 
    public Address Address { get; set; } 
}
public class Address 
{ 
    public string StreetName { get; set; } 
}

For example, after modifying addressPred like addressPred = addressPred.And(a => a.StreetName == "Foo bar");, the merged predicate should be equivalent to combinedPred = combinedPred.And(p => p.Address.StreetName == "Foo bar"), and be typed as Expression<Func<Person, bool>>.

Additional Context: My actual models are much larger than this simplified example. The end goal is to first build out the full Address predicate, then build Person (and later Company, Customer, etc.) predicates with their own conditions, reusing the pre-built addressPred for the Address-related part of those parent model predicates. Since Address can have many filter conditions, I want to reuse this predicate across all parent models before making database calls for each. The combinedPred example above just shows the logical end result.

Solution #

This is a classic expression tree transformation scenario—we need to rewrite the Address-targeting predicate to reference the Address property of parent models, then merge it with existing parent predicates. Here's a clean, reusable implementation:

1. Custom Expression Visitor for Parameter Replacement #

First, create a visitor that replaces the Address parameter in the child expression with a reference to the parent model's Address property:

public class ParameterReplacingVisitor<TParent, TChild> : ExpressionVisitor
{
    private readonly ParameterExpression _parentParameter;
    private readonly PropertyInfo _childProperty;

    public ParameterReplacingVisitor(ParameterExpression parentParameter, Expression<Func<TParent, TChild>> childPropertySelector)
    {
        _parentParameter = parentParameter;
        // Extract the property info from the selector (e.g., p => p.Address gives us Person's Address property)
        _childProperty = (PropertyInfo)((MemberExpression)childPropertySelector.Body).Member;
    }

    protected override Expression VisitParameter(ParameterExpression node)
    {
        // Replace any TChild parameters with access to the parent's child property
        if (node.Type == typeof(TChild))
        {
            return Expression.MakeMemberAccess(_parentParameter, _childProperty);
        }
        return base.VisitParameter(node);
    }
}

2. Extension Methods for Predicate Merging #

Add extension methods to handle converting the child predicate to the parent's context and merging with existing parent predicates:

public static class ExpressionExtensions
{
    /// <summary>
    /// Merges a parent model predicate with a child model predicate (logical AND)
    /// </summary>
    public static Expression<Func<TParent, bool>> AndWithChildPredicate<TParent, TChild>(
        this Expression<Func<TParent, bool>> parentPredicate,
        Expression<Func<TChild, bool>> childPredicate,
        Expression<Func<TParent, TChild>> childPropertySelector)
    {
        // If parent predicate is null, just convert the child predicate to parent context
        if (parentPredicate == null)
        {
            return ConvertChildToParentPredicate<TParent, TChild>(childPredicate, childPropertySelector);
        }

        // Convert child predicate to work with the parent model
        var convertedChild = ConvertChildToParentPredicate<TParent, TChild>(childPredicate, childPropertySelector);

        // Combine parent and converted child predicates with AND
        var combinedBody = Expression.AndAlso(parentPredicate.Body, convertedChild.Body);

        // Return the new combined predicate with the parent's parameter
        return Expression.Lambda<Func<TParent, bool>>(combinedBody, parentPredicate.Parameters);
    }

    /// <summary>
    /// Converts a child model predicate to a parent model predicate targeting the child property
    /// </summary>
    private static Expression<Func<TParent, bool>> ConvertChildToParentPredicate<TParent, TChild>(
        Expression<Func<TChild, bool>> childPredicate,
        Expression<Func<TParent, TChild>> childPropertySelector)
    {
        var parentParam = Expression.Parameter(typeof(TParent), "parent");
        var visitor = new ParameterReplacingVisitor<TParent, TChild>(parentParam, childPropertySelector);

        // Rewrite the child predicate's body to use the parent's child property
        var rewrittenBody = visitor.Visit(childPredicate.Body);

        return Expression.Lambda<Func<TParent, bool>>(rewrittenBody, parentParam);
    }

    /// <summary>
    /// Helper method to chain AND conditions on the same type predicate
    /// </summary>
    public static Expression<Func<T, bool>> And<T>(this Expression<Func<T, bool>> predicate, Expression<Func<T, bool>> other)
    {
        if (predicate == null) return other;
        var invokedOther = Expression.Invoke(other, predicate.Parameters);
        return Expression.Lambda<Func<T, bool>>(Expression.AndAlso(predicate.Body, invokedOther), predicate.Parameters);
    }
}

3. Usage Example #

Here's how you'd implement your exact use case, plus reuse the addressPred for another model:

// Step 1: Build your reusable Address predicate
Expression<Func<Address, bool>> addressPred = a => true; // Start with a base predicate
addressPred = addressPred.And(a => a.StreetName == "Foo bar");
addressPred = addressPred.And(a => a.StreetName.Contains("Main"));
// Add as many Address conditions as needed here

// Step 2: Build your Person predicate with its own conditions
Expression<Func<Person, bool>> personPred = p => p.Name.StartsWith("Jane");

// Step 3: Merge the two predicates
var combinedPersonPred = personPred.AndWithChildPredicate(addressPred, p => p.Address);

// Step 4: Reuse the same addressPred for another model (e.g., Company)
public class Company 
{ 
    public string CompanyName { get; set; } 
    public Address Address { get; set; } 
}
Expression<Func<Company, bool>> companyPred = c => c.CompanyName.Contains("Corp");
var combinedCompanyPred = companyPred.AndWithChildPredicate(addressPred, c => c.Address);

Key Benefits #

• Full Reusability: The same addressPred works with any parent model that has an Address property—no duplicate filter logic.
• ORM Compatibility: The rewritten expression tree is fully translatable to SQL by EF Core and other ORMs, since it uses valid property access expressions.
• Clean, Maintainable Code: Build your Address filter logic once, then apply it wherever you need to filter parent models by their Address properties.

内容的提问来源于stack exchange，提问作者Sindre