DataReader转换

public static partial class Extension
    {
        
        private static ConcurrentDictionary<Type, ConcurrentDictionary<string, PropertyInfo>> typePropertyCache = new ConcurrentDictionary<Type, ConcurrentDictionary<string, PropertyInfo>>();

        private static ConcurrentDictionary<string, PropertyInfo> GetTypePropertyMap(Type entityType)
        {
            if (typePropertyCache.ContainsKey(entityType))
                return typePropertyCache[entityType];
            ConcurrentDictionary<string, PropertyInfo> propertyMappers = new ConcurrentDictionary<string, PropertyInfo>();
            var properties = entityType.GetProperties(BindingFlags.Public | BindingFlags.Instance | BindingFlags.SetProperty);
            foreach (var item in properties)
            {
                string columnName = ImprovedNamingStrategy.Instance.PropertyToColumnName(item.Name);
                propertyMappers.TryAdd(columnName, item);
            }
            typePropertyCache[entityType] = propertyMappers;
            return propertyMappers;
        }


        public static IEnumerable<T> QueryList<T>(this IDbConnection connection, string sql, object param = null, IDbTransaction transaction = null, int? commandTimeout = null, CommandType? commandType = null)
        {
            IDataReader reader = connection.ExecuteReader(sql, param, transaction, commandTimeout, commandType);

            List<T> list = new List<T>();
            var propertyMappers = GetTypePropertyMap(typeof(T));
            while (reader.Read())
            {
                T obj = Activator.CreateInstance<T>();

                for (int i = 0; i < reader.FieldCount; i++)
                {
                    if (reader.IsDBNull(i))
                    {
                        continue;
                    }
                    string columnName = reader.GetName(i).ToLower();
                    if (!propertyMappers.ContainsKey(columnName))
                    {
                        continue;
                    }
                    PropertyInfo property = propertyMappers[columnName];
                    if (property == null)
                    {
                        continue;
                    }

                    property.SetValue(obj, ChangeType(reader[columnName], property.PropertyType));
                }
                list.Add(obj);
            }
            return list;
        }

        static public object ChangeType(object value, Type type)
        {
            if (value == null && type.IsGenericType) return Activator.CreateInstance(type);
            if (value == null) return null;
            if (type == value.GetType()) return value;
            if (type.IsEnum)
            {
                if (value is string)
                    return Enum.Parse(type, value as string);
                else
                    return Enum.ToObject(type, value);
            }
            if (!type.IsInterface && type.IsGenericType)
            {
                Type innerType = type.GetGenericArguments()[0];
                object innerValue = ChangeType(value, innerType);
                return Activator.CreateInstance(type, new object[] { innerValue });
            }
            if (value is string && type == typeof(Guid)) return new Guid(value as string);
            if (value is string && type == typeof(Version)) return new Version(value as string);
            if (!(value is IConvertible)) return value;
            return Convert.ChangeType(value, type);
        }
    }