SQL Comme mot-clé dans Dynamic Linq

Question

Je souhaite utiliser le mot-clé Like de SQL dans LINQ dynamique.

La requête que je veux faire est comme ça

select * from table_a where column_a like '%search%' 

Lorsque le column_a peut être modifié de manière dynamique à autre colonne etc

Dans cette LINQ dynamique

var result = db.table_a.Where(a=> (a.column_a.Contains("search"))); 

Mais la colonne ne peut pas être modifié dynamiquement, seule la touche de recherche peut

Comment pouvons-nous créer un LINQ dynamique comme

var result = db.table_a.Where("column_a == \"search\""); 

que nous pouvons changer la colonne et la clé de recherche dynamique

Answer 1

Créer une classe ExtensionMethods avec cette fonction

public static IQueryable<T> Like<T>(this IQueryable<T> source, string propertyName, string keyword) 
    { 
     var type = typeof(T); 
     var property = type.GetProperty(propertyName); 
     string number = "Int"; 
     if (property.PropertyType.Name.StartsWith(number)) 
      return source; 

     var parameter = Expression.Parameter(type, "p"); 
     var propertyAccess = Expression.MakeMemberAccess(parameter, property); 
     var constant = Expression.Constant("%" + keyword + "%"); 
     MethodCallExpression methodExp = Expression.Call(null, typeof(SqlMethods).GetMethod("Like", new Type[] { typeof(string), typeof(string) }), propertyAccess, constant); 
     Expression<Func<T, bool>> lambda = Expression.Lambda<Func<T, bool>>(methodExp, parameter); 
     return source.Where(lambda); 
    } 

Et puis appelez comme ceci:

var result = db.table_a.Like("column_a", "%search%"); 

Answer 2

http://weblogs.asp.net/rajbk/archive/2007/09/18/dynamic-string-based-queries-in-linq.aspx

Addition:

Utilisez un arbre d'expression How do I create an expression tree to represent 'String.Contains("term")' in C#? C'est ce que la bibliothèque linq dynamique fait en interne.

Answer 3

Je ne crois pas qu'il existe une traduction directe vers SQL pour le mot-clé LIKE dans LINQ. Vous pourriez en construire un si vous utilisiez des arbres d'expression, mais je n'ai pas encore réussi.

Ce que je fais est quelque chose comme ceci:

using System.Data.Linq.SqlClient; 

if (!string.IsNullOrEmpty(data.MailerName)) 
    search = search.Where(a => SqlMethods.Like(a.Mailer.Name, string.Format("%{0}%", data.MailerName))); 

où search est la requête que je construis et data est l'objet contenant les propriétés qui maintiennent les critères de recherche. Je crée la requête dynamiquement en listant tous les critères de recherche possibles de cette manière, ce qui ajoute les méthodes Where appropriées à search.

Answer 4

Cela devrait fonctionner pour vous:

.Where("AColumnName.Contains(@0)", "Criteria") 

Answer 5

Peut-être un peu en retard, mais Une autre approche consiste à ajouter une méthode d'extension qui utilise Contains pour simuler Like mot-clé comme:

public static class DbHelpers 
    { 
     public static IQueryable<T> Like<T>(this IQueryable<T> source, string propertyName, string propertyValue) 
     { 
      var prop = typeof(T).GetProperty(propertyName); 
      if (prop == null || prop.PropertyType.Name.StartsWith("Int")) 
       return source; 

      ParameterExpression parameter = Expression.Parameter(typeof(T), "row"); 
      Expression property = Expression.Property(parameter, propertyName); 
      Expression value = Expression.Constant(propertyValue); 

      var containsmethod = value.Type.GetMethod("Contains", new[] { typeof(string) }); 
      var call = Expression.Call(property, containsmethod, value); 
      var lambda = Expression.Lambda<Func<T, bool>>(call, parameter); 
      return source.Where(lambda); 
     } 
    } 

et l'utilisation de celui-ci:

var foo = entity.AsQueryable().Like("Name", "bla bla"); 

Si envoyer PropertyName avec le type de int, la méthode retour entité originale que vous avez passé avant lui.