.net Func <T> 'yi .net İfadesine dönüştürme <Func <T>>

Bir lambda'dan bir İfadeye gitmek, bir yöntem çağrısı kullanarak kolaydır ...

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

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

Ancak Func'u bir ifadeye dönüştürmek istiyorum, sadece nadir durumlarda ...

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

Çalışmayan satır bana derleme zamanı hatası veriyor Cannot implicitly convert type 'System.Func<T>' to 'System.Linq.Expressions.Expression<System.Func<T>>'. Açık bir atama durumu çözmez. Bunu yapmak için gözden kaçırdığım bir tesis var mı?

Ooh, hiç de kolay değil. bir ifadeyi değil Func<T>genel delegatebir ifadeyi temsil eder . Bunu yapabileceğiniz herhangi bir yol varsa (derleyici tarafından yapılan optimizasyonlar ve diğer şeyler nedeniyle, bazı veriler atılabilir, bu nedenle orijinal ifadeyi geri almak imkansız olabilir), bu IL'yi anında parçalarına ayırmak olacaktır. ve ifadeyi çıkarmak (ki bu hiç de kolay değildir). Lambda ifadelerini data ( Expression<Func<T>>) olarak ele almak, derleyici tarafından yapılan bir sihirdir (temelde derleyici, onu IL'ye derlemek yerine kodda bir ifade ağacı oluşturur).

İlgili gerçek

Bu nedenle, lambdaları aşırıya iten dillerin (Lisp gibi) tercüman olarak uygulanması genellikle daha kolaydır . Bu dillerde, kod ve veriler temelde aynı şeydir ( çalışma zamanında bile ), ancak çipimiz bu kod biçimini anlayamaz, bu nedenle, böyle bir makineyi, onu anlayan bir yorumlayıcı oluşturarak taklit etmeliyiz ( Lisp tarafından diller gibi yapılan seçim) veya gücü bir dereceye kadar feda etme (kod artık tam olarak verilere eşit olmayacak) (C # tarafından yapılan seçim). C # 'da derleyici, lambdaların derleme zamanında kod ( Func<T>) ve veri ( Expression<Func<T>>) olarak yorumlanmasına izin vererek kodu veri olarak işleme yanılsamasını verir .

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

Muhtemelen yapmanız gereken, yöntemi tersine çevirmektir. Bir İfade alın> ve derleyin ve çalıştırın. Başarısız olursa, bakmanız gereken İfade zaten var.

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

Açıkçası, bunun performans etkilerini göz önünde bulundurmanız ve gerçekten yapmanız gereken bir şey olup olmadığına karar vermeniz gerekiyor.

Ancak .Compile () yöntemini kullanarak diğer yoldan gidebilirsiniz - bunun sizin için yararlı olup olmadığından emin değilsiniz:

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

Bazen bir ifadeye, bazen de bir temsilciye ihtiyacınız varsa, 2 seçeneğiniz vardır:

• farklı yöntemleri vardır (her biri için 1)
• her zaman Expression<...>sürümü kabul edin ve .Compile().Invoke(...)bir temsilci istiyorsanız sadece onu. Açıkçası bunun bir maliyeti var.

NJection.LambdaConverter , temsilcileri ifadeye dönüştüren bir kitaplıktır

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

Cecil Mono ekibinden JB Evain bunu sağlamak için biraz ilerleme kaydediyor

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

Değişiklik

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

için

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