.net Func <T>を.net Expression <Func <T >>に変換する

ラムダから式への移行は、メソッド呼び出しを使用すると簡単です...

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

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

しかし、私はFuncを式に変えたいのですが、まれなケースだけです...

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など）がインタプリタとして実装するのが簡単になることが多い理由です。これらの言語では、コードとデータは（実行時でも）基本的に同じものですが、チップはその形式のコードを理解できません。 Lispのような言語で行われた選択）またはある程度までパワーを犠牲にします（コードはデータと完全に等しくなくなります）（C＃で行われた選択）。C＃では、コンパイラーは、コンパイル時にラムダをコード（Func<T>）およびデータ（Expression<Func<T>>）として解釈できるようにすることで、コードをデータとして扱うような錯覚を与えます。

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

おそらくあなたがすべきことは、方法を変えることです。Expression>を取り込み、コンパイルして実行します。失敗した場合、調査する式はすでにあります。

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

式が必要な場合とデリゲートが必要な場合は、2つのオプションがあります。

• 異なる方法があります（それぞれに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);
        }

Cecil Monoチームの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();