select * from customers where (category = 4);

select * from customers where (category = 4 or category = 8);

select * from customers where (category = 4 or category = 8 or category = 9);

var result = from c in customers where categories.Contains(c.category)

var result = from c in customers select c;
if (categories.Length > 0)
{
  result = from r in result where categories.Contains(r.category) select r;
}

if (!name.IsNullOrEmpty)
{
  result = from r in result where r.name == name select r;
}
...

context.Log = Console.Out;

select * from customers where category = 4;

select * from customers where category = 4 and category = 8;

select * from customers where category = 4 and category = 8 and category = 9;

select * from customers;

List<int> categories = new List<int>(){4,8}; //на самом деле массив передается в качестве параметра и содержит произвольный набор категорий и может быть пустым

//дальше идет псевдокод

var result;
foreach(int cat in categories)
{
    result = customers.Where(r => r == cat);
}
result = result.Select();

J_K>select * from customers where category = 4;

J_K>select * from customers where category = 4 and category = 8;

J_K>select * from customers where category = 4 and category = 8 and category = 9;

J_K>select * from customers;
J_K>

J_K>List<int> categories = new List<int>(){4,8}; //на самом деле массив передается в качестве параметра и содержит произвольный набор категорий и может быть пустым

J_K>//дальше идет псевдокод

J_K>var result = customers;
J_K>foreach(int cat in categories)
J_K>{
J_K>    result = result.Where(r => r == cat);
J_K>}
J_K>//result = result.Select();
J_K>

result = customers.Where(c => categories.Contains(c.category));

List<int> targetCategories = new List<int>();
// Заполняем
var p = from с in Cusromers where targetCategories.Contains(с.category);

var result = from c in customers select c;
if (categories.Length > 0)
{
  result = from r in result where categories.Contains(r.category) select r;
}

if (!name.IsNullOrEmpty)
{
  result = from r in result where r.name == name select r;
}

using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Linq.Expressions;

namespace LinqDynamicExpression
{
    class Program
    {
        static void Main(string[] args)
        {
            using (var dc = new TestDataContext())
            {
                dc.Customers.DeleteAllOnSubmit(dc.Customers);
                dc.Customers.InsertAllOnSubmit(new[]
                {
                    new Customer {CategoryId = 1},
                    new Customer {CategoryId = 3},
                    new Customer {CategoryId = 10},
                    new Customer {CategoryId = 11},
                });
                dc.SubmitChanges();

                dc.Log = Console.Out;

                var categories = new[] {1, 2, 3};

                var result = dc.Customers
                    .Where(categories.BuildContainsAnalogue<Customer, int>(c => c.CategoryId))
                    .ToList();

                Debug.Assert(result.Count == 2);
                Debug.Assert(result.All(c => categories.Contains(c.CategoryId)));
            }
        }
    }

    public static class ContainsAnalogue
    {
        public static Expression<Func<T, bool>> BuildContainsAnalogue<T, C>(
            this IEnumerable<C> collection,
            Expression<Func<T, C>> propertyLambda)
        {
            var propertyGetter = propertyLambda.Body;

            var firstElem = Expression.Constant(collection.First(), typeof(C));
            var orChain = Expression.Equal(propertyGetter, firstElem);

            foreach (var item in collection.Skip(1))
            {
                var curElem = Expression.Constant(item, typeof(C));
                orChain = Expression.Or(orChain, Expression.Equal(propertyGetter, curElem));
            }

            return Expression.Lambda<Func<T, bool>>(orChain, propertyLambda.Parameters);
        }
    }
}

SELECT [t0].[Id], [t0].[CategoryId]
FROM [dbo].[Customer] AS [t0]
WHERE ([t0].[CategoryId] = @p0) OR ([t0].[CategoryId] = @p1) OR ([t0].[CategoryId] = @p2)
-- @p0: Input Int (Size = 0; Prec = 0; Scale = 0) [1]
-- @p1: Input Int (Size = 0; Prec = 0; Scale = 0) [2]
-- @p2: Input Int (Size = 0; Prec = 0; Scale = 0) [3]