Equivalente "Or" nell'espressione lambda Linq Where ()

Esiste un metodo in Linq in cui è possibile utilizzare per creare stringhe SQL come "... dove (a = 1) OR (a = 2)"?

Puoi certamente farlo all'interno di una clausola Where (metodo di estensione). Se è necessario creare una query complessa in modo dinamico, tuttavia, è possibile utilizzare un PredicateBuilder .

 var query = collection.Where( c => c.A == 1 || c.B == 2 );

O usando un PredicateBuilder

 var predicate = PredicateBuilder.False<Foo>();
 predicate = predicate.Or( f => f.A == 1 );
 if (allowB)
 {
    predicate = predicate.Or( f => f.B == 1 );
 }

 var query = collection.Where( predicate );

Puoi utilizzare gli operatori booleani .NET standard nella tua singola clausola where:

MyDataSource.Where(data => data.a == 'a' || data.a == 'b')

Si utilizzano tutti gli stessi operatori del normale C # ===> || per "o" && per "e" ecc.

var something = from s in mycollection
                where s.something == 32 || 
                      s.somethingelse == 45 
                select s

nella vostra .Where()chiamata utilizzare lo standard booleano 'O' operatore, ||.

var query = items.Where(item => (item == 1 || item == 2));

Tutto ciò che la chiamata Where fa è un confronto booleano su tutto ciò che desideri, quindi puoi riempirlo con tutta la logica condizionale che desideri.

Se non conosci il conteggio dei parametri, puoi usare questo:

Dati di esempio

var parameters= new List<string>{"a","d"};
var sampledata = new Dictionary<string,string>();
    sampledata["a"] = "A";
    sampledata["b"] = "B";
    sampledata["c"] = "C";
    sampledata["d"] = "D";

Codice

var query = sampledata.AsQueryable();
var firstItemKey = sampledata.FirstOrDefault().Key;
var queryresult= sampledata.Where(x => x.Key == firstItemKey).AsQueryable();
foreach (var parameter in parameters.Skip(1))
{
    queryresult=queryresult.Concat(query.Where(x => x.Key == parameter));
}
var result = queryresult.ToList();

Questo è integrato in .net ora, non sono sicuro se non lo fosse in precedenza. Data una query Linq esistente, puoi aggiungere una clausola where che accetta un array di stringhe (SearchStrings) e controllare se qualcuna di esse corrisponde a qualsiasi oggetto nella raccolta che stai cercando. L'uso di ToLower () assicura solo di evitare la distinzione tra maiuscole e minuscole nelle query SQL.

query.Where(i => SearchStrings.Any(s => i.ToLower().Contains(s.ToLower()));

Puoi fare la stessa cosa per un predicato "and" abbinando tutte le parole nell'array all'oggetto della raccolta.

query.Where(i => SearchStrings.All(s => i.ToLower().Contains(s.ToLower()));

In questo esempio i è correlato a ogni oggetto in una raccolta e s è correlato a ciascuna stringa nell'array SearchStrings.