Question

Within the following method, I would like to access any optional arguments that are contained within the Action:

public static class ValidatorEngine
{
    public static void Validate(Action someMethodWithOptionalArguments)
    {
        object target = someMethodWithOptionalArguments.Target;
    }
}

So if I called this method like so:

ValidatorEngine.Validate(() => UpdateByModel(model));

I would like to be able to access the model argument passed into the Action. I’m not even interested in invoking this Action.

I’m thinking that there is something that can be done with the Target property of the Action because I can see the model when debugging. I just can’t figure it out programmatically.

Answer 1

If you want to inspect it but not execute it, this is a prime example for an Expression. Just change the signature from Action to Expression<Action>. This will give you an expression tree that you can analyse. For a basic example:

public static class ValidatorEngine
{
    static void Main()
    {
        string model = "abc";
        ValidatorEngine.Validate(() => UpdateByModel(model));
    }
    public static void Validate(Expression<Action> action)
    {
        var methodCall = action.Body as MethodCallExpression;
        if (methodCall == null) throw new InvalidOperationException("Expected a method-call");
        Console.WriteLine("Method: " + methodCall.Method.DeclaringType.Name + "." + methodCall.Method.Name);
        var parameters = methodCall.Method.GetParameters();
        for (int i = 0; i < parameters.Length; i++)
        {
          Console.WriteLine(parameters[i].Name + ": " + Evaluate(methodCall.Arguments[i]));
        }
    }

    static object Evaluate(Expression exp)
    {
        switch (exp.NodeType)
        {
            case ExpressionType.Constant:
                return ((ConstantExpression)exp).Value;
            case ExpressionType.MemberAccess:
                var me = (MemberExpression)exp;
                switch (me.Member.MemberType)
                {
                    case System.Reflection.MemberTypes.Field:
                        return ((FieldInfo)me.Member).GetValue(Evaluate(me.Expression));
                    case MemberTypes.Property:
                        return ((PropertyInfo)me.Member).GetValue(Evaluate(me.Expression), null);
                    default:
                        throw new NotSupportedException(me.Member.MemberType.ToString());
                }
            default:
                throw new NotSupportedException(exp.NodeType.ToString());

        }

    }
    static void UpdateByModel(object model) {
        throw new NotImplementedException();
    }
}

To support a richer set of nodes and scenarios, see this richer version.