using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using System.Text.RegularExpressions;

using System.Net;

using System.IO;

using System.Security.Cryptography;

using System.Linq;

using System.Linq.Expressions;

public class Program

{

    public static void Main()

    {

        List<Player> players = new List<Player>();

        players.Add(new Player { Name = "a", IsActive = false, Bats = "L" });

        players.Add(new Player { Name = "b", IsActive = true, Bats = "L" });

        players.Add(new Player { Name = "c", IsActive = false, Bats = "R" });

        players.Add(new Player { Name = "d", IsActive = true, Bats = "R" });

        players.Add(new Player { Name = "e", IsActive = false, Bats = "B" });

        players.Add(new Player { Name = "f", IsActive = true, Bats = "B" });

        List<Expression<Func<Player, bool>>> evaluations = new List<Expression<Func<Player, bool>>>();

        evaluations.Add(_binaryCompare<Player>(Expression.Equal, "IsActive", true));

        //evaluations.Add(_binaryCompare<Player>(Expression.Equal, "Bats", "R"));

        evaluations.Add(_binaryContains<Player>("Bats", new List<object>() { "R", "B" }));

        IQueryable<Player> filtered = players.AsQueryable();

        foreach (var eval in evaluations) 

        {

            filtered = filtered.Where<Player>(eval);

        }

        foreach (var p in filtered) 

        {

            Console.WriteLine(p.Name);

        }

    }

    private static Expression<Func<T, bool>> _binaryCompare<T>(Func<Expression, Expression, BinaryExpression> operation, string propertyName, object filterValue)

    {

        var param = Expression.Parameter(typeof(T));

        var prop = Expression.Property(param, propertyName);

        var propValue = Expression.Constant(Convert.ChangeType(filterValue, prop.Type));

        return Expression.Lambda<Func<T, bool>>(operation(prop, propValue), param);

    }

    private static Expression<Func<T, bool>> _binaryContains<T>(string propertyName, List<object> values)

    {

        var param = Expression.Parameter(typeof(T));

        MemberExpression property = Expression.PropertyOrField(param, propertyName);

        var micontain = typeof(List<object>).GetMethod("Contains");

        var mc = Expression.Call(Expression.Constant(values), micontain, property);

        return Expression.Lambda<Func<T, bool>>(mc, param);

    }

}

​

public class Player 

{

    public string Name { get; set; }

    public bool IsActive { get; set; }

    public string Bats { get; set; }

}