chuyển đổi .net Func <T> thành .net Expression <Func <T>>

Chuyển từ lambda sang Biểu thức thật dễ dàng bằng cách sử dụng một cuộc gọi phương thức ...

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

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

Nhưng tôi muốn chuyển Hàm thành một biểu thức, chỉ trong một số trường hợp hiếm hoi ...

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

Dòng không hoạt động mang lại cho tôi lỗi thời gian biên dịch Cannot implicitly convert type 'System.Func<T>' to 'System.Linq.Expressions.Expression<System.Func<T>>'. Diễn viên rõ ràng không giải quyết được tình huống. Có cơ sở nào để làm việc này mà tôi đang bỏ qua không?

Ồ, không dễ chút nào. Func<T>đại diện cho một delegatebiểu thức chung chứ không phải một biểu thức. Nếu có bất kỳ cách nào bạn có thể làm như vậy (do tối ưu hóa và những thứ khác được thực hiện bởi trình biên dịch, một số dữ liệu có thể bị loại bỏ, vì vậy có thể không thể lấy lại biểu thức ban đầu), nó sẽ được tháo rời IL ngay lập tức và suy ra biểu thức (không có nghĩa là dễ dàng). Xử lý các biểu thức lambda dưới dạng data ( Expression<Func<T>>) là một phép thuật được thực hiện bởi trình biên dịch (về cơ bản trình biên dịch xây dựng một cây biểu thức trong mã thay vì biên dịch nó thành IL).

Sự thật liên quan

Đây là lý do tại sao các ngôn ngữ đẩy lambdas đến cùng cực (như Lisp) thường dễ thực hiện hơn với vai trò thông dịch viên . Trong các ngôn ngữ đó, mã và dữ liệu về cơ bản là giống nhau (ngay cả khi đang chạy ), nhưng chip của chúng ta không thể hiểu dạng mã đó, vì vậy chúng ta phải mô phỏng một máy như vậy bằng cách xây dựng một trình thông dịch trên đầu nó để hiểu nó ( lựa chọn được thực hiện bởi Lisp như ngôn ngữ) hoặc hy sinh sức mạnh (mã sẽ không còn chính xác bằng dữ liệu) ở một mức độ nào đó (lựa chọn được thực hiện bởi C #). Trong C #, trình biên dịch tạo ảo giác coi mã là dữ liệu bằng cách cho phép lambdas được hiểu là mã ( Func<T>) và dữ liệu ( Expression<Func<T>>) tại thời điểm biên dịch .

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

Điều bạn có thể nên làm, là xoay chuyển phương pháp. Lấy một Biểu thức>, biên dịch và chạy. Nếu nó không thành công, bạn đã có Biểu thức để xem xét.

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

Rõ ràng là bạn cần phải xem xét các tác động hiệu suất của việc này và xác định xem đó có phải là điều bạn thực sự cần làm hay không.

Tuy nhiên, bạn có thể đi theo cách khác thông qua phương thức .Compile () - không chắc liệu điều này có hữu ích cho bạn hay không:

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

Nếu đôi khi bạn cần một biểu thức và đôi khi cần một đại biểu, bạn có 2 lựa chọn:

• có các phương pháp khác nhau (1 cho mỗi phương pháp)
• luôn chấp nhận Expression<...>phiên bản và chỉ .Compile().Invoke(...)nó nếu bạn muốn có người ủy quyền. Rõ ràng điều này có chi phí.

NJection.LambdaConverter là một thư viện chuyển đổi các đại biểu thành biểu thức

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 từ nhóm Cecil Mono đang thực hiện một số tiến bộ để thực hiện điều này

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

Thay đổi

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

Đến

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