反射

using System;
using System.Reflection;

/// <summary>
/// 反射：可以通过类名、成员的名字进行对象的实例化、操作类成员。
/// </summary>

namespace Per
{
    class Person
    {
        public int a;
        private int b;
        public static int c;
        private static int d;

        private Person()
        {
            Console.WriteLine("Person类无参构造方法被调用");
        }
        private Person(int a, string b)
        {
            Console.WriteLine("Person类有参参构造方法被调用");
        }

        public void ShowA()
        {
            Console.WriteLine(a);
        }
        private void ShowB()
        {
            Console.WriteLine(b);
        }
        public static void ShowC()
        {
            Console.WriteLine(c);
        }
        private static void ShowD()
        {
            Console.WriteLine(d);
        }
        public int Show(int num1, double num2)
        {
            return num1;
        }
        private double Show(double num1, int num2)
        {
            return num1;
        }
    }
}

namespace ReflectTest
{
    class Program
    {
        static void Main(string[] args)
        {
            /*
             BindingFlags:要访问的方法或者字段的访问权限描述，必须要具备两个：
             1、要有访问权限的描述 BindingFlags.NonPublic：非公开类；BindingFlags.Public：公开类
             2、要有访问的成员归属 BindingFlags.Instance:非静态；BindingFlags.Static：静态
             */
            #region 实例化一个Person对象
            //通过类名来获取一个类型
            //命名空间：如果这个类在一个命名空间中，写类型名字的时候则需要加上命名空间

            //Type t = typeof(Per.Person);
            Type t = Type.GetType("Per.Person");

            //实例化一个对象，默认使用public权限的无参构造方法来实例化
            //object obj = Activator.CreateInstance(t);

            //实例化一个对象,如果为true，可以匹配任何权限的无参构造方法来实例化
            //object obj = Activator.CreateInstance(t,true);

            //实例化一个对象,如果为true，有使用public权限参构造方法来实例化
            //object obj = Activator.CreateInstance(t, 1, "小明");

            //实例化一个对象,如果为true，有参构造方法来实例化
            object obj = Activator.CreateInstance(t, BindingFlags.NonPublic | BindingFlags.Instance, null, new object[] { 1, "xiaoming" }, null);

            #endregion


            #region 通过反射访问类中的字段
            //访问public非静态字段a

            FieldInfo a = t.GetField("a");
            //给obj对象的a赋值为10
            a.SetValue(obj, 10);
            object aa = a.GetValue(obj);
            Console.WriteLine("aa==" + aa);
            //访问非public非静态字段b

            FieldInfo b = t.GetField("b", BindingFlags.NonPublic | BindingFlags.Instance);
            //给obj对象的a赋值为10
            b.SetValue(obj, 10);
            object bb = b.GetValue(obj);
            Console.WriteLine("bb==" + bb);
            //访问public静态字段c

            FieldInfo c = t.GetField("c", BindingFlags.Public | BindingFlags.Static);
            //给obj对象的a赋值为10,如果访问的对象是静态的，访问主体建议使用ull
            c.SetValue(null, 10);
            object cc = c.GetValue(null);
            Console.WriteLine("cc==" + cc);
            //访问非public静态字段d

            FieldInfo d = t.GetField("d", BindingFlags.NonPublic | BindingFlags.Static);
            //给obj对象的a赋值为10，如果访问的对象是静态的，访问主体建议使用ull
            d.SetValue(null, 10);
            object dd = d.GetValue(null);
            Console.WriteLine("dd==" + dd);
            #endregion

            #region 通过反射访问类中的方法
            //获取没参数的方法,静态对象使用null
            MethodInfo method0 = t.GetMethod("ShowA", BindingFlags.Public | BindingFlags.Instance);
            //方法调用：
            //第一个参数：谁在调用方法
            //第二个参数：调用方法的实参列表
            method0.Invoke(obj, null);
            MethodInfo method1 = t.GetMethod("ShowC", BindingFlags.Public | BindingFlags.Static);
            method1.Invoke(null, null);

            //获取有参数有重载的方法
            //Type  数组中传入要访问方法的参数类型
            MethodInfo method2 = t.GetMethod("Show", BindingFlags.Public | BindingFlags.Instance, null, new Type[] { typeof(int), typeof(double) }, null);
            object result = method2.Invoke(obj, new object[] { 1, 3.14 });
            Console.WriteLine(result);
            #endregion
        }
    }
}