การแปลง. net Func <T> เป็น. net Expression <Func <T>>

การเปลี่ยนจาก lambda เป็น Expression ทำได้ง่ายโดยใช้วิธีการเรียก ...

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 ออกทันที และอนุมานนิพจน์ (ซึ่งไม่ง่ายเลย) การจัดการนิพจน์แลมบ์ดาเป็น data ( Expression<Func<T>>) เป็นเวทมนตร์ที่ทำโดยคอมไพเลอร์ (โดยทั่วไปคอมไพเลอร์จะสร้างแผนภูมินิพจน์ในโค้ดแทนที่จะคอมไพล์เป็น IL)

ข้อเท็จจริงที่เกี่ยวข้อง

นี่คือเหตุผลที่ภาษาที่จะผลักดัน lambdas ไปมาก (เช่นเสียงกระเพื่อม) มักจะง่ายต่อการใช้เป็นล่าม ในภาษาเหล่านั้นรหัสและข้อมูลเป็นสิ่งเดียวกัน (แม้ในขณะรันไทม์ ) แต่ชิปของเราไม่สามารถเข้าใจรูปแบบของรหัสนั้นได้ดังนั้นเราจึงต้องเลียนแบบเครื่องดังกล่าวโดยการสร้างล่ามที่ด้านบนซึ่งเข้าใจได้ ( ตัวเลือกที่ทำโดย Lisp เช่นภาษา) หรือการเสียสละอำนาจ (รหัสจะไม่เท่ากับข้อมูลอีกต่อไป) ในระดับหนึ่ง (ตัวเลือกที่ทำโดย C #) ใน C # คอมไพเลอร์ให้ภาพลวงตาของการรักษารหัสเป็นข้อมูลโดยการอนุญาตให้ lambdas ที่จะตีความว่าเป็นรหัส ( Func<T>) และข้อมูล ( Expression<Func<T>>) ที่รวบรวมเวลา

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

สิ่งที่คุณควรทำคือเปลี่ยนวิธีการ ใช้ Expression> และรวบรวมและเรียกใช้ หากล้มเหลวแสดงว่าคุณมี 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);
        }

JB Evain จากทีม Cecil Mono กำลังดำเนินการบางอย่างเพื่อเปิดใช้งานสิ่งนี้

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