Jak uzyskać dostęp do wartości zmiennej lokalnej z drzewa wyrażeń

Question

Badając drzewo wyrażeń, można uzyskać wartość stałej, pole instancji i właściwość, ale nie zmienną lokalną zdefiniowaną w metodzie.

Wykonanie następujących czynności spowoduje wyprowadzenie 1, 2, 3 (ze stałej, pola instancji i właściwości), a następnie wyjątku, ponieważ nie wiem, jak uzyskać instancję, w której deklarowana jest FieldInfo w celu wywołania GetValue () dla zmiennej lokalnej.

using System; 
using System.Linq.Expressions; 
using System.Reflection; 

namespace Example 
{ 
    class Program 
    { 
     private int _intField = 2; 

     static void Main() 
     { 
      new Program().Run(); 
      Console.ReadLine(); 
     } 

     private void Run() 
     { 
      IntProp = 3; 
      var intVariable = 4; 
      Test(() => 1); 
      Test(() => _intField); 
      Test(() => IntProp); 
      Test(() => intVariable); 
     } 

     public int IntProp { get; set; } 

     void Test<T>(Expression<Func<T>> func) 
     { 
      var body = func.Body; 

      if (body.NodeType == ExpressionType.Constant) 
      { 
       Console.WriteLine(((ConstantExpression)body).Value); 
      } 
      else 
      { 
       var memberExpression = body as MemberExpression; 

       var @object = memberExpression.Member.DeclaringType == GetType() 
        ? this 
        : null; //Can I do anything here? Instance of the method the variable is defined in? 

       if (memberExpression.Member.MemberType == MemberTypes.Field) 
       { 
        Console.WriteLine(((FieldInfo)memberExpression.Member).GetValue(@object)); 
       } 
       else if (memberExpression.Member.MemberType == MemberTypes.Property) 
       { 
        Console.WriteLine(((PropertyInfo)memberExpression.Member).GetValue(@object)); 
       } 
      } 
     } 
    } 
} 

Answer 1

Zmienna lokalna, która została przechwycona przez lambda i uwzględniona w drzewie wyrażeń, będzie w tym czasie naprawdę polem w klasie generowanej przez kompilator. To działa na moją wersję .NET:

void Test<T>(Expression<Func<T>> func) 
{ 
    var body = func.Body; 

    if (body.NodeType == ExpressionType.Constant) 
    { 
    Console.WriteLine(((ConstantExpression)body).Value); 
    } 
    else 
    { 
    var memberExpression = (MemberExpression)body; 

    var @object = 
     ((ConstantExpression)(memberExpression.Expression)).Value; //HERE! 

    if (memberExpression.Member.MemberType == MemberTypes.Field) 
    { 
     Console.WriteLine(((FieldInfo)memberExpression.Member).GetValue(@object)); 
    } 
    else if (memberExpression.Member.MemberType == MemberTypes.Property) 
    { 
     Console.WriteLine(((PropertyInfo)memberExpression.Member).GetValue(@object)); 
    } 
    } 
} 

Oczywiście, można również „oszukiwać”:

void Test<T>(Expression<Func<T>> func) 
{ 
    Console.WriteLine(func.Compile()()); 
} 

Answer 2

Nie, nie możesz.

Odbicie nie obejmuje odczytania wartości zmiennej metody.

Obsługuje tylko metadane deklaracji zmiennych. Nawet wtedy kompilator mógł usunąć zmienną, o której myślałeś, że ją zadeklarowałeś. Już masz dostęp do właściwości, pól.

Answer 3

Nie, nie można, ponieważ te zmienne są po prostu niedostępne poza metodą ich zakresu.

Answer 4

Nie można z refleksją. Ale są inne metody, aby to zrobić. Jako przykład pokazuję, jak wyeksportować zmienną z zakresu leksykalnego funkcji.

Powiedzmy, że masz sposób tak:

private void f(int x) 
{ 
    // your code here 
} 

Trzeba też kawałek kodu:

int x_in_f; 

f(3); 
x_in_f = /* I want to have the value here */; 

aby uzyskać wartość spośród f() należy wyeksportować funkcję pochłaniacza. Jako f() zwraca void, po prostu można zwrócić getter. W ogólnym przypadku (gdy f() ma typ zwrotny bez void), można użyć parametru out. Oto oba warianty:

private Func<int> f(int x) 
{ 
    // your code here 

    return() => { return x; }; 
} 

lub poprzez parametr out:

private void f(int x, out Func<int> g) 
{ 
    // your code here 

    g =() => { return x; }; 
} 

Kod będzie wówczas:

int x_in_f; 
Func<int> g; 

g = f(3); 

x_in_f = g(); // this will return the value of x as it was passed to f() 

lub poprzez parametr out powołać f() następująco:

f(3, out g); 

W tym momencie można przekazać g() wokół innych funkcji:

private void h(Func<int> getx) 
{ 
    // your code here 
    int x = getx(); 
    // now you have the value of x inside the h() function 
} 

i inwokacji z h():

Func<int> g = f(3); 

// ... 

h(g); 

Mam nadzieję, że to pomaga lub przynajmniej pokazuje jak używać zamknięć do obejścia leksykalny zakres.

Dla projektantów jest to model obiektowy Model. This is a video Douglas Crockforda, w jaki sposób używać go do celów bezpieczeństwa w JavaScript.Przekłada się to na C# i inne cele z łatwością, jak pokazałem powyżej.