通配符搜索皇宫

Question

我想知道如果这是可以做到的通配符的搜索中使用皇宫.

我看到皇宫已经包含StartsWith,endswith操作符，等等。

如果有什么我想要的东西喜欢%测试，如果%它的工作%，我该怎么做？

关于

Answer 1

我将使用正则表达式，因为你可能并不总是使用LINQ到SQL。

像的LINQ的这个例子中，以对象

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);
}

Answer 2

可以使用 SqlMethods.Like （）。

的使用的一个示例：

var results =
        from u in users
        where SqlMethods.Like(u.FirstName, "%John%")
        select u;

Answer 3

添加System.Data.Linq.SqlClient您使用或进口，然后列表尝试：

var results= from x in data
             where SqlMethods.Like(x.SearchField, “%something%like%this%”)
             select x;

Answer 4

对于 Entity Framework Core 2.0 那里是 LIKE 操作员(宣布在八月2017):

var query = from e in _context.Employees
                    where EF.Functions.Like(e.Title, "%developer%")
                    select e;

Answer 5

综观问题

  

如果我想类似％测试，如果％，该作品％，我该怎么办呢？

然后我期待的东西。

LIKE '%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();

然后我会发现，同时包含所有记录“测试如果”和“它的工作”，，但没有具体的顺序的。

因此，与包含这是不可能的。但的IndexOf 是

的IndexOf将定位搜索字符串并返回字符串中的它的位置。使得能够找到的话以正确的顺序。

- 更新 -

使用我原来的答复这不是我的目标是提供一个通用的解决方案，而是另一种方法，是不是SQL dependend一个例子。因此，它是正确的，因为原来的例子只回答了文字的问题。但是，因为答案可能是，如果它是通用的更加有用，我已经写了一个IQuerable扩展，允许一个像声明那样容易添加到查询的WHERE语句。扩展既适用于作为的LINQ LINQ的-SQL。

这会发现这两个 “测试如果” 和 “它的工作”，按照这个顺序的所有记录。

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。但我不知道。我使用实体框架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))

关于性能，似乎有什么是“好”的一些讨论：喜欢或CHARINDEX。从我读过CHARINDEX似乎是最喜欢的。

Answer 6

.Where( column LIKE "Pattern")

Answer 7

var result = (from x in db.Members
              where x.IDNumber.Contains(idnumber)
              && x.InstitutionIdentifier == institution.Identifier
              select x).ToList();
return result;

，才能既为LINQ的工作，以在存储器SQL和LINQ。

Answer 8

我知道这是老话题，但这里是我最简单的解决方案：

string s=Regex.Escape("pattern - escaped for sanity").Replace("%", ".*").Replace("_", ".?");
user => Regex.IsMatch(user.FullName, s, RegexOptions.CultureInvariant | RegexOptions.IgnoreCase);

在此代码，我使用的常见转义字符为SQL语言。 如果你想用说*和?，躲过字符串将包含\*和\?相应地，确保包括在.Replace(...)声明（S）的反斜杠的角色。 当然，如果你想给你的用户RexEx搜索的能力，只是不逃避模式字符串。

搜索的Regex教程的其他选项。

我相信通常%将匹配的的至少一个字符，而正则表达式.*将匹配的零个或多个字符。因此，在现实中，%通配符更像.+（贪婪），而不是.*（懒惰）。

希望这有助于。

Answer 9

不知道，如果你说话LinqToSql或只是LINQ ...但你可以正则表达式是这样的：

.Where(dto => System.Text.RegularExpressions.Regex.IsMatch(dto.CustomerName, @"Ad"));

Answer 10

中。净码包括皇宫的对象，我使用执行情况 IsSqlLikeMatch 功能离线程 使用Regex创建一个SQL的"喜欢"等功能。.

例的使用

bool ret = message.IsSqlLikeMatch(pattern);

更多详细信息在我的帖子 SQL的"喜欢"的模式，以比较。净

Answer 11

您还可以使用 “包含”

var myresult = db.MyItems.Where(x=>x.MyField.Contains(mysearchstring));

Answer 12

你说的LINQ到对象或LINQ to SQL的？

有关LINQ的对象，你必须诉诸正则表达式我想。