Drzewo wyrażeń dla metody String.IndexOf

Question

Jak skonstruować drzewo wyrażeń dla string.IndexOf("substring", StringComparison.OrdinalIgnoreCase)?

Mogę go uruchomić bez drugiego argumentu: StringComparison.OrdinalIgnoreCase. Są to moje próby do tej pory:

var methodCall = typeof (string).GetMethod("IndexOf", new[] {typeof (string)}); 
Expression[] parms = new Expression[]{right, Expression.Constant("StringComparison.OrdinalIgnoreCase", typeof (Enum))}; 
var exp = Expression.Call(left, methodCall, parms); 
return exp; 

próbował Również w tym:

var methodCall = typeof (string).GetMethod(method, new[] {typeof (string)}); 
Expression[] parms = new Expression[]{right, Expression.Parameter(typeof(Enum) , "StringComparison.OrdinalIgnoreCase")}; 
var exp = Expression.Call(left, methodCall, parms); 
return exp; 

Proszę pamiętać, że mogę dostać pracy, jeśli pominąć parametr OrdinalIgnoreCase.

Dzięki

Answer 1

Podejrzewam, że są dwa problemy.

Pierwszym z nich jest sposób dostajesz metodę - jesteś prosząc dla metody z tylko jednego parametru ciąg, zamiast jednego z dwóch parametrów:

var methodCall = typeof (string).GetMethod("IndexOf", 
          new[] { typeof (string), typeof(StringComparison) }); 

Drugi jest wartość dajesz - powinna być rzeczywista wartość stałą, a nie ciąg znaków:

Expression[] parms = new Expression[] { right, 
    Expression.Constant(StringComparison.OrdinalIgnoreCase) }; 

EDIT: Oto pełna próbka robocza:

using System; 
using System.Linq.Expressions; 

class Test 
{ 
    static void Main() 
    { 
     var method = typeof (string).GetMethod("IndexOf", 
       new[] { typeof (string), typeof(StringComparison) }); 

     var left = Expression.Parameter(typeof(string), "left"); 
     var right = Expression.Parameter(typeof(string), "right"); 

     Expression[] parms = new Expression[] { right, 
       Expression.Constant(StringComparison.OrdinalIgnoreCase) }; 

     var call = Expression.Call(left, method, parms); 
     var lambda = Expression.Lambda<Func<string, string, int>> 
      (call, left, right); 

     var compiled = lambda.Compile(); 
     Console.WriteLine(compiled.Invoke("hello THERE", "lo t")); 
    } 
} 

Answer 2

nie sprawdzić resztę, ale jeśli tylko enum stwarza problemy:

Expression.Constant(StringComparison.OrdinalIgnoreCase) 

lub

Expression.Constant(Enum.Parse(typeof(StringComparison), "OrdinalIgnoreCase"), typeof(Enum)); 

i masz więcej opcji. Lub sprawdź moją odpowiedź here.

Edytuj: zapomniałem o namaszczeniu.

Answer 3

Najprostszym sposobem na to byłoby je zdobyć poprzez lambda tak:

//the compiler will convert the lambda into an expression 
Expression<Func<string, string, int>> expression = (s1, s2) => s1.IndexOf(s2, StringComparison.OrdinalIgnoreCase); 
//compile the expression so we can call it 
var func = expression.Compile(); 
//outputs 2 
Console.WriteLine(func("Case Sensitive", "se sensitive")); 

Jest to o wiele bardziej czytelny i utrzymaniu niż ręcznie budowania drzewa wyrażenie.

Jestem nieustannie zaskoczony ilością ludzi, którzy nurkują bezpośrednio do ręcznego budowania drzew ekspresji. Nie ma potrzeby, aby kompilator mógł wykonać pracę za ciebie.