C# problème avec LINQ sensible à la casse

Question

J'ai ceci:

var sortName = Request.Params["sortName"]; 
var query = Request.Params["query"]; 

Func<UsuarioEndereco, bool> whereClause = (uen => uen.GetPropValue<string>(sortName).Contains(query)); 

Le "uen.GetPropValue<string>(sortName)" sera rempli dynamiquement avec le sortName l'utilisateur a tapé dans la page.

Par exemple, si un utilisateur recherche une personne nommée « Joe », l'extrait sera:

(uen => uen.namePerson.Contains(Joe)) 

Mais, je vais avoir des problèmes avec LINQ recherches sensibles à la casse. Si je tape "Joe", je ferai quelque chose. D'un autre côté, si je tape "Joe", ça n'apporte rien.

Comment puis-je faire ce "Contient (sortName)" fonctionne avec Case-Insensitive ?? J'ai essayé certaines choses avec String.Comparer mais il signale des erreurs sur la solution de construction.

Merci!

Answer 1

je crois que le suivant va générer une bonne SQL:

uen=>(uen.GetPropValue<string>(sortName)).ToLower().Contains(query.ToLower())) 

Answer 2

Si cela est vraiment LINQ to SQL, essayez d'utiliser la méthode SqlMethods.Like au lieu de String.Contains.

Cependant, je pense que le problème est que ce n'est pas LINQ-to-SQL, parce que vous utilisez des délégués au lieu d'arbres d'expression. Donc, ceci est amené côté client, puis exécuté localement ("LINQ to Objects"). Par conséquent, String.Contains fait ce qu'il fait localement. De cette façon, la réponse de James est correcte, puisqu'il appelle ToLower() à la fois sur la valeur et la requête. (Bien que, méfiez-vous des questions de culture - peut-être préciser que la culture que vous voulez.)

Answer 3

Voici le code entier:

var sortOrder = Request.Params["sortorder"];  
var sortName  = Request.Params["sortname"]; 
var query  = Request.Params["query"]; 

IEnumerable<UsuarioEndereco> pagedEndereco; 

Func<UsuarioEndereco, bool> whereClause = (uen => uen.GetPropValue<string>(sortName).Contains(query)); 
pagedEndereco = sortOrder.Equals("asc", StringComparison.CurrentCultureIgnoreCase) ? 
         _agendaServico.SelecionaUsuarioEnderecos(u.codUsuario).Where(whereClause).OrderByDescending(uen => uen.GetPropValue<IComparable>(sortName)) : 
         _agendaServico.SelecionaUsuarioEnderecos(u.codUsuario).Where(whereClause).OrderBy(uen => uen.GetPropValue<IComparable>(sortName)); 

La Méthode d'extension GetPropValue est:

public static T GetPropValue<T>(this object component, string propertyName) 
{ 
    return (T)TypeDescriptor.GetProperties(component)[propertyName].GetValue(component); 
} 

Answer 4

Vous pouvez également utilisez la méthode String.IndexOf (String, Int32, StringComparison) (http://msdn.microsoft.com/en-us/library/ms224424.aspx). Cette méthode vous permet de spécifier si la correspondance doit être sensible à la casse ou non, et si elle doit utiliser une culture Invariant ou non.

Donc, dans votre exemple:

Func<UsuarioEndereco, bool> whereClause = (uen => uen.GetPropValue<string>(sortName).IndexOf(query, 0, StringComparison.OrdinalIgnoreCase)); 

Je ne suis pas des commentaires sur si cela est une meilleure solution que celle fournie par James Curran. Cela pourrait ou ne pourrait pas être, performance sage.