Konvertieren eines .net Func <T> in einen .net Ausdruck <Func <T>>

Mit einem Methodenaufruf ist es einfach, von einem Lambda zu einem Ausdruck zu wechseln ...

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

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

Aber ich möchte den Func nur in seltenen Fällen in einen Ausdruck verwandeln ...

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

Die Zeile, die nicht funktioniert, gibt mir den Fehler beim Kompilieren Cannot implicitly convert type 'System.Func<T>' to 'System.Linq.Expressions.Expression<System.Func<T>>'. Eine explizite Besetzung löst die Situation nicht. Gibt es eine Möglichkeit, dies zu tun, die ich übersehen habe?

Oh, es ist überhaupt nicht einfach. Func<T>repräsentiert einen generischen delegateund keinen Ausdruck. Wenn Sie dies auf irgendeine Weise tun können (aufgrund von Optimierungen und anderen vom Compiler vorgenommenen Vorgängen werden möglicherweise einige Daten weggeworfen, sodass der ursprüngliche Ausdruck möglicherweise nicht wiederhergestellt werden kann), wird die IL im laufenden Betrieb zerlegt und auf den Ausdruck schließen (was keineswegs einfach ist). Das Behandeln von Lambda-Ausdrücken als data ( Expression<Func<T>>) ist eine Magie des Compilers (im Grunde erstellt der Compiler einen Ausdrucksbaum im Code, anstatt ihn in IL zu kompilieren).

Verwandte Tatsache

Aus diesem Grund sind Sprachen, die Lambdas auf die Spitze treiben (wie Lisp), als Dolmetscher oft einfacher zu implementieren . In diesen Sprachen sind Code und Daten im Wesentlichen dasselbe (auch zur Laufzeit ), aber unser Chip kann diese Form von Code nicht verstehen. Daher müssen wir eine solche Maschine emulieren, indem wir darauf einen Interpreter aufbauen, der sie versteht (the Auswahl von Lisp wie Sprachen) oder Einbußen bei der Leistung (Code entspricht nicht mehr genau den Daten) bis zu einem gewissen Grad (Auswahl von C #). In C # gibt der Compiler die Illusion, Code als Daten zu behandeln, indem Lambdas zur Kompilierungszeit als Code ( Func<T>) und Daten ( Expression<Func<T>>) interpretiert werden können .

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

Was Sie wahrscheinlich tun sollten, ist die Methode umzudrehen. Nehmen Sie einen Ausdruck> auf und kompilieren Sie ihn und führen Sie ihn aus. Wenn dies fehlschlägt, müssen Sie bereits den Ausdruck untersuchen.

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

Natürlich müssen Sie die Auswirkungen auf die Leistung berücksichtigen und feststellen, ob Sie dies wirklich tun müssen.

Sie können jedoch auch über die .Compile () -Methode in die andere Richtung gehen - nicht sicher, ob dies für Sie nützlich ist:

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

Wenn Sie manchmal einen Ausdruck und manchmal einen Delegaten benötigen, haben Sie zwei Möglichkeiten:

• unterschiedliche Methoden haben (jeweils 1)
• Akzeptieren Sie immer die Expression<...>Version und nur .Compile().Invoke(...)dann, wenn Sie einen Delegaten möchten. Offensichtlich hat dies Kosten verursacht.

NJection.LambdaConverter ist eine Bibliothek, die Delegaten in Ausdruck konvertiert

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 vom Cecil Mono-Team macht einige Fortschritte, um dies zu ermöglichen

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

Veränderung

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

Zu

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