"Oder" -Äquivalent in Linq Where () Lambda-Ausdruck

Gibt es in Linq eine Methode, mit der Sie SQL-Zeichenfolgen wie "... wo (a = 1) ODER (a = 2)" erstellen können?

Sie können dies sicherlich innerhalb einer Where-Klausel (Erweiterungsmethode) tun. Wenn Sie jedoch eine komplexe Abfrage dynamisch erstellen müssen, können Sie einen PredicateBuilder verwenden .

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

Oder mit einem 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 );

Sie können die standardmäßigen booleschen .NET-Operatoren in Ihrer einzelnen where-Klausel verwenden:

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

Sie verwenden dieselben Operatoren wie in normalem C # ===> || für "oder" && für "und" etc.

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

.Where()Verwenden Sie in Ihrem Anruf den Standard-Booleschen Operator 'Oder' ||.

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

Der Where-Aufruf ist lediglich ein boolescher Vergleich für alles, was Sie möchten, sodass Sie ihn mit so viel bedingter Logik füllen können, wie Sie möchten.

Wenn Sie die Anzahl der Parameter nicht kennen, können Sie Folgendes verwenden:

Beispieldaten

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

Dies ist jetzt in .net integriert, nicht sicher, ob es vorher nicht war. Bei einer vorhandenen Linq-Abfrage können Sie eine where-Klausel hinzufügen, die ein Array von Zeichenfolgen (SearchStrings) enthält, und prüfen, ob eine dieser Zeichenfolgen mit dem Objekt in der Sammlung übereinstimmt, nach der Sie suchen. Durch die Verwendung von ToLower () wird lediglich sichergestellt, dass bei SQL-Abfragen die Groß- und Kleinschreibung nicht berücksichtigt wird.

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

Sie können dasselbe für ein 'und' Prädikat tun, indem Sie alle Wörter im Array mit dem Objekt der Sammlung abgleichen.

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

In diesem Beispiel korreliert i mit jedem Objekt in einer Sammlung und s mit jeder Zeichenfolge im SearchStrings-Array.