LINQ 的通配符搜索
Posted
技术标签:
【中文标题】LINQ 的通配符搜索【英文标题】：Wildcard search for LINQ 【发布时间】：2010-11-05 15:19:06 【问题描述】：我想知道是否可以使用 LINQ 进行通配符搜索。
我看到 LINQ 有 Contains、StartsWith、EndsWith 等。
如果我想要 %Test if%it work% 之类的东西怎么办？
问候
【问题讨论】：
【参考方案1】：您可以使用SqlMethods.Like()。
用法示例：
var results =
from u in users
where SqlMethods.Like(u.FirstName, "%John%")
select u;
【讨论】：
这只适用于 LinqToSql 查询（使用的类应该很明显）。 很好，我也不知道有没有+1 哇，我从来不知道有一个 SqlMethods 类。 太糟糕了，它不能在 .NET Core 上运行。 （仅供参考，以防有人试图为他们的 c# UWP 找到修复程序）【参考方案2】：我会使用正则表达式，因为您可能并不总是使用 Linq to SQL。
就像这个 Linq to Objects 的例子
List<string> list = new List<string>();
list.Add("This is a sentence.");
list.Add("This is another one.");
list.Add("C# is fun.");
list.Add("Linq is also fun.");
System.Text.RegularExpressions.Regex regEx = new System.Text.RegularExpressions.Regex("This");
var qry = list
.Where<string>(item => regEx.IsMatch(item))
.ToList<string>();
// Print results
foreach (var item in qry)
Console.WriteLine(item);
【讨论】：
有点啰嗦-他可以只使用SqlMethods.Like 您总是假设您正在调用 SQL 数据库。如果您要查询在内存中创建的列表怎么办？ 他的问题是用SQL标记的 为特定问题提供通用解决方案并不是一件坏事。 @Dementic 除非它没有回答原始问题。【参考方案3】：将 System.Data.Linq.SqlClient 添加到您的使用或导入列表中，然后尝试：
var results= from x in data
where SqlMethods.Like(x.SearchField, “%something%like%this%”)
select x;
【讨论】：
【参考方案4】：对于Entity Framework Core 2.0，有LIKE 运算符（announced in August 2017）：
var query = from e in _context.Employees
where EF.Functions.Like(e.Title, "%developer%")
select e;
【讨论】：
【参考方案5】：看问题
如果我想要 %Test if%it work% 之类的东西怎么办？
那么我期待一些东西
LIKE '%Test if%it work%'
表示字符串必须包含“Test if”和“it work”，按此顺序。
这不起作用：
context.SomeTable.Where(s => s.Name.Contains("Test if%it work")).ToList();
如果我使用：
context.SomeTable.Where(s => s.Name.Contains("Test if") && s.Name.Contains("it work")).ToList();
然后我会找到所有同时包含“Test if”和“it work”的记录，但不按这个顺序。
所以使用 Contains 这是不可能的。但是使用 IndexOf 就是这样。
IndexOf 将定位搜索字符串并返回它在字符串中的位置。可以按正确的顺序找到单词。
-- 更新--
根据我的原始答案，我的目标不是提供通用解决方案，而是另一种不依赖 sql 的方法的示例。因此，原始示例仅回答字面问题是正确的。但是由于如果它是通用的答案可能会更有用，我编写了一个 IQuerable 扩展，它允许向查询中添加一个 like 语句，就像 where 语句一样简单。该扩展适用于 Linq 作为 Linq-Sql。
这将按顺序查找所有带有“Test if”和“it work”的记录。
context.SomeTable.Like("test if%it work", "Name").ToList();
listOfString.Like("test if%it work").ToList();
扩展，允许任意数量的通配符：
/// <summary>
/// Allow to search the string with wildcards.
/// </summary>
/// <typeparam name="T">String or an object with a string member.</typeparam>
/// <param name="q">Original query</param>
/// <param name="searchstring">The searchstring</param>
/// <param name="memberName">The name of the field or null if not a field.</param>
/// <returns>Query filtered by 'LIKE'.</returns>
public static IQueryable<T> Like<T>(this IQueryable<T> q, string searchstring, string memberName = null)
// %a%b%c% --> IndexOf(a) > -1 && IndexOf(b) > IndexOf(a) && IndexOf(c) > IndexOf(b)
var eParam = Expression.Parameter(typeof(T), "e");
MethodInfo methodInfo;
// Linq (C#) is case sensitive, but sql isn't. Use StringComparison ignorecase for Linq.
// Sql however doesn't know StringComparison, so try to determine the provider.
var isLinq = (q.Provider.GetType().IsGenericType && q.Provider.GetType().GetGenericTypeDefinition() == typeof(EnumerableQuery<>));
if (isLinq)
methodInfo = typeof(string).GetMethod("IndexOf", new[] typeof(string), typeof(StringComparison) );
else
methodInfo = typeof(string).GetMethod("IndexOf", new[] typeof(string) );
Expression expr;
if (string.IsNullOrEmpty(memberName))
expr = eParam;
else
expr = Expression.Property(eParam, memberName);
// Split the searchstring by the wildcard symbol:
var likeParts = searchstring.Split(new char[] '%' , StringSplitOptions.RemoveEmptyEntries);
for (int i = 0; i < likeParts.Length; i++)
MethodCallExpression e;
if (isLinq)
e = Expression.Call(expr, methodInfo, new Expression[] Expression.Constant(likeParts[i], typeof(string)), Expression.Constant(StringComparison.OrdinalIgnoreCase) );
else
e = Expression.Call(expr, methodInfo, Expression.Constant(likeParts[i], typeof(string)));
if (i == 0)
// e.IndexOf("likePart") > -1
q = q.Where(Expression.Lambda<Func<T, bool>>(Expression.GreaterThan(e, Expression.Constant(-1, typeof(int))), eParam));
else
// e.IndexOf("likePart_previous")
MethodCallExpression ePrevious;
if (isLinq)
ePrevious = Expression.Call(expr, methodInfo, new Expression[] Expression.Constant(likeParts[i - 1], typeof(string)), Expression.Constant(StringComparison.OrdinalIgnoreCase) );
else
ePrevious = Expression.Call(expr, methodInfo, Expression.Constant(likeParts[i - 1], typeof(string)));
// e.IndexOf("likePart_previous") < e.IndexOf("likePart")
q = q.Where(Expression.Lambda<Func<T, bool>>(Expression.LessThan(ePrevious, e), eParam));
return q;
由于它不需要 SqlMethods，我假设您可以将它用于任何数据库，例如 mysql 或 Postgresql。但我不确定。我确实使用 Entity Framework 6 对 Sql Server 进行了测试。上面的语句在 Sql Server 中生成了以下代码。
SELECT [Extent1].* FROM SomeTable AS [Extent1]
WHERE ((( CAST(CHARINDEX(N'test if', [Extent1].[Name]) AS int)) - 1) > -1)
AND ((( CAST(CHARINDEX(N'test if', [Extent1].[Name]) AS int)) - 1) <
(( CAST(CHARINDEX(N'it work', [Extent1].[Name]) AS int)) - 1))
关于性能，似乎有一些关于“更好”的讨论：LIKE 或 CHARINDEX。从我读过的内容来看，CHARINDEX 似乎是最喜欢的。
【讨论】：
您的答案不包含对如何在 LINQ 中实现通配符搜索的一般问题的答案，它只是回答了具体示例，不适用于任何其他情况。因此，它没有为问题提供有用的答案。 实际上我一直在寻找特定于 SQL 的答案，因为不得不编写额外的通用代码让我很恼火，因为我们将始终使用 SQL Server。不幸的是，当你展示了为什么 contains 不起作用时，你没有展示任何简单的东西。我要进行的比较是包含字符串之一。所以我希望能在那个字符串中添加一些简单的东西。看起来必须使用 SQLMethods.Like。【参考方案6】：我知道这是一个老话题，但这是我非常简单的解决方案：
string s=Regex.Escape("pattern - escaped for sanity").Replace("%", ".*").Replace("_", ".?");
user => Regex.IsMatch(user.FullName, s, RegexOptions.CultureInvariant | RegexOptions.IgnoreCase);
在这段代码中，我使用 SQL 语言的常见转义字符。
如果你想使用*和?，转义字符串将包含\*和\?，请确保在.Replace(...)语句中包含反斜杠字符.
当然，如果您想让您的用户能够进行 RexEx 搜索，请不要转义模式字符串。
搜索正则表达式教程以获取其他选项。
我相信通常% 将匹配至少一个字符，而RegEx .* 将匹配零个或多个 个字符。所以实际上，% 通配符更像.+（贪婪）而不是.*（懒惰）。
希望这会有所帮助。
【讨论】：
【参考方案7】：.Where( column LIKE "Pattern")
【讨论】：
【参考方案8】：var result = (from x in db.Members
where x.IDNumber.Contains(idnumber)
&& x.InstitutionIdentifier == institution.Identifier
select x).ToList();
return result;
适用于内存中的 Linq to SQL 和 Linq。
【讨论】：
【参考方案9】：不确定你说的是 LinqToSql 还是 linq……但你可以像这样的正则表达式：
.Where(dto => System.Text.RegularExpressions.Regex.IsMatch(dto.CustomerName, @"Ad"));
【讨论】：
【参考方案10】：在包括 LINQ to Objects 的 .Net 代码中，我正在使用线程 Using Regex to create a SQL's "like" like function. 中的 IsSqlLikeMatch 函数的实现。
使用示例
bool ret = message.IsSqlLikeMatch(pattern);
更多细节在我的帖子中 SQL's "like" patterns to compare in .Net
【讨论】：
【参考方案11】：你也可以使用“包含”
var myresult = db.MyItems.Where(x=>x.MyField.Contains(mysearchstring));
【讨论】：
【参考方案12】：您是在谈论 LINQ to objects 还是 LINQ to SQL？
对于 LINQ to 对象，您必须求助于 regular expressions 我认为。
【讨论】：
【参考方案13】：我用它来支持用户搜索中的“*”通配符过滤器。 （顺序无关紧要）：
if (!string.IsNullOrEmpty(SearchString))
List<String> containValues = new List<String>();
if (SearchString.Contains("*"))
String[] pieces = SearchString.Split("*");
foreach (String piece in pieces)
if (piece != "")
containValues.Add(piece);
if (containValues.Count > 0)
foreach(String thisValue in containValues)
Items = Items.Where(s => s.Description.Contains(thisValue));
else
Items = Items.Where(s => s.Description.Contains(SearchString));
【讨论】：
【参考方案14】：我扩展了 Ruard van Elburg 的示例来支持我的需求，并认为我会分享。它处理通配符，例如“a%”（startswith(a)）、“%b”（endswith(b)）、“a%b”（startswith(a) && endswith(b)）和“a%b% c" (startwith(a), indexof(a)
public static class LinqLikeExtension
/// <summary> Permits searching a string value with any number of wildcards. This was written
/// to handle a variety of EF wildcard queries not supported because the current version is
/// less tan EFv6.2, which has a .Like() method.
/// like in EFv6.</summary>
/// <typeparam name="T">String or an object with a string member.</typeparam>
/// <param name="query">Original query</param>
/// <param name="searchstring">The searchstring</param>
/// <param name="columnName">The name of the db column, or null if not a column.</param>
/// <returns>Query filtered by 'LIKE'.</returns>
/// <example>return iQueryableRows.Like("a", "ReferenceNumber");</example>
/// <example>return iQueryableRows.Like("a%", "ReferenceNumber");</example>
/// <example>return iQueryableRows.Like("%b", "ReferenceNumber");</example>
/// <example>return iQueryableRows.Like("a%b", "ReferenceNumber");</example>
/// <example>return iQueryableRows.Like("a%b%c", "ReferenceNumber");</example>
/// <remarks>Linq (C#) is case sensitive, but sql isn't. Use StringComparison ignorecase for Linq.
/// Keep in mind that Sql however doesn't know StringComparison, so try to determine the provider.</remarks>
/// <remarks>base author -- Ruard van Elburg from ***, modifications by dvn</remarks>
/// <seealso cref="https://***.com/questions/1040380/wildcard-search-for-linq"/>
public static IQueryable<T> Like<T>(this IQueryable<T> query, string searchstring, string columnName = null)
var eParam = Expression.Parameter(typeof(T), "e");
var isLinq = (query.Provider.GetType().IsGenericType && query.Provider.GetType().GetGenericTypeDefinition() == typeof(EnumerableQuery<>));
MethodInfo IndexOf, StartsWith, EndsWith, Equals;
MethodCallExpression mceCurrent, mcePrevious;
Expression method = string.IsNullOrEmpty(columnName) ? eParam : (Expression)Expression.Property(eParam, columnName);
var likeParts = searchstring.Split(new char[] '%' );
for (int i = 0; i < likeParts.Length; i++)
if (likeParts[i] == string.Empty) continue; // "%a"
if (i == 0)
if (likeParts.Length == 1) // "a"
Equals = isLinq
? Equals = typeof(string).GetMethod("Equals", new[] typeof(string), typeof(StringComparison) )
: Equals = typeof(string).GetMethod("Equals", new[] typeof(string) );
mceCurrent = isLinq
? Expression.Call(method, Equals, new Expression[] Expression.Constant(likeParts[i], typeof(string)), Expression.Constant(StringComparison.OrdinalIgnoreCase) )
: Expression.Call(method, Equals, Expression.Constant(likeParts[i], typeof(string)));
else // "a%" or "a%b"
StartsWith = isLinq
? StartsWith = typeof(string).GetMethod("StartsWith", new[] typeof(string), typeof(StringComparison) )
: StartsWith = typeof(string).GetMethod("StartsWith", new[] typeof(string) );
mceCurrent = isLinq
? Expression.Call(method, StartsWith, new Expression[] Expression.Constant(likeParts[i], typeof(string)), Expression.Constant(StringComparison.OrdinalIgnoreCase) )
: Expression.Call(method, StartsWith, Expression.Constant(likeParts[i], typeof(string)));
query = query.Where(Expression.Lambda<Func<T, bool>>(mceCurrent, eParam));
else if (i == likeParts.Length - 1) // "a%b" or "%b"
EndsWith = isLinq
? EndsWith = typeof(string).GetMethod("EndsWith", new[] typeof(string), typeof(StringComparison) )
: EndsWith = typeof(string).GetMethod("EndsWith", new[] typeof(string) );
mceCurrent = isLinq
? Expression.Call(method, EndsWith, new Expression[] Expression.Constant(likeParts[i], typeof(string)), Expression.Constant(StringComparison.OrdinalIgnoreCase) )
: Expression.Call(method, EndsWith, Expression.Constant(likeParts[i], typeof(string)));
query = query.Where(Expression.Lambda<Func<T, bool>>(mceCurrent, eParam));
else // "a%b%c"
IndexOf = isLinq
? IndexOf = typeof(string).GetMethod("IndexOf", new[] typeof(string), typeof(StringComparison) )
: IndexOf = typeof(string).GetMethod("IndexOf", new[] typeof(string) );
mceCurrent = isLinq
? Expression.Call(method, IndexOf, new Expression[] Expression.Constant(likeParts[i], typeof(string)), Expression.Constant(StringComparison.OrdinalIgnoreCase) )
: Expression.Call(method, IndexOf, Expression.Constant(likeParts[i], typeof(string)));
mcePrevious = isLinq
? Expression.Call(method, IndexOf, new Expression[] Expression.Constant(likeParts[i - 1], typeof(string)), Expression.Constant(StringComparison.OrdinalIgnoreCase) )
: Expression.Call(method, IndexOf, Expression.Constant(likeParts[i - 1], typeof(string)));
query = query.Where(Expression.Lambda<Func<T, bool>>(Expression.LessThan(mcePrevious, mceCurrent), eParam));
return query;
我知道这真的很晚了，我知道 EFv6.2+ 支持 Like() 方法。但也许你和我一样，在一家小商店里有大量遗留应用程序，很难简单地升级 .Net 和 EF 版本。
【讨论】：
以上是关于LINQ 的通配符搜索的主要内容，如果未能解决你的问题，请参考以下文章