4.1 反射工具

在编写开发框架的时候，经常会使用反射。反射的作用主要是动态创建类型的实例，或者获取对象类型并动态调用方法、属性、字段等。

我们在以前的.net framework框架中，反射工具包含了许多方法，但是在.net core中由于appdomain等变化的原因，许多方法已不再使用。我只将重反射工具类（ReflectionHelper）重要的几个方法说明一下。

在框架编写过程中，我们会遇到这样的需求：找出应用所用到的所有程序集和类，然后进行下一步的处理。

例如，我们有一个通用控件类BaseControl，各种富文本编辑器控件(RichText)、表格控件(Table)、分页控件(Paganitation)等都继承于通用控件类BaseControl。甚至CMS这个项目的评论(Comment)等控件也会继承该通用控件类BaseControl。我们需求是要做一个下拉列表，列出所有的控件。因为各个子控件会分散在不同的程序集中，评论控件就在CMS程序集中，这样我们必然会搜索当前应用中的所有程序集，从中找出所有继承于BaseControl的控件子类。这就是控件的列表。（如果我懒病不发作，能够写的够久的话，自定义表单、自定义查询等技术点可以看到这个需求。）

下面的方法是找到所有的应用程序集：

        private static IEnumerable<Assembly> GetAssemblies()
        {
            List<Assembly> assemblies = new List<Assembly>();

            //以下2行，总是认为所有的个人程序集都依赖于core
            Type type = typeof(ReflectionHelper);

            var libs = DependencyContext.Default.CompileLibraries;
            foreach (CompilationLibrary lib in libs)
            {
                //if (lib.Name.StartsWith("Microsoft") || lib.Name.StartsWith("System") || lib.Name.Contains(".System.") || lib.Name.StartsWith("NuGet") || lib.Name.StartsWith("AutoMapper")) continue;
                if (lib.Serviceable) continue;
                if (lib.Type == "package") continue;

                var assembly = Assembly.Load(new AssemblyName(lib.Name));
                assemblies.Add(assembly);

                //以下，总是认为所有的个人程序集都依赖于core

                ////过滤掉“动态生成的”
                //if (assembly.IsDynamic) continue;

                //if (assembly.FullName == type.AssemblyQualifiedName.Replace(type.FullName + ", ", ""))
                //{
                //    assemblies.Add(assembly);
                //    continue;
                //}

                //if (assembly.GetReferencedAssemblies().Any(ass => ass.FullName == type.AssemblyQualifiedName.Replace(type.FullName + ", ", "")))
                //{
                //    assemblies.Add(assembly);
                //}
            }

            return assemblies;
        }

此处有个假设，第6行Type type = typeof(ReflectionHelper)。其中ReflectionHelper是核心应用程序集中的一个静态类，而核心应用程序集假设会被所有的应用程序集所引用。如果该假设不成立，需要将19-22行的注释去掉，针对每个找到的程序集获取所有引用的程序集。

if (lib.Serviceable) continue;和if (lib.Type == "package") continue; 这两行的意思是排除所有的系统程序集、Nuget下载包，减少搜索范围，提高效率。（这2行暂未最终确认。）

通过上面的程序，我们就可以从应用中找出所有的程序集。下一步从这些程序集中获取所有继承于BaseControl的控件子类。因为控件子类继承于BaseControl，因此子类所在的应用程序集必然引用BaseControl的应用程序集。从父类获取所有子类的方法如下：

        #region 类型搜索
        /// <summary>
        /// 获取子类型
        /// </summary>
        /// <param name="type">父类型</param>
        /// <returns></returns>
        public static IEnumerable<Type> GetSubTypes(Type type)
        {
            var assemblies = _Assemblies.Where(a =>
            {
                Assembly assembly = type.GetTypeInfo().Assembly;
                //基类所在程序集或依赖于基类的其他程序集
                return a.FullName == assembly.FullName || a.GetReferencedAssemblies().Any(ra => ra.FullName == assembly.FullName);
            });

            TypeInfo typeInfo = type.GetTypeInfo();

            return assemblies.SelectMany(a =>
            {
                return a.GetTypes().Where(t =>
                {
                    if (type == t)
                    {
                        return false;
                    }

                    TypeInfo tInfo = t.GetTypeInfo();

                    if (tInfo.IsAbstract || !tInfo.IsClass || !tInfo.IsPublic)
                    {
                        return false;
                    }

                    if (typeInfo.IsGenericTypeDefinition)
                    {
                        return type.IsAssignableFromGenericType(t);
                    }

                    return type.IsAssignableFrom(t);
                });
            });
        }

        /// <summary>
        /// 获取子类型
        /// </summary>
        /// <typeparam name="T">父类型</typeparam>
        /// <returns></returns>
        public static IEnumerable<Type> GetSubTypes<T>()
        {
            return GetSubTypes(typeof(T));
        }
        #endregion

其中_Assemblies是从GetAssemblies()方法返回的结果。

这样就能够获取当前的子类列表IEnumerable<Type>。对于我们的需求，可以这样写ReflectionHelper.GetSubTypes<BaseControl>()。但是该方法的结果是IEnumerable<Type>，是Type的列表。我们如果用下拉列表展示，应该展示的是中文名称，总不能显示类似namespace.classname, assemblyname的样子吧，这样会被客户骂的。应该下拉出来的是中文名，例如富文本编辑器、文件上传、分页、自动完成等。

简单的做法是在BaseControl中增加一个抽象的Name属性，各个子类实现时override这个属性，标识该控件的中文名，倒是可以实现，不过在获取Name属性时，必须要实例化各个子类，天知道子类的构造函数有哪些参数。

我们的做法是建一个TypeNameAttribute，标识在各个子控件类上。具体实现如下：

    /// <summary>
    /// 子类中，甚至TypeName，包括中英文及属性，以便反射使用
    /// </summary>
    [AttributeUsage(AttributeTargets.Class, AllowMultiple = false, Inherited = false)]
    public class TypeNameAttribute : Attribute
    {
        private string _Code, _Name, _Description;
        /// <summary>
        /// 英文
        /// </summary>
        public string Code
        {
            get
            {
                return _Code;
            }
            set
            {
                _Code = value;
            }
        }
        /// <summary>
        /// 中文
        /// </summary>
        public string Name
        {
            get
            {
                return _Name;
            }
            set
            {
                _Name = value;
            }
        }
        /// <summary>
        /// 描述
        /// </summary>
        public string Description
        {
            get
            {
                return _Description;
            }
            set
            {
                _Description = value;
            }
        }
        /// <summary>
        /// 构造函数
        /// </summary>
        /// <param name="code">英文</param>
        /// <param name="name">中文</param>
        /// <param name="description">描述</param>
        public TypeNameAttribute(string code, string name, string description)
        {
            this._Code = code;
            this._Name = name;
            this._Description = description;
        }

        /// <summary>
        /// 构造函数
        /// </summary>
        /// <param name="code">英文</param>
        /// <param name="name">中文</param>
        public TypeNameAttribute(string code, string name) : this(code, name, string.Empty)
        {
        }
    }

    /// <summary>
    /// TypeName的工具类
    /// </summary>
    public static class TypeNameHelper
    {
        public static ConcurrentDictionary<Type, List<TypeNameHelperInfo>> list = new ConcurrentDictionary<Type, List<TypeNameHelperInfo>>();

        public static TypeNameHelperInfo GetTypeNameHelperInfo<T>(string code)
        {
            List<TypeNameHelperInfo> list = GetTypeNameHelperList<T>();

            return list.SingleOrDefault(info => info.Code == code);
        }

        /// <summary>
        /// 根据基类，获取所有子类的TypeName
        /// </summary>
        /// <typeparam name="T">基类型</typeparam>
        /// <returns>子类的TypeName信息</returns>
        public static List<TypeNameHelperInfo> GetTypeNameHelperList<T>()
        {
            if (list.ContainsKey(typeof(T)))
            {
                return list[typeof(T)];
            }

            List<TypeNameHelperInfo> result = new List<TypeNameHelperInfo>();

            IEnumerable<Type> typeList = ReflectionHelper.GetSubTypes<T>();

            foreach (Type type in typeList)
            {
                try
                {
                    TypeNameAttribute attribute = ReflectionHelper.GetCustomAttribute<TypeNameAttribute>(type);
                    result.Add(new TypeNameHelperInfo()
                    {
                        Code = attribute.Code,
                        Name = attribute.Name,
                        Description = attribute.Description,
                        Type = type
                    });
                }
                catch
                {
                }
            }

            list[typeof(T)] = result;

            return result;
        }
    }

    /// <summary>
    /// TypeName的信息类
    /// </summary>
    public class TypeNameHelperInfo
    {
        /// <summary>
        /// 英文
        /// </summary>
        public string Code { get; set; }
        /// <summary>
        /// 中文
        /// </summary>
        public string Name { get; set; }
        /// <summary>
        /// 描述
        /// </summary>
        public string Description { get; set; }
        /// <summary>
        /// 类型
        /// </summary>
        public Type Type { get; set; }
    }

例如自动完成控件就可以如下写法：

    /// <summary>
    /// 自动填充下拉框控件
    /// </summary>
    [TypeName("AutoComplete", "自动填充下拉框")]
    public class AutoComplete : BaseControl
    {
    ...
    }

 最终就可以通过TypeNameHelper.GetTypeNameHelperList<BaseControl>()就可以获取所有的控件子类，子类列表存放在List<TypeNameHelperInfo>，绑定到select标签即可。

面向云的.net core开发框架目录