La recherche LINQ utilisant le caractère WildCards comme *,% ,?

Question

Salut J'ai une collection d'objets de type nom et je veux y effectuer une recherche par caractère générique. Par exemple, si je fournis un critère de recherche *ABC, le nom renvoyé doit commencer par ABC. Si je fournis un critère de recherche ABC*, le nom retourné doit se terminer par ABC. Si je fournis un critère de recherche *ABC*, le nom renvoyé doit contenir ABC. Si je fournis un critère de recherche ?ABC, les deuxième, troisième et quatrième caractères renvoyés doivent être respectivement ABC et le premier caractère peut être n'importe quel caractère.

Answer 1

est ici une méthode d'extension, vous pouvez utiliser

public static class EnumerableExtensions 
{ 
    public static IEnumerable<T> MatchesWildcard<T>(this IEnumerable<T> sequence, Func<T,string> expression, string pattern) 
    { 
     var regEx = WildcardToRegex(pattern); 

     return sequence.Where(item => Regex.IsMatch(expression(item), regEx)); 
    } 

    public static string WildcardToRegex(string pattern) 
    { 
     return "^" + Regex.Escape(pattern). 
     Replace("\\*", ".*"). 
     Replace("\\?", ".") + "$"; 
    } 
} 

utiliser comme suit:

void Main() 
{ 
    var items = new[] { new MyObj { MyProperty = "ABC123" }, 
         new MyObj { MyProperty = "123ABC" }, 
         new MyObj { MyProperty = "123ABC456" }, 
    }; 

    var matches = items.MatchesWildcard(item => item.MyProperty, "???ABC"); 
} 

public class MyObj 
{ 
    public string MyProperty {get;set;} 
} 

(WildcardToRegex pris de CodeProject)

Answer 2

Je pense que vous devez utiliser .Contains, .StartWith, .EndsWith

Answer 3

Je pense que vous avez besoin Regex.Escape et Regex.IsMatch().

private IEnumerable<Item> FilterList(IEnumerable<Item> list, string query) 
{ 
    string pattern = QueryToRegex(query); 

    return list.Where(i => Regex.IsMatch(i.Name, pattern, RegexOptions.Singleline)); 
} 

private static string QueryToRegex(string query) 
{ 
    return "^" + Regex.Escape(query).Replace("\\*", ".*").Replace("\\?", ".") + "$"; 
} 

Note: Samuel Jack's answer était mieux que son Regex valait mieux, si honteusement fixé ici.

Answer 4

Cette article listes une méthode d'extension qui est également compatible avec Entity Framework et LINQ-to-entities.

Exemple d'utilisation:

var searchTerm = "*Inc"; 
var q = db.Customers 
     .WhereLike(c => c.CompanyName, searchTerm, '*') 
     .ToList(); 

code source:

using System; 
using System.Collections.Generic; 
using System.Data; 
using System.Data.Objects; 
using System.Data.Objects.DataClasses; 
using System.Linq; 
using System.Linq.Expressions; 
using System.Reflection; 

    public static class LinqExtensions 
    { 
     public static IQueryable<TSource> WhereLike<TSource>(
      this IQueryable<TSource> source, 
      Expression<Func<TSource, string>> valueSelector, 
      string value, 
      char wildcard) 
     { 
      return source.Where(BuildLikeExpression(valueSelector, value, wildcard)); 
     } 

     public static Expression<Func<TElement, bool>> BuildLikeExpression<TElement>(
      Expression<Func<TElement, string>> valueSelector, 
      string value, 
      char wildcard) 
     { 
      if (valueSelector == null) 
       throw new ArgumentNullException("valueSelector"); 

      var method = GetLikeMethod(value, wildcard); 

      value = value.Trim(wildcard); 
      var body = Expression.Call(valueSelector.Body, method, Expression.Constant(value)); 

      var parameter = valueSelector.Parameters.Single(); 
      return Expression.Lambda<Func<TElement, bool>>(body, parameter); 
     } 

     private static MethodInfo GetLikeMethod(string value, char wildcard) 
     { 
      var methodName = "Contains"; 

      var textLength = value.Length; 
      value = value.TrimEnd(wildcard); 
      if (textLength > value.Length) 
      { 
       methodName = "StartsWith"; 
       textLength = value.Length; 
      } 

      value = value.TrimStart(wildcard); 
      if (textLength > value.Length) 
      { 
       methodName = (methodName == "StartsWith") ? "Contains" : "EndsWith"; 
       textLength = value.Length; 
      } 

      var stringType = typeof(string); 
      return stringType.GetMethod(methodName, new Type[] { stringType }); 
     } 
    }