var param = Expression.Parameter(typeof (T), "key");
                var property = Expression.Property(param, sortExpression);

                //是否值类型
                bool valueFlag = property.Type.BaseType.Equals(typeof(ValueType));

                //因为值类型不能用else里面的Func<T, object>签名的委托，所以把值类型的情况特殊出来
                if(valueFlag)
                {
                    //获取值类型的类型名
                    string typeName = property.Type.FullName;

                    /*
                     * 如果这样写
                    Expression expr;
                    expr = Expression.Lambda<Func<T, int>>(property, param);
                    GetTable.OrderBy(expr); //这里会通不过编译
                    */
                    switch (typeName)
                    {
                        
                        case "System.Int16":
                        case "System.Int32":
                        case "System.Int64":
                            return descFlag
                                       ? GetTable.OrderByDescending(Expression.Lambda<Func<T, int>>(property, param))
                                       : GetTable.OrderBy(Expression.Lambda<Func<T, int>>(property, param));
                            //这里非常猥琐,每实现一组值类型的分支，就要写一遍这个return，如何能写更好？
                            
                            break;
                        default:
                            break;
                    }

Code
public virtual IQueryable<T> GetAllQuery(string sortExpression)
        {
            //sortExpression格式可以为"ID"或"ID DESC"
            bool descFlag = false;

            if(!String.IsNullOrEmpty(sortExpression))
            {
                string[] sValues = sortExpression.Split(' ');
                if(sValues.Length > 1)
                {
                    if(sValues[1].ToUpper() == "DESC")
                    {
                        //获取是否DESC标志
                        descFlag = true;
                    }

                    sortExpression = sValues[0];
                }
            }

            if(!string.IsNullOrEmpty(sortExpression))
            {
                //构造泛型参数的Property Expression
                var param = Expression.Parameter(typeof (T), "key");
                var property = Expression.Property(param, sortExpression);

                //是否值类型
                bool valueFlag = property.Type.BaseType.Equals(typeof(ValueType));

                //因为值类型不能用else里面的Func<T, object>签名的委托，所以把值类型的情况特殊出来
                if(valueFlag)
                {
                    //获取值类型的类型名
                    string typeName = property.Type.FullName;

                    /*
                     * 如果这样写
                    Expression expr;
                    expr = Expression.Lambda<Func<T, int>>(property, param);
                    GetTable.OrderBy(expr); //这里会通不过编译
                    */
                    switch (typeName)
                    {
                        
                        case "System.Int16":
                        case "System.Int32":
                        case "System.Int64":
                            return descFlag
                                       ? GetTable.OrderByDescending(Expression.Lambda<Func<T, int>>(property, param))
                                       : GetTable.OrderBy(Expression.Lambda<Func<T, int>>(property, param));
                            //这里非常猥琐,每实现一组值类型的分支，就要写一遍这个return，如何能写更好？
                            
                            break;
                        default:
                            break;
                    }
                }
                else
                {
                    var sortLambda = Expression.Lambda<Func<T, object>>(property, param);
                    if (descFlag)
                    {
                        return GetTable.OrderByDescending(sortLambda);
                    }
                    return GetTable.OrderBy(sortLambda);
                }
                
            }

            return GetTable;
        }