"Or" equivalent in Linq Where() lambda expression

Is there a method in Linq where you can use to build SQL strings like "...where (a=1) OR (a=2)"?

You can certainly do it within a Where clause (extension method). If you need to build a complex query dynamically, though, you can use a PredicateBuilder.

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

Or using a 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 );

You can use the standard .NET boolean operators in your single where clause:

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

You use the all the same operators as in normal C# ===> || for "or" && for "and" etc.

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

in your .Where() call use the standard Boolean 'Or' operator, ||.

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

All the Where call does is a Boolean comparison on anything you want, so you can fill it with as much conditional logic as you wish.

If you don' t know parameter count, you can use this:

Sample Data

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

This is built into .net now, not sure if it previously wasn't. Given an existing Linq query you can add a where clause that takes an array of strings (SearchStrings), and check if any of them match whatever object in the collection you're search. Using ToLower() just makes sure that you avoid case sensitivity in SQL queries.

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

You can do the same thing for an 'and' predicate by matching all the words in the array to the collection's object.

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

In this example i correlates to each object in a collection, and s correlates to each string in the SearchStrings array.