¿Cómo creo un árbol de expresiones para representar 'String.Contains ("term")' en C#?

Question

Estoy empezando con los árboles de expresión, así que espero que tenga sentido. Estoy tratando de crear un árbol de expresión para representar:

t => t.SomeProperty.Contains("stringValue"); 

Hasta ahora he conseguido:

private static Expression.Lambda<Func<string, bool>> GetContainsExpression<T>(string propertyName, string propertyValue) 
    { 
     var parameterExp = Expression.Parameter(typeof(T), "type"); 
     var propertyExp = Expression.Property(parameter, propertyName); 
     var containsMethodExp = Expression.*SomeMemberReferenceFunction*("Contains", propertyExp) //this is where I got lost, obviously :) 
     ... 
     return Expression.Lambda<Func<string, bool>>(containsMethodExp, parameterExp); //then something like this 
    } 

Simplemente no sé cómo hacer referencia a los métodos() String.Contains.

Ayuda apreciada.

Answer 1

Algo así como:

class Foo 
{ 
    public string Bar { get; set; } 
} 
static void Main() 
{ 
    var lambda = GetExpression<Foo>("Bar", "abc"); 
    Foo foo = new Foo { Bar = "aabca" }; 
    bool test = lambda.Compile()(foo); 
} 
static Expression<Func<T, bool>> GetExpression<T>(string propertyName, string propertyValue) 
{ 
    var parameterExp = Expression.Parameter(typeof(T), "type"); 
    var propertyExp = Expression.Property(parameterExp, propertyName); 
    MethodInfo method = typeof(string).GetMethod("Contains", new[] { typeof(string) }); 
    var someValue = Expression.Constant(propertyValue, typeof(string)); 
    var containsMethodExp = Expression.Call(propertyExp, method, someValue); 

    return Expression.Lambda<Func<T, bool>>(containsMethodExp, parameterExp); 
} 

Puede que le resulte útil this.

Answer 2

¿Qué tal esto:

Expression<Func<string, string, bool>> expFunc = (name, value) => name.Contains(value); 

En el código de cliente:

bool result = expFunc.Compile()("FooBar", "Foo"); //result true 
    result = expFunc.Compile()("FooBar", "Boo");  //result false 

Answer 3

Para realizar una búsqueda como:

ef.Entities.Where(entity => arr.Contains(entity.Name)).ToArray(); 

la que será la serie de rastreo:

SELECT .... From Entities ... Where Name In ("abc", "def", "qaz") 

utilizo el método creé a continuación:

ef.Entities.Where(ContainsPredicate<Entity, string>(arr, "Name")).ToArray(); 

public Expression<Func<TEntity, bool>> ContainsPredicate<TEntity, T>(T[] arr, string fieldname) where TEntity : class { 
    ParameterExpression entity = Expression.Parameter(typeof(TEntity), "entity"); 
    MemberExpression member = Expression.Property(entity, fieldname); 

    var containsMethods = typeof(Enumerable).GetMethods(BindingFlags.Static | BindingFlags.Public) 
    .Where(m => m.Name == "Contains"); 
    MethodInfo method = null; 
    foreach (var m in containsMethods) { 
    if (m.GetParameters().Count() == 2) { 
     method = m; 
     break; 
    } 
    } 
    method = method.MakeGenericMethod(member.Type); 
    var exprContains = Expression.Call(method, new Expression[] { Expression.Constant(arr), member }); 
    return Expression.Lambda<Func<TEntity, bool>>(exprContains, entity); 
} 

Answer 4

Aquí está una muestra de criteria.Contains (MyParam)

var method = typeof(Enumerable).GetRuntimeMethods().Single(m => m.Name == nameof(Enumerable.Contains) && m.GetParameters().Length == 2); 
var containsMethod = method.MakeGenericMethod(typeof(string)); 
var doesContain = Expression.Call(containsMethod, Expression.Constant(criteria.ToArray()), Expression.Property(p, "MyParam")); 

El uso real en https://raw.githubusercontent.com/xavierjohn/Its.Cqrs/e44797ef6f47424a1b145d69889bf940b5581eb8/Domain.Sql/CatchupEventFilter.cs