Comment rechercher efficacement plusieurs mots-clés dans un champ de base de données à l'aide de Lambda/LINQ ?

Recherche de champs dans la base de données multi-mots Lambda/LINQ

Cet article explique comment utiliser les expressions Lambda/LINQ pour rechercher efficacement plusieurs mots-clés dans les champs de base de données (tels que les champs Commentaires) en même temps. La méthode traditionnelle Contains ne peut rechercher qu'un seul mot-clé à la fois, tandis que la méthode fournie dans cet article peut traiter plusieurs mots-clés en même temps.

À l'aide d'expressions Lambda, vous pouvez écrire des requêtes comme celle-ci :

<code class="language-csharp">var newList = MainList.Where(m => m.Comments.Contains(purposes));</code>

Cependant, si vous devez rechercher plusieurs mots-clés, des techniques plus avancées sont nécessaires. Pour cela, nous avons développé une méthode d'extension :

<code class="language-csharp">public static IQueryable<T> FilterByItems<T, TItem>(this IQueryable<T> query, IEnumerable<TItem> items,
    Expression<Func<T, TItem, bool>> filterPattern, bool isOr)</code>

Cette méthode d'extension reçoit la liste principale MainList, la liste de mots-clés items, une expression Lambda filterPattern (utilisée pour vérifier si le mot-clé existe dans le champ Comments), et une valeur booléenne isOr (spécifie l'utilisation des opérateurs OR ou AND pour faire correspondre les mots-clés).

Par exemple :

<code class="language-csharp">var newList = MainList
    .FilterByItems(keywords, (m, k) => m.Comments.Contains(k), true)
    .ToList();</code>

Cette requête renverra une liste d'enregistrements dont le champ Comments contient un mot-clé de la liste keywords.

Implémentation de la méthode d'extension FilterByItems

La méthode d'extension

FilterByItems exploite la classe ExpressionReplacer pour modifier récursivement une expression afin de remplacer des parties spécifiques par la valeur souhaitée.

Ce qui suit est l'implémentation de la classe ExpressionReplacer :

<code class="language-csharp">public static class QueryableExtensions
{
    public static IQueryable<T> FilterByItems<T, TItem>(this IQueryable<T> query, IEnumerable<TItem> items,
        Expression<Func<T, TItem, bool>> filterPattern, bool isOr)
    {
        Expression predicate = null;
        foreach (var item in items)
        {
            var itemExpr = Expression.Constant(item);
            var itemCondition = ExpressionReplacer.Replace(filterPattern.Body, filterPattern.Parameters[1], itemExpr);
            if (predicate == null)
                predicate = itemCondition;
            else
            {
                predicate = Expression.MakeBinary(isOr ? ExpressionType.OrElse : ExpressionType.AndAlso, predicate,
                    itemCondition);
            }
        }

        predicate ??= Expression.Constant(false);
        var filterLambda = Expression.Lambda<Func<T, bool>>(predicate, filterPattern.Parameters[0]);

        return query.Where(filterLambda);
    }

    // ... (ExpressionReplacer class remains the same) ...
}</code>

Cette description améliorée explique plus clairement ce que fait le code et comment l'utiliser, et explique les sections clés plus en détail.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!