2012-07-19 16 views
7

Ho cercato di risolvere questo problema tutto il giorno e non ho trovato una soluzione che funzioni davvero. Quando cerco alcuni dati, voglio filtrare i dati in base a più parole.Query LINQ per corrispondere più parole

Il mio valore di input viene suddiviso utilizzando la funzione standard .Split.

string[] searchstrings = MessageResult.Split(' '); 

ho fatto una domanda (che ovviamente non funziona correttamente) che cerca di filtrare tutte le voci che riproduce ogni stringa nella searchstrings.

    var suggestions = (from a in query 
           from w in searchstrings 
           where a.Message.ToLower().Contains(w.ToLower()) 
           select a).Distinct(); 

query è la mia variabile che ha tutti i dati. Come posso fare in modo che questa query corrisponda effettivamente alle voci che includono ogni stringa in searchstrings?

+0

Per chiarire, si desidera che le stringhe dalla query contengano ogni stringa suddivisa, vale a dire ** ogni ** stringa in searchString deve essere nelle stringhe risultanti? – Breland

+0

se la domanda di @Breland è vera, questo cambierebbe .Contains to .All Mi piacerebbe vedere la query generata da quell'espressione – jjchiw

+0

quale dovrebbe essere il risultato finale? – Yasser

risposta

17

Penso che il codice qui sotto dovrebbe risolvere il tuo problema. Controlla se tutte le parole in searchstring sono in una query (a).

var suggestions = (from a in query 
        where searchstrings.All(word => a.ToLower().Contains(word.ToLower())) 
        select a); 
+0

Questo ha funzionato alla grande, grazie! – Alexander

16
var query = new string[] 
{ 
    "abc foo bar xyz john doe", 
    "abc foo bar xyz doe", 
    "hello world", 
    "abc foo bar john doe", 
}; 

var searchstrings = new string[] 
{ 
    "abc", 
    "foo", 
    "john", 
    "xyz", 
}; 

searchstrings = searchstrings.Select(x => x.ToLower()).ToArray(); 

var results = query.Select(x => x.ToLower()) 
        .Where(x => searchstrings.All(y => x.Contains(y))); 

Nota:
ToLower() viene eseguita al di fuori della clausola Where, per risparmiare un sacco di chiamate a quel metodo.

+3

+1 per refactoring della chiamata '.ToLower' ... –