C#学习笔记（一） 反射

先是反射的基础概念：

反射指程序可以访问、检测和修改它本身状态或行为的一种能力。

程序集包含模块，而模块包含类型，类型又包含成员。反射则提供了封装程序集、模块和类型的对象。

您可以使用反射动态地创建类型的实例，将类型绑定到现有对象，或从现有对象中获取类型。然后，可以调用类型的方法或访问其字段和属性。

首先获取对象类型的方法有两种，object.GetType() 或者 typeof(object)，假定取到的type为t，t.GetField("name")可以获取到FieldInfo类型的字段，使用SetValue跟GetValue方法可以对该对象里的该字段值进行读写，t.GetMethod("name")可以获取到MethodInfo类型的方法，使用Invoke方法可以进行调用，上述俩Get方法还有两个参数的重载，第二个参数是BindingFlags，会根据传入的参数进行搜索匹配。

然后是泛型反射

class Class1<T>
{
  public void Test(T t)
  {
    Console.WriteLine(t);
  }
}

static void InvokeTest(Type t, params object[] args)
{
  Type type = typeof(Class1<>);
  type = type.MakeGenericType(t);
  object o = Activator.CreateInstance(type);
  type.InvokeMember("Test", BindingFlags.Default | BindingFlags.InvokeMethod, null, o, args);
}

大概就是这种。

MakeGenericType函数可以用来指定泛型方法和泛型类的具体类型；

Activator.CreateInstance函数是创造一个实例对象；

InvokeMember函数就是调用一个成员函数。

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

namespace ConsoleApplication1
{
    class Program
    {
        static void Main(string[] args)
        {
            //TestClassA a = new TestClassA();
            //TestFunc(a);
            TestBFunc(typeof(int));
            Console.ReadLine();
        }

        static void TestFunc(object _para)
        {
            Type t = _para.GetType();
            Console.WriteLine(t.FullName);

            MethodInfo mi = t.GetMethod("TestFuncA", BindingFlags.Public | BindingFlags.Static);
            FieldInfo fi = t.GetField("PNum");
            FieldInfo fi2 = t.GetField("m_String",BindingFlags.NonPublic | BindingFlags.Instance);
            fi.SetValue(_para, 55);
            Console.WriteLine(fi2.GetValue(_para));
            //object[] olist = new object[]{};
            object result = mi.Invoke(_para,null);
            Console.WriteLine((string)result);

            //string result = mi.Invoke();
        }

        static void TestBFunc(Type typ)
        {
            //Type t = typeof(TestClassB<string>);
            //object o = Activator.CreateInstance(t);

            //MethodInfo mi = t.GetMethod("TestFuncB", BindingFlags.Public | BindingFlags.Instance);
            //mi.Invoke(o, new object[] { "test_hello" });
            Type t = typeof(TestClassB<>);
            t = t.MakeGenericType(typ);
            object o = Activator.CreateInstance(t);
            t.InvokeMember("TestFuncB", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.InvokeMethod, null, o, new object[] { 159 });
        }
    }

    class TestClassA
    {
        public int PNum;
        private string m_String;
        private static float ms_float = 2.33f;

        public TestClassA()
        {
            this.PNum = 0;
            this.m_String = "helloworld";
        }

        public static string TestFuncA()
        {
            Console.WriteLine("test_ms_float:"+ ms_float);
            return "AFunc";
        }
    }

    class TestClassB<T>
    {
        private void TestFuncB(T t)
        {
            Console.WriteLine(t);
        }
    }
}