Jak zmienić typ w drzewie wyrażeń?

Question

mam metody takie jak to:

private bool Method_1(Expression<Func<IPerson, bool>> expression) 
{ 
    /* Some code that will call Method_2 */ 
} 

W tej metodzie chcę zmienić typ innemu typowi IPerson. Chcę wywołać inną metodę, która wygląda tak:

private bool Method_2(Expression<Func<PersonData, bool>> expression) 
{ 
    /* Some code */ 
} 

Więc w method_1 muszę zmienić IPerson do PersonData. Jak mogę to zrobić?

Edit:

Kiedy zadzwonić: Method_1(p => p.Id == 1) chcę „zapisz” warunek (p.Id == 1), ale chcę, aby wykonać ten warunek na innego rodzaju, a mianowicie IPerson. Więc muszę zmieniać ekspresję lub utworzyć nowe wyrażenie z IPerson

EDIT II:

Dla tych, którzy są zainteresowani, to jest (na razie) moje rozwiązanie:

private class CustomExpressionVisitor<T> : ExpressionVisitor 
{ 
    ParameterExpression _parameter; 

    public CustomExpressionVisitor(ParameterExpression parameter) 
    { 
     _parameter = parameter; 
    } 

    protected override Expression VisitParameter(ParameterExpression node) 
    { 
     return _parameter; 
    } 

    protected override Expression VisitMember(MemberExpression node) 
    { 
     if (node.Member.MemberType == System.Reflection.MemberTypes.Property) 
     { 
      MemberExpression memberExpression = null; 
      var memberName = node.Member.Name; 
      var otherMember = typeof(T).GetProperty(memberName); 
      memberExpression = Expression.Property(Visit(node.Expression), otherMember); 
      return memberExpression; 
     } 
     else 
     { 
      return base.VisitMember(node); 
     } 
    } 
} 

I jest tak, jak go używać:

public virtual bool Exists(Expression<Func<Dto, bool>> expression) 
{ 
    var param = Expression.Parameter(typeof(I)); 
    var result = new CustomExpressionVisitor<I>(param).Visit(expression.Body); 
    Expression<Func<I, bool>> lambda = Expression.Lambda<Func<I, bool>>(result, param); 

    bool exists = _repository.Exists(lambda); 
    return exists; 
} 

Answer 1

to proste, jeśli użyć .net 4 (zmiana: jak zauważono w komentarzu ExpressionVisitor został dodany w wersji 4 nie 4.5) wymagałoby to trochę googlowania dla starszych frameworków:

Jest kilka założeń, ale myślę, że są one ważne dla scenariusza DTO i Entity - właściwości, do których dostęp uzyskałem, muszą być zgodne.

class PersonData 
{ 
    public bool Prop { get; set; } 
} 

interface IPerson 
{ 
    bool Prop { get; set; } 
} 

w .NET 4 jest ExpressionVisitor klasa zdefiniowana sprawia, że ​​to o wiele łatwiejsze, jeśli używasz starszej potem trzeba napisać lub znaleźć implementacja IT:

class Visitor<T> : ExpressionVisitor 
{ 
    ParameterExpression _parameter; 

    //there must be only one instance of parameter expression for each parameter 
    //there is one so one passed here 
    public Visitor(ParameterExpression parameter) 
    { 
     _parameter = parameter; 
    } 

    //this method replaces original parameter with given in constructor 
    protected override Expression VisitParameter(ParameterExpression node) 
    { 
     return _parameter; 
    } 

    //this one is required because PersonData does not implement IPerson and it finds 
    //property in PersonData with the same name as the one referenced in expression 
    //and declared on IPerson 
    protected override Expression VisitMember(MemberExpression node) 
    { 
     //only properties are allowed if you use fields then you need to extend 
     // this method to handle them 
     if (node.Member.MemberType != System.Reflection.MemberTypes.Property) 
      throw new NotImplementedException(); 

     //name of a member referenced in original expression in your 
     //sample Id in mine Prop 
     var memberName = node.Member.Name; 
     //find property on type T (=PersonData) by name 
     var otherMember = typeof(T).GetProperty(memberName); 
     //visit left side of this expression p.Id this would be p 
     var inner = Visit(node.Expression); 
     return Expression.Property(inner, otherMember); 
    } 
} 

Dowód koncepcji:

class Program 
{ 
    static void Main() 
    { 
     //sample expression 
     Expression<Func<IPerson, bool>> expression = x => x.Prop; 

     //parameter that will be used in generated expression 
     var param = Expression.Parameter(typeof(PersonData)); 
     //visiting body of original expression that gives us body of the new expression 
     var body = new Visitor<PersonData>(param).Visit(expression.Body); 
     //generating lambda expression form body and parameter 
     //notice that this is what you need to invoke the Method_2 
     Expression<Func<PersonData, bool>> lambda = Expression.Lambda<Func<PersonData, bool>>(body, param); 
     //compilation and execution of generated method just to prove that it works 
     var boolValue = lambda.Compile()(new PersonData()); 
    } 
} 

Należy zauważyć, że działa to w przypadku prostych wyrażeń. Jeśli potrzebujesz obsługi x.Prop.Prop1 < 3, musisz rozszerzyć to dalej.