converter um Func .net <T> em uma Expressão .net <Func <T>>

Ir de um lambda para uma Expressão é fácil usando uma chamada de método ...

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

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

Mas eu gostaria de transformar o Func em uma expressão, apenas em casos raros ...

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());
}

A linha que não funciona me dá o erro de tempo de compilação Cannot implicitly convert type 'System.Func<T>' to 'System.Linq.Expressions.Expression<System.Func<T>>'. Um elenco explícito não resolve a situação. Existe uma facilidade para fazer isso que estou esquecendo?

Ooh, não é nada fácil. Func<T>representa um genérico delegatee não uma expressão. Se houver alguma maneira de fazer isso (devido a otimizações e outras coisas feitas pelo compilador, alguns dados podem ser jogados fora, então pode ser impossível obter a expressão original de volta), seria desmontar o IL na hora e inferir a expressão (o que não é nada fácil). Tratar expressões lambda como data ( Expression<Func<T>>) é uma mágica feita pelo compilador (basicamente, o compilador constrói uma árvore de expressão no código em vez de compilá-la para IL).

Fato relacionado

É por isso que as linguagens que levam lambdas ao extremo (como Lisp) são geralmente mais fáceis de implementar como interpretadores . Nessas linguagens, código e dados são essencialmente a mesma coisa (mesmo em tempo de execução ), mas nosso chip não consegue entender essa forma de código, então temos que emular tal máquina construindo um interpretador em cima dela que a entenda (o escolha feita por linguagens como o Lisp) ou sacrificando o poder (o código não será mais exatamente igual aos dados) até certo ponto (a escolha feita pelo C #). No C #, o compilador dá a ilusão de tratar o código como dados, permitindo que lambdas sejam interpretados como code ( Func<T>) e data ( Expression<Func<T>>) no momento da compilação .

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

O que você provavelmente deve fazer é inverter o método. Pegue um Expression>, compile e execute. Se falhar, você já tem a Expressão para examinar.

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());
}

Obviamente, você precisa considerar as implicações disso no desempenho e determinar se é algo que você realmente precisa fazer.

No entanto, você pode fazer o contrário por meio do método .Compile () - não tenho certeza se isso é útil para você:

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());
}

Se às vezes você precisa de uma expressão e às vezes de um delegado, você tem 2 opções:

• têm métodos diferentes (1 para cada)
• aceite sempre a Expression<...>versão, e apenas .Compile().Invoke(...)se quiser um delegado. Obviamente, isso tem um custo.

NJection.LambdaConverter é uma biblioteca que converte delegados em expressão

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, da equipe Cecil Mono, está fazendo alguns progressos para habilitar este

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

mudança

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

Para

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