«Ou» équivalent dans l'expression lambda Linq Where ()

Existe-t-il une méthode dans Linq où vous pouvez utiliser pour créer des chaînes SQL comme "... where (a = 1) OR (a = 2)"?

Vous pouvez certainement le faire dans une clause Where (méthode d'extension). Si vous avez besoin de créer dynamiquement une requête complexe, vous pouvez utiliser un PredicateBuilder .

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

Ou en utilisant 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 );

Vous pouvez utiliser les opérateurs booléens .NET standard dans votre clause where unique:

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

Vous utilisez tous les mêmes opérateurs que dans C normal # ===> || pour "ou" && pour "et" etc.

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

dans votre .Where()appel utiliser l' opérateur booléen standard « ou » opérateur ||.

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

Tout ce que fait l'appel Where est une comparaison booléenne sur tout ce que vous voulez, vous pouvez donc le remplir avec autant de logique conditionnelle que vous le souhaitez.

Si vous ne connaissez pas le nombre de paramètres, vous pouvez utiliser ceci:

Exemple de données

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

Code

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

Ceci est intégré dans .net maintenant, je ne sais pas si ce n'était pas le cas auparavant. Étant donné une requête Linq existante, vous pouvez ajouter une clause where qui prend un tableau de chaînes (SearchStrings) et vérifier si l'une d'entre elles correspond à n'importe quel objet de la collection que vous recherchez. L'utilisation de ToLower () garantit simplement que vous évitez le respect de la casse dans les requêtes SQL.

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

Vous pouvez faire la même chose pour un prédicat «et» en faisant correspondre tous les mots du tableau à l'objet de la collection.

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

Dans cet exemple, i correspond à chaque objet d'une collection et s correspond à chaque chaîne du tableau SearchStrings.