Конструктор фильтра

    public class Entity
    {
        public virtual int ID {get; set;}
        public virtual string Description { get; set; }
    }

var paramExp = Expression.Parameter(typeof(T), "x");

var propExp = Expression.Property(paramExp, "PropertyName");

var constExp = Expression.Constant(value);

 switch (operation)
{
    case Operation.Equal:
        var resultExp = Expression.Equal(propExp, constantExp);
    case Operation.Greater:
        var resultExp = Expression.GreaterThan(propExp, constantExp);
    //и так далее
}

List<Party> filterList = SomeList.Where<Party>(ExprTree);

            ParameterExpression param = Expression.Parameter(typeof(Party), "x");
            int[] ids = new int[] { 5 };
            Expression<Func<Party, bool>> aLambda = Expression.Lambda<Func<Party, bool>>(
                Expression.Equal(Expression.Call(
                Expression.Property(param, "Contract"),
                typeof(int[]).GetMethod("Contains"),
                new Expression[] { Expression.Constant(ids, ids.GetType()) }),
                Expression.Constant(true)),
                param);
            var deleg = aLambda.Compile();
            List<Party> filterList = Parties.Where(deleg).ToList();

              ParameterExpression pe = Expression.Parameter(typeof(Party), "x");
              MemberExpression me = Expression.Property(pe, "Contract");
              ConstantExpression constant = Expression.Constant(5, typeof(int));
              BinaryExpression body = Expression.Equal(me, constant);
              var resultExp = Expression.Lambda<Func<Party, bool>>(body, new[] { pe });
              var deleg = resultExp.Compile();

              ParameterExpression pe = Expression.Parameter(typeof(Party), "x");
              MemberExpression me = Expression.Property(pe, "Contract.Id");
              ConstantExpression constant = Expression.Constant(5, typeof(int));
              BinaryExpression body = Expression.Equal(me, constant);
              var resultExp = Expression.Lambda<Func<Party, bool>>(body, new[] { pe });
              var deleg = resultExp.Compile();

MethodInfo ContainsOffOfIEnumerable = OverloadedMethodFinder.FindOverloadedMethodToCall("Contains", typeof(Enumerable), typeof(IEnumerable<Party>), typeof(Party)).MakeGenericMethod(typeof(Party));
            ParameterExpression param = Expression.Parameter(typeof(Party), "x.Contract");
            ConstantExpression ConstantListExpressionParameter = Expression.Constant(Parties, typeof(IEnumerable<Party>));
            MethodCallExpression ContainsMethodCall = Expression.Call(ContainsOffOfIEnumerable, ConstantListExpressionParameter, param);
            Expression<Func<Party, bool>> aLambda = Expression.Lambda<Func<Party, bool>>(ContainsMethodCall, param);
            var deleg = aLambda.Compile();
            List<Party> filterList = Parties.Where(deleg).ToList();

    public static class FilterHelper
    {
        public static IEnumerable Where<T>(this IEnumerable list, string propertyName, Func<T, bool> filter)
        {
            foreach(var obj in list)
            if (obj != null)
            {
                var pi = obj.GetType().GetProperty(propertyName);
                if (pi != null && pi.PropertyType == typeof(T))
                if (filter((T)pi.GetValue(obj)))
                    yield return obj;
            }
        }
    }

var allowedIDs = new HashSet<int> {2, 3};
var temp = list.Where<Entity>("MyEntity", e => allowedIDs.Contains(e.ID));

var temp = list.Where<Entity>("MyEntity", e => e.ID == 2).
                Where<DateTime>("MyDate", e => e >= new DateTime(2017, 1, 1));

        public static IEnumerable Where<T>(this List<T> list, List<string> propertyName, List<int> allowedID) where T:Entity
        {
            for (int i = 0; i < list.Count; i++)
            {
                if (list[i] != null)
                for (int u = 0; u < propertyName.Count; u++)
                {
                    var pi = list[i].GetType().GetProperty(propertyName[u]);
                    if (pi != null && pi.PropertyType == typeof(T))
                        if (filter((T)pi.GetValue(list[i])))
                            yield return list[i];
                }
            }
}

    public static class FilterHelper
    {
        ....
 
        public static IEnumerable Where<T>(this IEnumerable list, List<string> propertyNames, List<List<int>> IDs)
        {
            var res = new HashSet<object>();
 
            for (int i=0; i < propertyNames.Count; i++)
            foreach (var obj in list.Where<Entity>(propertyNames[i], e => IDs[i].Contains(e.ID)))
                res.Add(obj);
 
            return res;
        }
    }

   public static class FilterHelper
   {
      public static IEnumerable Where<T>(this IEnumerable list, string propertyName, Func<T, bool> filter)
      {
         foreach(var obj in list)
            if(obj != null)
            {
               var pi = obj.GetType().GetProperty(propertyName);
               if(pi != null && pi.PropertyType == typeof(T))
                  if(filter((T)pi.GetValue(obj)))
                     yield return obj;
            }
      }
 
      public static IEnumerable Where<T>(this IEnumerable list, List<string> propertyNames, List<List<int>> IDs)
      {
         var res = new HashSet<object>();
 
         for(int i = 0; i < propertyNames.Count; i++)
            foreach(var obj in list.Where<Entity>(propertyNames[i], e => IDs[i].Contains(e.ID)))
               res.Add(obj);
 
         return res;
      }
   }

    public class BaseDictionary
    {
        public int ID { get; set; }
        public string Description { get; set; }
    }
 
    public class A : BaseDictionary
    {
 
    }
    public class B : BaseDictionary
    {
 
    }
 
    public class C : BaseDictionary
    {
 
    }
 
    public class SomeMainClass
    {
        public A A { get; set; }
        public B B { get; set; }
        public C C { get; set; }
        public override string ToString()
        {
            return string.Format("A: {0} B: {1} C: {2}", A.ID, B.ID, C.ID);
        }
    }

            
var list = new List<Object>()
            {
                new SomeMainClass {A = new A {ID = 1}, B = new B {ID = 2}, C = new C {ID = 3}},
                new SomeMainClass {A = new A {ID = 11}, B = new B {ID = 22}, C = new C {ID = 33 }},
                new SomeMainClass {A = new A {ID = 111}, B = new B {ID = 222}, C = new C {ID = 333 }}
            };
            var tempMain = list.Where<A>("A", x => x.ID == 1);
            tempMain = tempMain.Where<B>("B", x => x.ID == 2);

            List<int> listAid = new List<int>() { 1 };
            List<int> listBid = new List<int>() { 2 };
            List<List<int>> allList= new List<List<int>>();
            allList.Add(listAid);
            allList.Add(listBid);
           var tempMain = list.Where<SomeMainClass>(new List<string>() { "A", "B" }, allList);

      public static void Main(string[] args)
      {
         var list = new List<Object>()
         {
             new SomeMainClass {A = new A {ID = 1}, B = new B {ID = 2}, C = new C {ID = 3}},
             new SomeMainClass {A = new A {ID = 11}, B = new B {ID = 22}, C = new C {ID = 33 }},
             new SomeMainClass {A = new A {ID = 111}, B = new B {ID = 222}, C = new C {ID = 333 }}
         };
 
         List<int> listAid = new List<int>() { 1 };
         List<int> listBid = new List<int>() { 2 };
         List<List<int>> allList = new List<List<int>>();
         allList.Add(listAid);
         allList.Add(listBid);
 
         var tempList = list
            .Where<SomeMainClass, BaseDictionary>(new[] { "A", "B" }, allList)
            .Cast<object>()
            .ToList();
 
         Console.ReadKey();
      }
   }
 
   public static class FilterHelper
   {
      public static IEnumerable Where<T, B>(this IEnumerable list, IEnumerable<string> propertyNames, List<List<int>> allowedID)
         where T : SomeMainClass
         where B : BaseDictionary
      {
         foreach(SomeMainClass some in list)
         {
            foreach(string propertyName in propertyNames)
            {
               var property = some.GetType().GetProperty(propertyName);
               if(property == null) yield break;
               foreach(List<int> internalList in allowedID)
               {
                  var x = (B)property.GetValue(some);
                  if(internalList.Contains(x.ID))
                     yield return some;
               }
            }
         }
      }
   }