.NET 反射代码

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Data;
using System.Reflection;

namespace 反射
{
    class Program
    {
        static void Main(string[] args)
        {
            ReflectionTest test=new ReflectionTest();
            test.ClassMemberInfo();
            Console.ReadLine();
        }
    }

    public class ReflectionTest
    {
        /// <summary>
        /// Assembly类的使用
        /// </summary>
        public void AssemblyTest()
        {
            Console.WriteLine("\t\t------------Assembly类的使用-------------");
            Console.WriteLine();

            //获取当前所执行代码的程序集信息
            Assembly myAssembly=Assembly.GetExecutingAssembly();
            Console.WriteLine("获取程序集位置："+myAssembly.CodeBase);
            Console.WriteLine("获取程序集的入口点："+myAssembly.EntryPoint);
            Console.WriteLine("获取程序集的显示名称："+myAssembly.FullName);
            Console.WriteLine("获取包含当前程序集清单的模块："+myAssembly.ManifestModule);            
            Console.WriteLine("获取URL，表示基本代码的转义符："+myAssembly.EscapedCodeBase);
            Console.WriteLine("获取此程序集的证据："+myAssembly.Evidence);
            Console.WriteLine("获取当前程序集的授予权："+myAssembly.PermissionSet);
            Console.WriteLine("当前程序集是否从缓存中加载的："+myAssembly.GlobalAssemblyCache.ToString());
            Console.WriteLine("加载程序集主机上下文："+myAssembly.HostContext);
            Console.WriteLine("CRL版本："+myAssembly.ImageRuntimeVersion);
            Console.WriteLine("当前程序集是否通过反射得到的："+myAssembly.IsDynamic);
            Console.WriteLine("当前程序集是否是完全信任的方式加载的："+myAssembly.IsFullyTrusted);
            Console.WriteLine("清单的已加载路径："+myAssembly.Location);
            Console.WriteLine("获取当前程序集的授予集："+myAssembly.PermissionSet);
            Console.WriteLine("当前程序集是否加载到只反射上下文中："+myAssembly.ReflectionOnly);
            Console.WriteLine("CLR对当前程序集强制执行的安全规则集："+myAssembly.SecurityRuleSet);
            Console.WriteLine();

            //获取当前程序集的名称及信息
            AssemblyName asmName=myAssembly.GetName();
            Console.WriteLine("获取或设置程序集的简单名称："+asmName.Name);
            Console.WriteLine("获取或设置程序集的全名："+asmName.FullName);
            Console.WriteLine("获取或设置程序集的URL位置："+asmName.CodeBase);
            Console.WriteLine("获取或设置程序集的主版本号、次版本号、内部版本号和修订版本号：{0}",asmName.Version);

            
            Console.WriteLine("获取或设置程序集支持的区域性："+asmName.CultureInfo);
            Console.WriteLine("获取URL，包括表示基本代码的转义符："+asmName.EscapedCodeBase);
            Console.WriteLine("获取或设置程序集的特性："+asmName.Flags);
            Console.WriteLine("获取或设置程序集的清单使用的哈希算法："+asmName.HashAlgorithm);
            Console.WriteLine("获取或设置为程序集的创建强名称签名的加密公钥/私钥对："+asmName.KeyPair);
            Console.WriteLine("获取或设置程序集的可执行文件的目标平台的处理器和每字位数："+asmName.ProcessorArchitecture);
            Console.WriteLine("获取或设置程序集同其他程序的兼容性相关的信息："+asmName.VersionCompatibility);
            Console.WriteLine();

            //获取当前程序集的版本相关信息
            System.Version asmVersion=asmName.Version;
            Console.WriteLine("获取当前程序集的主版本号："+asmVersion.Major);
            Console.WriteLine("获取当前程序集的次版本号："+asmVersion.Minor);
            Console.WriteLine("获取当前程序集的内部版本号："+asmVersion.Build);
            Console.WriteLine("获取当前程序集的修订版本号："+asmVersion.MajorRevision);
        }

        /// <summary>
        /// Type 类：检索类信息
        /// </summary>
        public void TypeTest()
        {
            Console.WriteLine("\t\t------------Type类的使用-------------");
            Console.WriteLine();

            Type myType=Type.GetType("反射.WeiMei");

            //检索信息
            Console.WriteLine("获取当前成员名称："+myType.Name);
            Console.WriteLine("获取当前完全限定名（不包括程序集）："+myType.FullName);
            Console.WriteLine("获取当前TYPE所在的命名空间："+myType.Namespace);
            Console.WriteLine("获取当前TYPE关联的GUID："+myType.GUID);
            Console.WriteLine("获取在其中定义在当前模块："+myType.Module);
            Console.WriteLine("获取该成员的类对象："+myType.ReflectedType);

            //检索类成员
            Console.WriteLine("获取方法相关信息：{0}",myType.GetMethod("MetName").ToString());
            Console.WriteLine("获取属性相关信息：{0}",myType.GetProperty("ProName").ToString());
            Console.WriteLine("获取字段相关信息：{0}",myType .GetField("mName",BindingFlags.NonPublic|BindingFlags.Instance).ToString());
            Console.WriteLine();
            Type myThis=this.GetType();
        }

        /// <summary>
        /// 访问类成员
        /// </summary>
        public void ClassMemberInfo()
        {
            //指定被访问的类
            //Type WMtype=Type.GetType("反射.WeiMei");//使用这个时无法获取属性值
            WeiMei myWeiMei=new WeiMei();
            Type WMtype=myWeiMei.GetType();
            Console.WriteLine("\t\t------------MemberInfo访问类的所有成员-------------");
            Console.WriteLine();
            //MemberInfo类：遍历被访问的类的所有成员
            MemberInfo[] members=WMtype.GetMembers(BindingFlags.Public|BindingFlags.NonPublic|BindingFlags.Static|BindingFlags.Instance|BindingFlags.DeclaredOnly);
            foreach(MemberInfo member in members)
            {
                Console.WriteLine("成员名称：{0}-----成员类型：{1}",member.Name,member.MemberType);
            }
            Console.WriteLine();
            Console.WriteLine("\t\t------------MethodInfo访问类的方法-------------");
            Console.WriteLine();

            MethodInfo[] methods=WMtype.GetMethods(BindingFlags.Public|BindingFlags.NonPublic|BindingFlags.Static|BindingFlags.Instance|BindingFlags.DeclaredOnly);
            foreach(MethodInfo method in methods)
            {
                Console.WriteLine("方法名称：{0}-----成员类型：{1}",method.Name,method.ReturnType);
            }
            Console.WriteLine(); 

            Console.WriteLine("\t\t------------PropertyInfo访问类的属性-------------");
            Console.WriteLine();
            PropertyInfo[] propertys=WMtype.GetProperties(BindingFlags.Public|BindingFlags.NonPublic|BindingFlags.Static|BindingFlags.Instance|BindingFlags.DeclaredOnly);
            foreach(PropertyInfo property in propertys)
            {
                Console.WriteLine("属性名称：{0}-----属性类型：{1}-----属性值：{2}",property.Name,property.PropertyType,property.GetValue(myWeiMei,null));
            }
            Console.WriteLine();
            Console.WriteLine("\t\t------------FieldInfo访问类的字段-------------");
            Console.WriteLine();
            FieldInfo[] fields=WMtype.GetFields(BindingFlags.Public|BindingFlags.NonPublic|BindingFlags.Static|BindingFlags.Instance|BindingFlags.DeclaredOnly);
            foreach(FieldInfo field in fields)
            {
                Console.WriteLine("字段名称：{0}-----字段类型：{1}",field.Name,field.FieldType);
            }

            Console.WriteLine("\t\t------------ConstructorInfo访问类的构造函数-------------");
            Console.WriteLine();

            ConstructorInfo[] constructors=WMtype.GetConstructors(BindingFlags.Public|BindingFlags.NonPublic|BindingFlags.Static|BindingFlags.Instance|BindingFlags.DeclaredOnly);
            foreach(ConstructorInfo constructor in constructors)
            {
                Console.WriteLine("构造函数：{0}-----构造函数类型：{1}",constructor.Name,constructor.MemberType);
            }
              Console.WriteLine(); 
            Console.WriteLine("\t\t------------MemberInfo访问类的构造函数-------------");
            Console.WriteLine();
            EventInfo[] eventinfos=WMtype.GetEvents(BindingFlags.Public|BindingFlags.NonPublic|BindingFlags.Static|BindingFlags.Instance|BindingFlags.DeclaredOnly);
            foreach(EventInfo eventinfo in eventinfos)
            {
                Console.WriteLine("事件名称：{0}------成员类型：{1}",eventinfo.Name,eventinfo.MemberType);
            }
            Console.WriteLine();
            
            Console.WriteLine("\t\t------------MemberInfo访问类的构造函数-------------");
            Console.WriteLine();
            MethodInfo myMethod=WMtype.GetMethod("TestName");
            ParameterInfo[] parameters=myMethod.GetParameters();
            int count=0;
            foreach(ParameterInfo param in parameters)
            {
                count++;
                Console.WriteLine("参数"+count+" 名称：{0}-----类型：{1}",param.Name,param.ParameterType);
            }
            Console.WriteLine();
        }

        /// <summary>
        /// 调用类成员
        /// </summary>
        public void OperMembers()
        {
            //指定被访问的类
            WeiMei weiMeiObj=new WeiMei();
            Type WMtype=weiMeiObj.GetType();
            //Type WMtype=Type.GetType("反射.WeiMei");
            //操作方法
            string[] parName=new string[]{"WeiMeiHua"};//方法参数的值
            MethodInfo method=WMtype.GetMethod("MetName");
            method.Invoke(weiMeiObj,parName);
            Console.WriteLine("操作方法改变值后为：{0}",weiMeiObj.ProName);

            //操作属性
            PropertyInfo proper=WMtype.GetProperty("ProName");
            proper.SetValue(weiMeiObj,"HuaWeiMei",null);
            //proper.GetValue(weiMeiObj,null);
            Console.WriteLine("操作属性改变值后为：{0}",weiMeiObj.ProName);

            //操作字段
            FieldInfo field=WMtype.GetField("mName",BindingFlags.Instance|BindingFlags.NonPublic);
            field.SetValue(weiMeiObj,"WeiMei");
            //field.GetValue(weiMeiObj);
            Console.WriteLine("操作字段改变值后为：{0}",weiMeiObj.ProName);

            //操作事件
            EventInfo eventinfo=WMtype.GetEvent("WMShout");
            Console.WriteLine("声明该成员的类："+eventinfo.DeclaringType);
            Console.WriteLine("事件名称："+eventinfo.Name);
            Console.WriteLine("事件类型："+eventinfo.MemberType);

            //操作构造函数
            ConstructorInfo constructor=WMtype.GetConstructor(System.Type.EmptyTypes);
        }
    }

    /// <summary>
    /// 被访问的类
    /// </summary>
    public class WeiMei
    {
        //字段
        private string mName;
        private string mSex;
        private int mAge;

        public WeiMei()
        {
            mName="LiuWeiMei";
            mSex="gril";
            mAge=20;
        }

        public WeiMei(string name,string sex,int age)
        {
            mName=name;
            mSex=sex;
            mAge=age;
        }

        public string ProName
        {
            get{return mName;}
            set{mName=value;}
        }

        public string ProSex
        {
            get{return mSex;}
            set{mSex=value;}
        }

        public int ProAge
        {
            get{return mAge;}
            set{mAge=value;}
        }

        private string ProLoveYou
        {
            get{return "这是一个秘密，只有我知道";}
        }

        public string MetName(string herName)
        {
            this.mName=herName;
            return mName;
        }

        public string MetSex(string herSex)
        {
            this.mSex=herSex;
            return mSex;
        }

        public int MetAge(int herAge)
        {
            this.mAge=herAge;
            return mAge;
        }

        public string TestName(string herName,int like,float love)
        {
            this.mName=herName;
            return mName;
        }

        public delegate string WMName(string wmName);

        public event WMName WMShout;
        private event WMName WMLove;
    }
    
}

c#反射用法例子
2010-06-27 17:49

using System;
using System.Collections.Generic;
using System.Text;

using System.Reflection;
namespace RefDemo
{
    class Program
    {
        static void Main(string[] args)
        {
            //通过反射得到 RefDemo.Test 类的类型（有两种方式）

            //第一种方式：获取当前正在运行的程序集中的类型，类型为“命名空间.类型”
            //Type type = Assembly.GetExecutingAssembly().GetType("RefDemo.Test");

            //第二种方式：加载指定的程序集，再获取其中的类型，Load()方法中的参数为程序集名称
            Type type = Assembly.Load("RefDemo").GetType("RefDemo.Test");


            //通过反射调用Test类的静态方法StaticMethod
            type.GetMethod("StaticMethod").Invoke(null, null);

            //通过反射创建 RefDemo.Test 类的对象（不带参的构造函数）
            object obj = Assembly.GetExecutingAssembly().CreateInstance("RefDemo.Test");

            //通过反射调用 obj 对象的 TestMethod3 方法，不带参数
            type.GetMethod("TestMethod2").Invoke(obj, null);

            //通过反射调用 obj 对象的 TestMethod3 方法，并传一个参数（值为 aaa ）
            type.GetMethod("TestMethod3").Invoke(obj, new object[] { "aaa" });

            //通过调用带参的构造函数来得到对象
            ConstructorInfo ci = type.GetConstructor(new Type[] { typeof(string) });
            object test = ci.Invoke(new object[] { "bbb" });
            type.GetMethod("TestMethod3").Invoke(test, new object[] { "bbb" });
        }
    }

    public class Test
    {
        public static void StaticMethod()
        {
            Console.WriteLine("StaticMethod方法的输出");
        }

        public static void TestMethod2()
        {
            Console.WriteLine("TestMethod2方法的输出");
        }
        public static void TestMethod3(string str)
        {
            Console.WriteLine(str);
        }

        public Test(string str)
        {
            this._str = str;
        }
        string _str;
        public void GetStr()
        {
            Console.WriteLine(this._str);
        }
        public Test()
        {
        }
    }
}