public enum Compare
    {
        Or = ExpressionType.Or,
        And = ExpressionType.And,
        Xor = ExpressionType.ExclusiveOr,
        Not = ExpressionType.Not,
        Equal = ExpressionType.Equal,
        Like = ExpressionType.TypeIs + 1,
        NotEqual = ExpressionType.NotEqual,
        OrElse = ExpressionType.OrElse,
        AndAlso = ExpressionType.AndAlso,
        LessThan = ExpressionType.LessThan,
        GreaterThan = ExpressionType.GreaterThan,
        LessThanOrEqual = ExpressionType.LessThanOrEqual,
        GreaterThanOrEqual = ExpressionType.GreaterThanOrEqual

    }
    public class NorthWindFilter<T> where T : class
    {
      


        public Expression<Func<T, bool>> ExecuteQuery(string fieldname, Compare tipo, object costante)
        {

            var p = Expression.Parameter(typeof(T), typeof(T).Name);
            var order = typeof(T).GetProperty(fieldname);
            var expr = CombineFunc(Expression.PropertyOrField(p, order.Name), tipo, Expression.Constant(costante));
            var predicate = Expression.Lambda<Func<T, bool>>(expr, new ParameterExpression[] { p });
            return predicate;

        }
       
        private static Expression CombineFunc(Expression left, Compare condType, Expression right)
        {

            switch (condType)
            {
                case Compare.Or:
                    return Expression.Or(left, right);
                    break;
                case Compare.And:
                    return Expression.And(left, right);
                    break;
                case Compare.Xor:
                    return Expression.ExclusiveOr(left, right);
                    break;
                case Compare.Equal: 
                    return Expression.Equal(left, right);
                    break;
                case Compare.OrElse:
                    return Expression.OrElse(left, right);
                    break;
                case Compare.AndAlso:
                    return Expression.AndAlso(left, right);
                    break;
                case Compare.NotEqual:
                    return Expression.NotEqual(left, right);
                case Compare.LessThan:
                    return Expression.LessThan(left, right);
                    break;
                case Compare.GreaterThan:
                    return Expression.GreaterThan(left, right);
                    break;
                case Compare.LessThanOrEqual:
                    return Expression.LessThanOrEqual(left, right);
                    break;
                case Compare.GreaterThanOrEqual:
                    return Expression.GreaterThanOrEqual(left, right);
                    break;



                default:
                    throw new ArgumentException("Not a valid Condition Type", "condType", null);
            }

        }

NorthWindFilter<Orders> ordini=new NorthWindFilter<Orders>();
            var result = ordini.ExecuteQuery("ShippedDate", Compare.GreaterThan, "16/07/1996");

            var query = nwdb.Orders.Where(result);
                       
          
            return View(query);

L'operatore binario GreaterThan non è definito per i tipi 'System.Nullable`1[System.DateTime]' e 'System.String'.