增加老版本 KJDWebService

StoreHub.KJDWebService/Commons/Helper/ReflectionHelper.cs

@@ -0,0 +1,220 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using System.Collections.Concurrent;
+using System.Reflection;
+using System.Linq.Expressions;
+using NaiBa.Util.Extension;
+
+namespace NaiBa.Util.Helper
+{
+    public class ReflectionHelper
+    {
+        private static ConcurrentDictionary<string, object> dictCache = new ConcurrentDictionary<string, object>();
+
+        #region 得到类里面的属性集合
+        public static PropertyInfo[] GetProperties(Type type, string[] columns = null)
+        {
+            PropertyInfo[] properties = null;
+            if (dictCache.ContainsKey(type.FullName))
+            {
+                properties = dictCache[type.FullName] as PropertyInfo[];
+            }
+            else
+            {
+                properties = type.GetProperties();
+                dictCache.TryAdd(type.FullName, properties);
+            }
+
+            if (columns != null && columns.Length > 0)
+            {
+                //  按columns顺序返回属性
+                var columnPropertyList = new List<PropertyInfo>();
+                foreach (var column in columns)
+                {
+                    var columnProperty = properties.Where(p => p.Name == column).FirstOrDefault();
+                    if (columnProperty != null)
+                    {
+                        columnPropertyList.Add(columnProperty);
+                    }
+                }
+                return columnPropertyList.ToArray();
+            }
+            else
+            {
+                return properties;
+            }
+        }
+        #endregion
+
+        public static List<MemberInfo> GetMembers(Type type)
+        {
+            var flags = BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic;
+            var members = new List<MemberInfo>();
+            members.AddRange(type.GetProperties(flags));
+            members.AddRange(type.GetFields(flags));
+            return members;
+        }
+
+        public static void SetObjectPropertyValue<T>(string propertyName, object value)
+        {
+            var type = typeof(T);
+            var field = type.GetProperty(propertyName);
+            if (field != null)
+            {
+                field.SetValue(null, value);
+            }
+        }
+
+        public static void SetObjectPropertyValue(object obj, string propertyName, object value)
+        {
+            if (obj != null)
+            {
+                PropertyInfo propertyInfo = GetProperties(obj.GetType()).Where(p => p.Name == propertyName).FirstOrDefault();
+                // make sure object has the property we are after
+                if (propertyInfo != null)
+                {
+                    switch (propertyInfo.PropertyType.FullName)
+                    {
+                        case "System.Int32": propertyInfo.SetValue(obj, value.ParseToInt(), null); break;
+                        case "System.Int64": propertyInfo.SetValue(obj, value.ParseToLong(), null); break;
+                        case "System.Decimal": propertyInfo.SetValue(obj, value.ParseToDecimal(), null); break;
+                        case "System.Double": propertyInfo.SetValue(obj, value.ParseToDouble(), null); break;
+                        default:
+                            if (propertyInfo.PropertyType.GenericTypeArguments.Length > 0)
+                            {
+                                switch (propertyInfo.PropertyType.GenericTypeArguments[0].FullName)
+                                {
+                                    case "System.DateTime":
+                                        if (!string.IsNullOrEmpty(value.ParseToString()))
+                                        {
+                                            propertyInfo.SetValue(obj, value.ParseToString().ParseToDateTime(), null);
+                                        }
+                                        break;
+
+                                    case "System.Decimal":
+                                        propertyInfo.SetValue(obj, value.ParseToDecimal(), null);
+                                        break;
+                                }
+
+                            }
+                            else
+                            {
+                                propertyInfo.SetValue(obj, value, null);
+                            }
+                            break;
+                    }
+                }
+            }
+        }
+
+        public static object GetObjectPropertyValue(object obj, string propertyName)
+        {
+            if (obj != null)
+            {
+                PropertyInfo propertyInfo = GetProperties(obj.GetType()).Where(p => p.Name == propertyName).FirstOrDefault();
+                // make sure object has the property we are after
+                if (propertyInfo != null)
+                {
+                    return propertyInfo.GetValue(obj);
+                }
+            }
+            return null;
+        }
+
+        public static string GetGenericName(Type type)
+        {
+            if (type.GetGenericArguments().Length > 0)
+            {
+                return GetGenericName(type.GetGenericArguments().FirstOrDefault());
+            }
+            else
+            {
+                if (type.GetGenericArguments().FirstOrDefault() != null)
+                {
+                    return type.GetGenericArguments().FirstOrDefault().Name;
+                }
+                else
+                {
+                    return type.Name;
+                }
+            }
+        }
+
+        public static string GetMemberName<T>(Expression<Func<T>> memberExpression)
+        {
+            MemberExpression expressionBody = (MemberExpression)memberExpression.Body;
+            return expressionBody.Member.Name;
+        }
+
+        public static void SetObjectValue<T>(ref T obj, MemberInfo member, object value)
+        {
+            // Boxing method used for modifying structures
+            var boxed = obj.GetType().IsValueType ? (object)obj : obj;
+            SetMemberValue(ref boxed, member, value);
+            obj = (T)boxed;
+        }
+
+        public static void SetMemberValue<T>(ref T obj, MemberInfo member, object value)
+        {
+            if (IsProperty(member))
+            {
+                var prop = (PropertyInfo)member;
+                if (prop.SetMethod != null)
+                {
+                    prop.SetValue(obj, value);
+                }
+            }
+            else if (IsField(member))
+            {
+                var field = (FieldInfo)member;
+                field.SetValue(obj, value);
+            }
+        }
+
+        public static object GetMemberValue(object obj, MemberInfo member)
+        {
+            object result = null;
+            if (IsProperty(member))
+            {
+                var prop = (PropertyInfo)member;
+                result = prop.GetValue(obj, prop.GetIndexParameters().Count() == 1 ? new object[] { null } : null);
+            }
+            else if (IsField(member))
+            {
+                var field = (FieldInfo)member;
+                result = field.GetValue(obj);
+            }
+            return result;
+        }
+
+        public static bool CanWrite(MemberInfo member)
+        {
+            return IsProperty(member) ? ((PropertyInfo)member).CanWrite : IsField(member);
+        }
+
+        public static bool CanRead(MemberInfo member)
+        {
+            return IsProperty(member) ? ((PropertyInfo)member).CanRead : IsField(member);
+        }
+
+        #region 私有方法
+        private static bool IsProperty(MemberInfo member)
+        {
+            return IsType(member.GetType(), typeof(PropertyInfo));
+        }
+
+        private static bool IsField(MemberInfo member)
+        {
+            return IsType(member.GetType(), typeof(FieldInfo));
+        }
+
+        private static bool IsType(System.Type type, System.Type targetType)
+        {
+            return type.Equals(targetType) || type.IsSubclassOf(targetType);
+        }
+        #endregion
+    }
+}