"O" equivalente en Linq Where () expresión lambda

¿Existe un método en Linq donde pueda usar para construir cadenas SQL como "... donde (a = 1) OR (a = 2)"?

Ciertamente puede hacerlo dentro de una cláusula Where (método de extensión). Sin embargo, si necesita crear una consulta compleja de forma dinámica, puede utilizar 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 );

Puede usar los operadores booleanos estándar de .NET en su cláusula where única:

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

Usas los mismos operadores que en C # ===> || para "o" && para "y", etc.

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

en su .Where()llamada se debe usar el estándar de Boole 'O' operador, ||.

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

Todo lo que hace la llamada Where es una comparación booleana de cualquier cosa que desee, por lo que puede completarla con tanta lógica condicional como desee.

Si no conoce el recuento de parámetros, puede usar esto:

Data de muestra

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";

Código

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

Esto está integrado en .net ahora, no estoy seguro si antes no lo estaba. Dada una consulta Linq existente, puede agregar una cláusula where que tome una matriz de cadenas (SearchStrings) y verificar si alguna de ellas coincide con el objeto de la colección que está buscando. El uso de ToLower () solo se asegura de evitar la distinción entre mayúsculas y minúsculas en las consultas SQL.

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

Puede hacer lo mismo para un predicado "y" haciendo coincidir todas las palabras de la matriz con el objeto de la colección.

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

En este ejemplo, i se correlaciona con cada objeto de una colección y s se correlaciona con cada cadena de la matriz SearchStrings.