перетворення .net Func <T> в .net Вираз <Func <T>>

Перехід від лямбда до Expression легко за допомогою виклику методу ...

public void GimmeExpression(Expression<Func<T>> expression)
{
    ((MemberExpression)expression.Body).Member.Name; // "DoStuff"
}

public void SomewhereElse()
{
    GimmeExpression(() => thing.DoStuff());
}

Але я хотів би перетворити функцію на вираз, лише в рідкісних випадках ...

public void ContainTheDanger(Func<T> dangerousCall)
{
    try 
    {
        dangerousCall();
    }
    catch (Exception e)
    {
        // This next line does not work...
        Expression<Func<T>> DangerousExpression = dangerousCall;
        var nameOfDanger = 
            ((MemberExpression)dangerousCall.Body).Member.Name;
        throw new DangerContainer(
            "Danger manifested while " + nameOfDanger, e);
    }
}

public void SomewhereElse()
{
    ContainTheDanger(() => thing.CrossTheStreams());
}

Рядок, який не працює, дає мені помилку часу компіляції Cannot implicitly convert type 'System.Func<T>' to 'System.Linq.Expressions.Expression<System.Func<T>>'. Явний виступ не вирішує ситуацію. Чи є можливість зробити це, що я оглядаю?

О, це зовсім не просто. Func<T>являє собою родове, delegateа не вираження. Якщо ви можете це зробити (через оптимізацію та інші речі, зроблені компілятором, деякі дані можуть бути викинуті, тож повернути оригінальний вираз може бути неможливо), це буде розбирати IL на льоту і виводити вираз (що аж ніяк не просто). Розгляд виразів лямбда як даних ( Expression<Func<T>>) - це магія, яку виконує компілятор (в основному компілятор будує дерево виразів у коді замість того, щоб компілювати його в IL).

Супутній факт

Ось чому мови, які підштовхують лямбда до крайності (як, наприклад, Лісп), часто легше реалізувати як перекладачів . У цих мовах код і дані - це по суті те саме (навіть під час виконання ), але наш чіп не може зрозуміти цю форму коду, тому нам доведеться емулювати таку машину, будуючи інтерпретатор, що розуміє її ( вибір, зроблений Lisp як мови) або жертвуючи потужністю (код більше не буде точно рівним даним) певною мірою (вибір зроблений C #). У C # компілятор подає ілюзію трактування коду як даних, дозволяючи лямбдам інтерпретувати як код ( Func<T>) та дані ( Expression<Func<T>>) під час компіляції .

    private static Expression<Func<T, bool>> FuncToExpression<T>(Func<T, bool> f)  
    {  
        return x => f(x);  
    } 

Що ви, мабуть, повинні зробити, це обернути метод. Візьміть у вираз> і компілюйте та запустіть. Якщо це не вдається, у вас вже є вираз.

public void ContainTheDanger(Expression<Func<T>> dangerousCall)
{
    try 
    {
        dangerousCall().Compile().Invoke();;
    }
    catch (Exception e)
    {
        // This next line does not work...
        var nameOfDanger = 
            ((MemberExpression)dangerousCall.Body).Member.Name;
        throw new DangerContainer(
            "Danger manifested while " + nameOfDanger, e);
    }
}

public void SomewhereElse()
{
    ContainTheDanger(() => thing.CrossTheStreams());
}

Очевидно, що вам потрібно врахувати наслідки для продуктивності та визначити, чи це дійсно вам потрібно зробити.

Ви можете піти іншим шляхом методом .Compile (), але не впевнені, чи корисно це для вас:

public void ContainTheDanger<T>(Expression<Func<T>> dangerousCall)
{
    try
    {
        var expr = dangerousCall.Compile();
        expr.Invoke();
    }
    catch (Exception e)
    {
        Expression<Func<T>> DangerousExpression = dangerousCall;
        var nameOfDanger = ((MethodCallExpression)dangerousCall.Body).Method.Name;
        throw new DangerContainer("Danger manifested while " + nameOfDanger, e);
    }
}

public void SomewhereElse()
{
    var thing = new Thing();
    ContainTheDanger(() => thing.CrossTheStreams());
}

Якщо вам іноді потрібен вираз, а іноді і делегат, у вас є два варіанти:

• мають різні методи (по 1 для кожного)
• завжди приймайте Expression<...>версію, і просто .Compile().Invoke(...)її, якщо хочете делегата. Очевидно, що це коштувало.

NJection.LambdaConverter - це бібліотека, яка перетворює делегатів на вирази

public class Program
{
    private static void Main(string[] args) {
       var lambda = Lambda.TransformMethodTo<Func<string, int>>()
                          .From(() => Parse)
                          .ToLambda();            
    }   

    public static int Parse(string value) {
       return int.Parse(value)
    } 
}

 Expression<Func<T>> ToExpression<T>(Func<T> call)
        {
            MethodCallExpression methodCall = call.Target == null
                ? Expression.Call(call.Method)
                : Expression.Call(Expression.Constant(call.Target), call.Method);

            return Expression.Lambda<Func<T>>(methodCall);
        }

JB Evain з команди Сесіль Моно досягає певного прогресу, щоб зробити це можливим

http://evain.net/blog/articles/2009/04/22/converting-delegates-to-expression-trees

Зміна

// This next line does not work...
Expression<Func<T>> DangerousExpression = dangerousCall;

До

// This next line works!
Expression<Func<T>> DangerousExpression = () => dangerousCall();