重写的表达式的类型

问题描述 投票:1回答:2

是否有可能动态地改写的Expression<T>,与另一种类型代替T的元素?

例如,与在下列情况下DocumentTypeA替换DocumentTypeB

  • Expression<Func<DocumentTypeA, bool>> expression = m => m.Details.Id == "an-id"
  • Expression<Func<DocumentTypeA, bool>> expression = m => m.Details.Id == "an-id" && m.AnInt == 42
  • Expression<Func<DocumentTypeA, bool>> expression = m => m.AString == "I'm a string"

我需要作出关于在运行时使用什么类型的,而不是编译时的决定。

另外值得一提的是,DocumentTypeADocumentTypeB不互相关联,除了它们的性质是相同的。

最终的结果将是重新处理它们,所以它们现在的样子

  • Expression<Func<DocumentTypeB, bool>> expression = m => m.Details.Id == "an-id"
  • Expression<Func<DocumentTypeB, bool>> expression = m => m.Details.Id == "an-id" && m.AnInt == 42
  • Expression<Func<DocumentTypeB, bool>> expression = m => m.AString == "I'm a string"

所以表达式的实际比较部分保持不变,只有顶层类型发生了变化。

c# lambda
2个回答
3
投票

您可以使用ExpressionVisitor更换型。

class ParameterRewriter<T, U> : ExpressionVisitor
{
    protected override Expression VisitParameter(ParameterExpression node)
    {
        if (node.Type.Equals(typeof(T)))
        {
            return Expression.Parameter(typeof(U), node.Name);
        }

        return base.VisitParameter(node);
    }

    protected override Expression VisitMember(MemberExpression node)
    {
        if (node.Expression is ParameterExpression paramExp && paramExp.Type.Equals(typeof(T)))
        {
            return Expression.MakeMemberAccess(
                Expression.Parameter(typeof(U), paramExp.Name),
                typeof(U).GetMember(node.Member.Name).Single());
        }

        return base.VisitMember(node);
    }

    protected override Expression VisitLambda<L>(Expression<L> node)
    {
        var parameters = node.Parameters.ToList();
        var found = false;

        for (var i = 0; i < parameters.Count; i++)
        {
            if (parameters[i].Type.Equals(typeof(T)))
            {
                parameters[i] = Expression.Parameter(typeof(U), parameters[i].Name);
                found = true;
            }
        }

        if (found)
        {
            return Expression.Lambda(node.Body, parameters);
        }

        return base.VisitLambda(node);
    }
}

在这种情况下,创建一个实例new ParameterRewriter<DocumentTypeA, DocumentTypeB>(),并参观了原始表达式树,你会得到你想要的东西。扩展方法也许更可读的:

public static class ExpressionExtensions
{
    public static Expression<Func<U, R>> RewriteParameter<T, U, R>(this Expression<Func<T, R>> expression)
    {
        var rewriter = new ParameterRewriter<T, U>();
        return (Expression<Func<U, R>>)rewriter.Visit(expression);
    }
}

用法很简单:

Expression<Func<A, bool>> expA = x => x.Id == 1;
Expression<Func<B, bool>> expB = expA.RewriteParameter<A, B, bool>();

1
投票

使用这两个类继承的接口,并包含在两个类是相同的例如特性

interface IDocumentTypes
{
    string AString { get; set; } //indicates that both classes need to implement this
    //etc...
}

class DocumentTypeA : IDocumentTypes
{
    //your class
}

然后双方你的类时,它实现了接口Expression,仍然是强类型可以使用IDocumentTypes。这些类不需要有其他的共同比实现接口中定义的特性/功能的东西。

© www.soinside.com 2019 - 2024. All rights reserved.