Question

我正在尝试为（在运行时）创建一个为所有类型的委托创建包装器的方法。这样可以创建一种注入额外日志记录的灵活方式（在本例中）。在第一步中，我尝试围绕给定的input - 参数创建try-catch包。

try
{
  Console.WriteLine(....);
  // Here the original call
  Console.WriteLine(....);
}
catch(Exception ex)
{
  Console.WriteLine(.....);
}

我正在使用通用方法调用CreateWrapper2（见下文）

private static readonly MethodInfo ConsoleWriteLine = typeof(Console).GetMethod("WriteLine", new[] { typeof(string), typeof(object[]) });

private static MethodCallExpression WriteLinExpression(string format, params object[] args)
{
    Expression[] expressionArguments = new Expression[2];
    expressionArguments[0] = Expression.Constant(format, typeof(string));
    expressionArguments[1] = Expression.Constant(args, typeof(object[]));

    return Expression.Call(ConsoleWriteLine, expressionArguments);
}

public T CreateWrapper2<T>(T input)
{
    Type type = typeof(T);

    if (!typeof(Delegate).IsAssignableFrom(type))
    {
        return input;
    }

    PropertyInfo methodProperty = type.GetProperty("Method");
    MethodInfo inputMethod = methodProperty != null ? (MethodInfo)methodProperty.GetValue(input) : null;

    if (inputMethod == null)
    {
        return input;
    }

    string methodName = inputMethod.Name;
    ParameterInfo[] parameters = inputMethod.GetParameters();
    ParameterExpression[] parameterExpressions = new ParameterExpression[parameters.Length];

    // TODO: Validate/test parameters, by-ref /out with attributes etc.

    for (int idx = 0; idx < parameters.Length; idx++)
    {
        ParameterInfo parameter = parameters[idx];
        parameterExpressions[idx] = Expression.Parameter(parameter.ParameterType, parameter.Name);
    }

    bool handleReturnValue = inputMethod.ReturnType != typeof(void);

    ParameterExpression variableExpression = handleReturnValue ? Expression.Variable(inputMethod.ReturnType) : null;
    MethodCallExpression start = WriteLinExpression("Starting '{0}'.", methodName);
    MethodCallExpression completed = WriteLinExpression("Completed '{0}'.", methodName);
    MethodCallExpression failed = WriteLinExpression("Failed '{0}'.", methodName);

    Expression innerCall = Expression.Call(inputMethod, parameterExpressions);
    LabelTarget returnTarget = Expression.Label(inputMethod.ReturnType);
    LabelExpression returnLabel = Expression.Label(returnTarget, Expression.Default(returnTarget.Type)); ;
    GotoExpression returnExpression = null;

    if (inputMethod.ReturnType != typeof(void))
    {
        // Handle return value.
        innerCall = Expression.Assign(variableExpression, innerCall);
        returnExpression = Expression.Return(returnTarget, variableExpression, returnTarget.Type);
    }
    else
    {
        returnExpression = Expression.Return(returnTarget);
    }

    List<Expression> tryBodyElements = new List<Expression>();
    tryBodyElements.Add(start);
    tryBodyElements.Add(innerCall);
    tryBodyElements.Add(completed);

    if (returnExpression != null)
    {
        tryBodyElements.Add(returnExpression);
    }

    BlockExpression tryBody = Expression.Block(tryBodyElements);
    BlockExpression catchBody = Expression.Block(tryBody.Type, new Expression[] { failed, Expression.Rethrow(tryBody.Type) });
    CatchBlock catchBlock = Expression.Catch(typeof(Exception), catchBody);
    TryExpression tryBlock = Expression.TryCatch(tryBody, catchBlock);

    List<Expression> methodBodyElements = new List<Expression>();

    if(variableExpression != null) methodBodyElements.Add(variableExpression);

    methodBodyElements.Add(tryBlock);
    methodBodyElements.Add(returnLabel);

    Expression<T> wrapperLambda = Expression<T>.Lambda<T>(Expression.Block(methodBodyElements), parameterExpressions);

    Console.WriteLine("lambda:");
    Console.WriteLine(wrapperLambda.GetDebugView());

    return wrapperLambda.Compile();
}

对于void-methods（如Action<>），这段代码可以满足我的需要。但是当有一个返回值时，我得到“范围''引用的'System.Boolean'类型的异常” variable''，但它没有被定义“

许多其他帖子谈论Expression.Parameter多次调用参数;对我来说，这里看起来像是其他错误，但我找不到它。一切顺利，直到.Compile行，它崩溃了。

对于Func<int, bool> target = i => i % 2 ==0;，下面是生成表达式的DebugView。

.Lambda #Lambda1<System.Func`2[System.Int32,System.Boolean]>(System.Int32 $i) {
    .Block() {
        $var1;
        .Try {
            .Block() {
                .Call System.Console.WriteLine(
                    "Starting '{0}'.",
                    .Constant<System.Object[]>(System.Object[]));
                $var1 = .Call LDAP.LdapProgram.<Main>b__0($i);
                .Call System.Console.WriteLine(
                    "Completed '{0}'.",
                    .Constant<System.Object[]>(System.Object[]));
                .Return #Label1 { $var1 }
            }
        } .Catch (System.Exception) {
            .Block() {
                .Call System.Console.WriteLine(
                    "Failed '{0}'.",
                    .Constant<System.Object[]>(System.Object[]));
                .Rethrow
            }
        };
        .Label
            .Default(System.Boolean)
        .LabelTarget #Label1:
    }
}

我缺少什么？（在调试期间我试过：

将Expression.Variable从try-body内移动到toplevel。
通过键入的Expression.Return为catch-block提供了与try-block相同的Body.Type。

）

Answer 1

看起来你没有为block语句指定你的变量。

在错误中你正在动态创建一个参数并且没有给它起一个名字，如果你这样做了，你会看到：

"variable 'varName' of type 'System.Boolean' referenced from scope 'varName', but it is not defined"

因此，如果您在制作表达树时提供您的vars名称，以后应该可以使您的生活更轻松

        // Define the variable at the top of the block 
        // when we are returning something
        if (variableExpression != null)
        {
            block = Expression.Block(new[] { variableExpression }, methodBodyElements);
        }
        else
        {
            block = Expression.Block(methodBodyElements);
        }

        Expression<T> wrapperLambda = Expression<T>.Lambda<T>(block, parameterExpressions);

        return wrapperLambda.Compile();

“范围''引用的'System.Boolean'类型的”变量“，但未在Expression中定义

1 个答案: