【C#】.NET提供了哪些類型來實現反射

實現反射的類型大多數都定義在System.Reflection命名空間之下。

Assembly　　定義一個Assembly，它是可重用、無版本沖突並且可自我描述的公共語言運行庫應用程序構造塊。

AssemblyName　　完整描述程序集的唯一標識

EventInfo　　發現事件的屬性（Attribute）並提供對事件元數據的訪問權

FieldInfo　　發現字段屬性（Attribute）並提供對字段元數據的訪問權

LocalVariableInfo　　發現局部變量的屬性，並提供對局部變量元數據的訪問

ManifestResourceInfo　　包含清單資源拓撲信息

MemberInfo　　獲取有關成員屬性的信息，並提供對成員元數據的訪問

MethodBase　　提供有關方法和構造函數的信息

MethodBody　　提供對用於方法體的元數據和MSIL的訪問

Module　　在模塊上執行反射

ParameterInfo　　發現參數屬性（Attribute）並提供對參數元數據的訪問

PropertyInfo　　發現屬性（Property）的屬性（Attribute）並提供對屬性（Property）元數據的訪問

示例：

using System;
using System.Reflection;

namespace UseReflection
{
    partial class UseReflection
    {
        /// <summary>
        /// 分析程序集
        /// </summary>
        /// <param name="assembly"></param>
        private static void AnalyzeAssembly(Assembly assembly)
        {
            // 打印程序集的名稱
            Console.WriteLine("程序集名字：" + assembly.FullName);
            // 打印程序集的位置
            Console.WriteLine("程序集位置：" + assembly.Location);
            // 打印程序集是否存在於GAC中
            Console.WriteLine("程序集是否存在於GAC中：" + assembly.GlobalAssemblyCache.ToString());
            // 打印包含程序集清單的模塊名單
            Console.WriteLine("包含程序集清單的模塊：", assembly.ManifestModule.Name);
            // 打印程序集的CLR版本
            Console.WriteLine("運行程序集需要的CLR版本：", assembly.ImageRuntimeVersion);

            Console.WriteLine("現在開始分析引用的程序集");
            Module[] modules = assembly.GetModules();
            foreach (Module module in modules)
            {
                AnalyzeModule(module);
            }
        }

        /// <summary>
        /// 分析模塊
        /// </summary>
        /// <param name="module"></param>
        private static void AnalyzeModule(Module module)
        {
            Console.WriteLine("模塊名：" + module.Name);
            Console.WriteLine("模塊的UUID：" + module.ModuleVersionId);
            Console.WriteLine("開始分析模塊下的類型");
            Type[] types = module.GetTypes();
            foreach (Type type in types)
            {
                AnalyzeType(type);
            }
        }

        /// <summary>
        /// 分析類型
        /// </summary>
        /// <param name="type"></param>
        private static void AnalyzeType(Type type)
        {
            Console.WriteLine("類型名字：" + type.Name);
            Console.WriteLine("類型的類別：" + type.Attributes);
            if (type.BaseType != null)
            {
                Console.WriteLine("類型的基類是：" + type.BaseType.Name);
            }
            Console.WriteLine("類型的GUID：" + type.GUID);
            // 設置感興趣的類型成員
            BindingFlags flags = (BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.Static | BindingFlags.Instance);
            // 分析成員
            FieldInfo[] fields = type.GetFields(flags);
            if (fields.Length > 0)
            {
                Console.WriteLine("開始分析類型的成員");
                foreach (FieldInfo field in fields)
                {
                    AnalyzeField(field);
                }
            }
            // 分析包含的方法
            MethodInfo[] methods = type.GetMethods(flags);
            if (methods.Length > 0)
            {
                Console.WriteLine("開始分析類型的方法");
                foreach (MethodInfo method in methods)
                {
                    AnalyzeMethod(method);
                }
            }
            // 分析屬性
            PropertyInfo[] properties = type.GetProperties(flags);
            if (properties.Length > 0)
            {
                Console.WriteLine("開始分析類型的屬性");
                foreach (PropertyInfo property in properties)
                {
                    AnalyzeProperty(property);
                }
            }
        }

        /// <summary>
        /// 分析成員
        /// </summary>
        /// <param name="field"></param>
        private static void AnalyzeField(FieldInfo field)
        {
            Console.WriteLine("成員名字：" + field.Name);
            Console.WriteLine("成員的類別：" + field.Attributes);
            Console.WriteLine("成員的類型名：" + field.FieldType.Name);
        }

        /// <summary>
        /// 分析方法
        /// </summary>
        /// <param name="method"></param>
        private static void AnalyzeMethod(MethodInfo method)
        {
            Console.WriteLine("方法名字：" + method.Name);
            Console.WriteLine("方法的類別：" + method.Attributes);
            Console.WriteLine("開始分析方法的參數");
            ParameterInfo[] parameters = method.GetParameters();
            if (parameters.Length <= 0)
            {
                Console.WriteLine("方法沒有參數");
            }
            foreach (ParameterInfo parameter in parameters)
            {
                AnalyzeParameter(parameter);
            }
            Console.WriteLine("分析方法的返回參數");
            ParameterInfo retpar = method.ReturnParameter;
            AnalyzeParameter(retpar);
        }

        /// <summary>
        /// 分析方法參數
        /// </summary>
        /// <param name="parameter"></param>
        private static void AnalyzeParameter(ParameterInfo parameter)
        {
            Console.WriteLine("參數名字：" + parameter.Name);
            Console.WriteLine("參數的類別：" + parameter.Attributes);
            Console.WriteLine("參數的類型：" + parameter.ParameterType.Name);
        }

        /// <summary>
        /// 分析屬性
        /// </summary>
        /// <param name="property"></param>
        private static void AnalyzeProperty(PropertyInfo property)
        {
            Console.WriteLine("屬性名字：" + property.Name);
            Console.WriteLine("屬性的類別：" + property.Attributes);
            Console.WriteLine("是否可讀：" + property.CanRead.ToString());
            Console.WriteLine("是否可寫：" + property.CanWrite.ToString());
        }

    }
}

using System;
using System.Reflection;
using System.Security.Permissions;

namespace UseReflection
{
    [PermissionSet(SecurityAction.Demand, Name = "FullTrust")]
    partial class UseReflection
    {
        static void Main(string[] args)
        {
            Assembly assembly = Assembly.LoadFrom(@"..\..\..\..\SimpleAssembly\SimpleAssembly\bin\Debug\SimpleAssembly.exe");
            AnalyzeAssembly(assembly);

            // 創建一個程序集中的類型的對象
            // 這裡嘗試創建SimpleAssembly對象
            Console.WriteLine("利用反射創建類型");
            string[] pars = { "測試反射" };
            object o = assembly.CreateInstance(assembly.GetModules()[0].GetTypes()[0].ToString(), true, BindingFlags.CreateInstance, null, pars, null, null);
            Console.WriteLine(o);
            Console.Read();
        }
    }
}