我想知道是否可以使用 LINQ 进行通配符搜索。
我看到 LINQ 有 Contains、StartsWith、EndsWith 等。
如果我想要 %Test if%it work% 之类的东西怎么办，我该怎么做？
问候
问问题
65282 次
14 回答
82
您可以使用SqlMethods.Like()。
使用示例：
var results =
from u in users
where SqlMethods.Like(u.FirstName, "%John%")
select u;
于 2009-06-24T19:22:56.003 回答
41
我会使用正则表达式，因为您可能并不总是使用 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);
}
于 2009-06-24T19:27:14.453 回答
14
将 System.Data.Linq.SqlClient 添加到您的使用或导入列表中，然后尝试：
var results= from x in data
where SqlMethods.Like(x.SearchField, “%something%like%this%”)
select x;
于 2009-06-24T19:26:37.120 回答
13
对于Entity Framework Core 2.0有LIKE运营商（2017年8月宣布）：
var query = from e in _context.Employees
where EF.Functions.Like(e.Title, "%developer%")
select e;
于 2017-10-10T13:22:36.847 回答
6
看着问题
如果我想要 %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”的记录，但不是按照这个顺序。
所以使用包含这是不可能的。但是使用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 似乎是最喜欢的。
于 2017-02-17T21:24:57.617 回答
4
我知道这是一个老话题，但这是我非常简单的解决方案：
string s=Regex.Escape("pattern - escaped for sanity").Replace("%", ".*").Replace("_", ".?");
user => Regex.IsMatch(user.FullName, s, RegexOptions.CultureInvariant | RegexOptions.IgnoreCase);
在这段代码中，我使用 SQL 语言的常见转义字符。如果你想使用 say *and ?，转义字符串将包含相应的\*和\?，请确保在语句中包含反斜杠字符。.Replace(...)当然，如果您想让您的用户能够进行 RexEx 搜索，请不要转义模式字符串。
搜索正则表达式教程以获取其他选项。
我相信通常%会匹配至少一个字符，而 RegEx.*将匹配零个或多个字符。所以实际上，%通配符更像是.+（贪婪）而不是.*（懒惰）。
希望这可以帮助。
于 2014-01-09T00:39:37.297 回答
3
.Where( column LIKE "Pattern")
于 2009-06-24T19:23:52.320 回答
2
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。
于 2012-10-08T19:58:30.900 回答
1
不知道你说的是 LinqToSql 还是 linq ......但你可以像这样的正则表达式：
.Where(dto => System.Text.RegularExpressions.Regex.IsMatch(dto.CustomerName, @"Ad"));
于 2009-06-24T19:26:16.200 回答
1
在包括 LINQ to Objects 的 .Net 代码中，我正在使用线程中的 IsSqlLikeMatch函数的实现使用正则表达式来创建 SQL 的“类似”函数。.
使用示例
bool ret = message.IsSqlLikeMatch(pattern);
在我的帖子SQL 的“喜欢”模式中有更多详细信息， 以便在 .Net 中进行比较
于 2012-11-04T16:57:58.377 回答
1
您也可以使用“包含”
var myresult = db.MyItems.Where(x=>x.MyField.Contains(mysearchstring));
于 2013-07-10T23:11:08.107 回答
0
您是在谈论 LINQ to objects 还是 LINQ to SQL？
对于 LINQ to 对象，您将不得不求助于我认为的正则表达式。
于 2009-06-24T19:24:25.300 回答
0
我用它来支持用户搜索中的“*”通配符过滤器。（顺序无关紧要）：
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));
}
}
于 2019-08-20T23:57:42.050 回答
0
我扩展了 Ruard van Elburg 的例子来支持我的需求，并认为我会分享。它处理通配符，例如“a%”（startswith(a)）、“%b”（endswith(b)）、“a%b”（startswith(a) && endswith(b)）和“a%b% c" (startwith(a), indexof(a) < indexof(b), & endwith(c) )。
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 StackOverflow, modifications by dvn</remarks>
/// <seealso cref="https://stackoverflow.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 版本。
于 2020-01-24T13:48:27.133 回答