C# 反射（Reference）的基本使用

1.官方这样描述： 反射提供描述程序集、模块和类型的对象（Type 类型）。 可以使用反射动态地创建类型的实例，将类型绑定到现有对象，或从现有对象中获取类型，然后调用其方法或访问器字段和属性。 如果代码中使用了特性，可以利用反射来访问它们。

 

2.程序的需要运行的流程 

//1.获取类

Type t = Type.GetType("命名空间.类名"); 

//2.实例化 obj类
object obj = Activator.CreateInstance(t);  

//3.设置字段
//（1）指定字段

FieldInfo  a = t.GetField("字段名");

//(2) 使用字段

a.SetValue(obj,"字段数据"); //给对象obj的字段a进行赋值    
object aa = a.GetValue(obj);// 获取对象obj 的 字段a 的值 （返回的均为 字段 object类型）

//4.使用方方法
//(1) 获取方法

 MethodInfo method1 = t.GetMethod("方法名",BindingFlags.Public | BindingFlags.Instance,null,new Type[]{typeof(int),typeof(double) },null);
           
//（2）执行方法 
object result = method1.Invoke(obj,new object[]{1,1.3d });

　　

 

 

学习时记录下的代码：

using System;
using System.Collections.Generic;
using System.Linq;
using System.Reflection;
using System.Text;
using System.Threading.Tasks;

namespace LearnRefeluction
{
     class MyClass2
    {
        /// <summary>
        ///1. public 无参构造
        /// </summary>
        //public MyClass2(){Console.WriteLine("-public 无参实例化" ); }

        /// <summary>
        ///2. private 无参构造
        /// </summary>
        private MyClass2() { Console.WriteLine("-private 无参实例化"); }

        /// <summary>
        /// 3.public 有参构造
        /// </summary>
        /// <param name="index"></param>
        /// <param name="num"></param>
        /// <param name="str"></param>
        public MyClass2(int index,float num,string str)
        {
            Console.WriteLine("-public 有参实例化->"+ index +" " + num + " " +str);
        }

        /// <summary>
        /// 4.private 有参数构造 
        /// </summary>
        /// <param name="index"></param>
        /// <param name="str"></param>
        private MyClass2(int index,string str)
        {
            Console.WriteLine("-private 有参实例化->"+ index + " " +str);
        }

        //字段
        public int a;
        private float b;
        public static int c;
        private static double  d;

        //无参的方法
        public void ShowA(){}
        private void ShowB(){}
        public static void ShowC(){}
        private static void ShowD(){}

        //有参的重载方法
        public int Show(int a,double b){return a;}
        public double Show(double a,int b){return b;}
    }


    class Test2
    {
       public  static void PlayTest()
        {
            //使用Type 获取类的引用  "命名空间.类名"
            Type t = Type.GetType("LearnRefeluction.MyClass2");

            //--->实例化一个对象   Activator.CreateInstance<--
            //1.使用默认pubulic 权限的无参构造方法来实例化
            // 方法： public static object CreateInstance(Type type);
            //object obj = Activator.CreateInstance(t);

            //2.使用非public权限的无参构造方法实例化 如果为true 则表示用任何权限
            //方法： public static object CreateInstance(Type type, bool nonPublic);
            object obj = Activator.CreateInstance(t, true);

            //3使用public 权限的有参构造方法  params 为传入的参数
            //方法 : public static object CreateInstance(Type type, params object[] args);
            //object obj = Activator.CreateInstance(t,1,3.1f,"hellow");

            //4.使用非public 权限的有参构造方法  params 为传入的参数
            //方法 :public static object CreateInstance(Type type, BindingFlags bindingAttr, Binder binder, object[] args, CultureInfo culture);
            // object obj = Activator.CreateInstance(t, System.Reflection.BindingFlags.NonPublic | System.Reflection.BindingFlags.Instance,null,new object[]{2,"this 参数"},null);

            // System.Reflection.BindingFlags :要访问的方法或者字段的权限描述，必须同时具备两个描述
            //a)    要有访问的成员的访问权限描述（如 NoPublic、Public）
            //b)    要有要访问的成员的归属 (Instance 、Static)

            /*-->访问类中的字段  字段用FieldInfo 描述<-- */
            //1.访问public 权限的 非静态 字段  public int a
            FieldInfo  a = t.GetField("a");
            a.SetValue(obj,2); //给对象obj的字段a进行赋值    
            object aa = a.GetValue(obj);// 获取对象obj 的 字段a 的值
            Console.WriteLine("aa -->" +aa);
        
            //2.访问非 public 权限， 非静态的字段 b  private float b;
            FieldInfo b = t.GetField("b",BindingFlags.NonPublic | BindingFlags.Instance);
            b.SetValue(obj,1.2f);
            object bb = b.GetValue(obj); //获取对象 obj的字段 b 的值
             Console.WriteLine("bb -->" +bb);

            //3.访问 public 权限 静态的字段 c public static int c;
            FieldInfo c = t.GetField("c",BindingFlags.Public | BindingFlags.Static); //使用 BindingFlags.Public | BindingFlags.Static
            c.SetValue(null,5);//如果要访问的是一个静态成员，访问主体是 null
            object cc = c.GetValue(null);
             Console.WriteLine("cc -->" +cc);
            
            //4.访问 非public 权限 静态字段 d  private static double  d;
            FieldInfo d = t.GetField("d",BindingFlags.NonPublic | BindingFlags.Static);//BindingFlags.NonPublic | BindingFlags.Static
            d.SetValue(null,1.22d);
            object dd = d.GetValue(null);
             Console.WriteLine("dd -->" +dd);


            /*--> 获取反射访问类中的方法  方法使用 MethodInfo 描述<----*/
            //1.获取无参方法  （static 和 非 static、public 、private 只需要设置 　ｂｉｎｄｉｎｇＦｌａｇｓ类型；
            MethodInfo method0 = t.GetMethod("ShowD",BindingFlags.NonPublic | BindingFlags.Static);
           //方法调用，
           //第一个参数：谁在调用方法
           //第二个参数的 ：调用方法的实参列表
            method0.Invoke(null,null);

            //2.获取有参数有重载的方法
            //Type 数组中传 要访问的方法的参数类型列表
            MethodInfo method1 = t.GetMethod("Show",BindingFlags.Public | BindingFlags.Instance,null,new Type[]{typeof(int),typeof(double) },null);
            //方法调用  第二个参数的是实参列表
            //Invoke 方法的返回值 就是method1 方法的返回值
            object result = method1.Invoke(obj,new object[]{1,1.3d });

            Console.WriteLine("---->"+ obj.ToString());

        }
    }
}