Request参数值自动去空格

     /// <summary>
    /// TypeTrimHelper
    /// </summary>
    public static class TypeTrimHelper
    {
        /// <summary>
        /// 类型字典
        /// </summary>
        public static ConcurrentDictionary<Type, PropertyInfo[]> TypeDictionary
            = new ConcurrentDictionary<Type, PropertyInfo[]>();

        /// <summary>
        /// 获取Type属性
        /// </summary>
        /// <param name="type"></param>
        /// <returns></returns>
        public static PropertyInfo[] GetTypeProperties(Type type)
        {
            PropertyInfo[] typeProperties = null;
            if (TypeDictionary.ContainsKey(type))
            {
                typeProperties = TypeDictionary[type];
            }
            else
            {
                typeProperties = type.GetProperties();
                TypeDictionary[type] = typeProperties;
            }

            return typeProperties;
        }

        private static bool HasNotAutoTrimSpacesAttribute(Type type)
        {
            return type.GetCustomAttribute<NotAutoTrimSpacesAttribute>()
                != null;
        }

        private static bool HasNotAutoTrimSpacesAttribute(PropertyInfo propertyInfo)
        {
            return propertyInfo.GetCustomAttribute<NotAutoTrimSpacesAttribute>()
                != null;
        }

        /// <summary>
        /// 去空格操作
        /// </summary>
        /// <param name="objType">类型</param>
        /// <param name="obj">当前对象</param>
        public static void TypeTrim(Type objType, object obj)
        {
            if (HasNotAutoTrimSpacesAttribute(objType) || obj == null) { return; }

            PropertyInfo[] typeProperties = GetTypeProperties(objType);
            foreach (var typeProperty in typeProperties)
            {
                if (HasNotAutoTrimSpacesAttribute(typeProperty)) { continue; }

                var cPropertyType = typeProperty.PropertyType;
                if (cPropertyType == typeof (string))
                {
                    if (!typeProperty.CanWrite)
                    {
                        continue;
                    }

                    string value = typeProperty.GetValue(obj) as string;
                    if (value != null)
                    {
                        typeProperty.SetValue(obj, value.Trim());
                    }
                }
                else
                {
                    if (cPropertyType.IsClass)
                    {
                        if (cPropertyType.IsValueType)
                        {
                            continue;
                        }

                        if (cPropertyType.GetInterface(typeof (IEnumerable).Name, false) != null)
                        {
                            var values = typeProperty.GetValue(obj) as IEnumerable;
                            if (values != null)
                            {
                                var enumerator = values.GetEnumerator();
                                while (enumerator.MoveNext())
                                {
                                    if (enumerator.Current != null)
                                    {
                                        var itemType = enumerator.Current.GetType();
                                        TypeTrim(itemType, enumerator.Current);
                                    }
                                }
                            }
                        }
                        else
                        {
                            TypeTrim(cPropertyType, typeProperty.GetValue(obj));
                        }
                    }
                }
            }
        }

    }