LINQ multiple where clause

J'ai une table dont j'ai besoin pour faire une recherche basée sur les mots-clés tapés dans la zone de recherche.
Voici un exemple de requête:

SELECT * FROM Courses WHERE 
Title LIKE '%word%' OR Title LIKE '%excel%' OR 
Contents LIKE '%word%' OR Contents LIKE '%excel%'

Comment puis-je convertir ce en LINQ où LINQ serait de générer dynamiquement OÙ consolidés sur la base de chacun des mots clés.

J'ai essayé de l'utilisateur PredicateBuilder il fonctionne très bien tant que le champ est de type VARCHAR. Pour le "TEXTE" les guillemets ne sont pas générés provoquant ainsi le compilateur pour donner un message d'erreur. Voici le code SQL généré par PredicateBuilder

SELECT [t0].[CoursesID], [t0].[Title], [t0].[Contents], [t0].[Active], 
FROM [dbo].[Courses] AS [t0]
WHERE ([t0].[Title] LIKE '%word%') OR ([t0].[Contents] LIKE %word%) OR 
([t0].Title] LIKE '%excel%') OR ([t0].[Contents] LIKE %excel%)

Avis il n'y a pas un seul Devis pour la "table des Matières", qui est un champ de Texte dans la base de données.

Est-il un moyen facile de construire OÙ la déclaration et le fixer avec de la requête? Personne ne sait comment je peux le faire sans PredicateBuilder?

Merci d'avance.

source d'informationauteur Amir

linq where-clause

13

Puisque vous travaillez w/LINQ je suppose que vous êtes à l'encontre d'un de LINQ-to-SQL contexte de données à droite? Je n'ai pas de rechange DataContext traîner pour tester cela, mais cela devrait vous donner quelques idées.

Je ne sais pas si il vont à l'encontre de contexte de données, mais la plupart de ces sont plutôt des trucs de base (chaînage OU l'exploitant et qui Contient l'appel de la méthode) donc ça ne devrait pas causer de problème lorsque la requête se traduit par SQL.

J'ai d'abord créer une fonction personnalisée qui serait de construire mon prédicat:
```
Func<string, Func<DataItem, bool>> buildKeywordPredicate =
    keyword =>
        x => x.Title.Contains(keyword)
            || x.Contents.Contains(keyword);
```
C'est une fonction qui prend une chaîne unique mot-clé et ensuite de retour à une autre fonction qui prend un DataItem et vérifie par rapport à la clé.

En gros, si vous passez dans la "Pile", vous obtiendrez un prédicat: x => x.Title.Contains("Stack") || x.Contents.Contains("Stack").

Prochaine, car il y a beaucoup de mots-clés possibles et vous avez besoin d'une chaîne à une opération, j'ai créer une autre fonction d'assistance à la chaîne 2 prédicats avec un OU
```
Func<Func<DataItem,bool>, Func<DataItem, bool>, Func<DataItem, bool>> buildOrPredicate =
    (pred1, pred2) =>
        x => pred1(x) || pred2(x);
```
Cette fonction prend 2 prédicats et puis joignez-les avec un OU à l'opération.

Avoir ces 2 fonctions, je peux construire ma où le prédicat comme ceci:
```
foreach (var word in keywords) {            
    filter = filter == null
        ? buildKeywordPredicate(word)
        : buildOrPredicate(filter, buildKeywordPredicate(word));
}
```
La première ligne à l'intérieur de la boucle, fondamentalement, vérifie si le filtre est null. Si c'est le cas, nous voulons un simple mot-clé filtre construit pour nous.

D'autre si le filtre n'est pas null, il nous faut de la chaîne de filtres existants avec l'un OU de l'opération, nous avons donc passer le filtre existant et un nouveau mot-clé filtre à buildOrPredicate de le faire.

Et alors nous pouvons maintenant créer le cas OÙ une partie de la requête:
```
var result = data.Where(filter);
```
Passant dans le prédicat complexe que nous venons de construire.

Je ne sais pas si ce sera différent de l'utilisation de PredicateBuilder mais puisque nous sommes en reportant la requête de traduction de l'LINQ-to-SQL moteur, il ne devrait pas y avoir de problèmes.

Mais comme je l'ai dit, je havn't-il testé contre un vrai contexte de données, donc si il y a tous les problèmes que vous pouvez écrire dans les commentaires.

Voici l'application de console que j'ai construit pour tester: http://pastebin.com/feb8cc1e

Espérons que cette aide!

EDIT: Pour plus générique et réutilisable version qui consiste à utiliser de façon appropriée les Arbres d'Expression dans LINQ, découvrez Thomas Petricek du blog: http://tomasp.net/articles/dynamic-linq-queries.aspx
0

Comme prédicat constructeur ne sait pas la DB type de la propriété qui Contient la méthode est appelée, je suppose que cela pourrait être un problème à l'intérieur de linq to sql. Avez-vous essayé avec une normale de la requête (pas avec le prédicat constructeur) et une colonne de TEXTE avec Contient?

Vous devez vous connecter pour publier un commentaire.