получить конечные значения из параметров метода лямбда-выражений

Question

В основном я хочу получить значения параметров вызываемого метода следующим образом:

var x = 1;
var a = 2;
var b = 3;
Do<HomeController>(o => o.Save(x, "Jimmy", a+b+5, Math.Sqrt(81)));

public static void Do<T>(Expression<Action<T>> expression) where T : Controller
{
  // get the values 1,Jimmy,10,9 here
}

Answer 1

Ну, вам нужно углубиться в выражение, найти MethodCallExpression, а затем посмотреть на аргументы к нему. Обратите внимание, что у нас нет значения o, поэтому мы должны предположить, что аргументы метода не полагаются на это. Также мы по-прежнему предполагаем, что лямбда-выражение просто полагается на то, что оно является MethodCallExpression?

РЕДАКТИРОВАТЬ: Хорошо, вот отредактированная версия, которая оценивает аргументы. Однако предполагается, что вы не действительно используете параметр лямбда-выражения в аргументах (о чем говорит new object[1] - это, по сути, пустой параметр).

using System;
using System.Linq.Expressions;

class Foo
{
    public void Save(int x, string y, int z, double d)
    {
    }
}

class Program
{
    static void Main()
    {
        var x = 1;
        var a = 2;
        var b = 3;
        ShowValues<Foo>(o => o.Save(x, "Jimmy", a + b + 5, Math.Sqrt(81)));
    }

    static void ShowValues<T>(Expression<Action<T>> expression)
    {
        var call = expression.Body as MethodCallExpression;
        if (call == null)
        {
            throw new ArgumentException("Not a method call");
        }
        foreach (Expression argument in call.Arguments)
        {
            LambdaExpression lambda = Expression.Lambda(argument, 
                                                        expression.Parameters);
            Delegate d = lambda.Compile();
            object value = d.DynamicInvoke(new object[1]);
            Console.WriteLine("Got value: {0}", value);
        }
    }
}

Answer 2

Как сказал Джон, вы можете проверить, является ли выражение MethodCallExpression

class Program
{
    static void Main(string[] args)
    {
        Program.Do<Controller>(c => c.Save(1, "Jimmy"));
    }

    public static void Do<T>(Expression<Action<T>> expression) where T : Controller
    {
        var body = expression.Body as MethodCallExpression;
        if (body != null)
        {
            foreach (var argument in body.Arguments)
            {
                var constant = argument as ConstantExpression;
                if (constant != null)
                {
                    Console.WriteLine(constant.Value);
                }
            }
        }
    }
}

public class Controller
{
    public void Save(int id, string name)
    {
    }
}

Answer 3

Мой универсальный ответ ниже. Я надеюсь, что это поможет вам и кому-то еще.

var dict = new Dictionary<string, object>();
var parameterExpressions = methodCallExpr.Arguments;
foreach (var param in method.GetParameters())
{
    var parameterExpression = parameterExpressions[counter];
    var paramValueAccessor = Expression.Lambda(parameterExpression);
    var paramValue = paramValueAccessor.Compile().DynamicInvoke();
    dict[param.Name] = paramValue;
}

Answer 4

Вот некоторый код, который предназначен для работы с любым выражением - в том смысле, что он не предполагает, что вы передаете выражение вызова метода.Тем не менее, это не завершено.Остальное вам нужно будет заполнить.

public static IEnumerable<object> ExtractConstants<T>(
        Expression<Action<T>> expression)
{
    return extractConstants(expression);
}
private static IEnumerable<object> extractConstants(Expression expression)
{
    if (expression == null)
        yield break;

    if (expression is ConstantExpression)
        yield return ((ConstantExpression) expression).Value;

    else if (expression is LambdaExpression)
        foreach (var constant in extractConstants(
                ((LambdaExpression) expression).Body))
            yield return constant;

    else if (expression is UnaryExpression)
        foreach (var constant in extractConstants(
                ((UnaryExpression) expression).Operand))
            yield return constant;

    else if (expression is MethodCallExpression)
    {
        foreach (var arg in ((MethodCallExpression) expression).Arguments)
            foreach (var constant in extractConstants(arg))
                yield return constant;
        foreach (var constant in extractConstants(
                ((MethodCallExpression) expression).Object))
            yield return constant;
    }

    else
        throw new NotImplementedException();
}

В случае, который вы упомянули, это уже работает:

// Prints:
// Jimmy (System.String)
// 1 (System.Int32)
foreach (var constant in Ext.ExtractConstants<string>(
        str => Console.WriteLine("Jimmy", 1)))
    Console.WriteLine("{0} ({1})", constant.ToString(),
                                   constant.GetType().FullName);

Для более сложных лямбда-выражений, которые используют другие типы выраженийузлы, вам придется постепенно расширять вышеуказанный код.Каждый раз, когда вы используете его, и он выдает NotImplementedException, вот что я делаю:

• Откройте окно просмотра в отладчике
• Посмотрите на переменную expression и еевведите
• Добавьте необходимый код для обработки этого типа выражения

Со временем метод будет становиться все более и более полным.

Answer 5

  public override IQueryable<Image> FindAll(System.Linq.Expressions.Expression<Func<Image, dynamic>> Id)
        {
            dynamic currentType = Id.Parameters[0];
            var id = currentType.Type.GUID;
            var result = (_uniwOfWork as UnitOfWork).uspGetImages(id.ToString());
            return FindAll();
        }

динамическое использование ключевого слова.