泛型和反射

泛型和反射经常是一起工作的，所以就一次介绍吧.

c# 是强类型语言，一般上函数的返回类型和参数的类型都是一早些好的，也就造成了很多时候不像js那样方便使用，不灵话。

所以呢就有了这个泛型，它可以让你的函数和参数在调用的时候才决定类型。

    public T abc<T>(T word)
    {
        return word;
        return default(T); //关键字default可以对引用类型返回nullAble,int类型返回0,初始化一个T的感觉啦
    }

    abc<string>("x");

    //struct 是 值类型
    //好处调用的是如果参数是值类型可以不用著名 test(100) 而不需要 test<int>(100);
    public void test<T>(T number) where T : struct
    {
        int z = Convert.ToInt32(number);
        //调用 test(100);
    }
    //下面的不知道好处在哪用在什么地方,
    public void test2<T>(T lei) where T : class
    {
    }
    public void test3<T>() where T : stooges
    {
    }
    public T test4<T>() where T : new()
    {
        T abc = new T();
        return abc;
    }
    public class stooges
    {
    }

加了where 我就不清楚在什么地方用的上了，这个以后再研究

反射能让我们的代码运行时动态的获取一些对象或者类的属性值等等，甚至是调用它们。

先来一个常用到的，我们想获取一个对象的全部属性和值, 用js 是 for(var attr in object) { object[attr]=value, attr = attr }

            var obj = new abc();
            Type T = typeof(abc); //typeof(Class) 而不是 typeof(object) 哦
            Type V = obj.GetType(); //obj.GetType() 就是typeof(object的class)
            PropertyInfo[] attrs = obj.GetType().GetProperties(BindingFlags.Instance | BindingFlags.Public); //获取attrs
            foreach (PropertyInfo attr in attrs)
            {
                string key = attr.Name;  //获取attr name
                object value = attr.GetValue(obj, null); //获取value                    Type type = attr.PropertyType; //类型
            }

关键就是那个 Type ， 获取Type后就可以做很多了

常用的方法

        T.GetProperty("key").GetValue(obj, null); //read a key value
        T.GetProperty("key").SetValue(obj, "", null); //write a value to key
        //注意如果是字典
        T.GetProperty("Item").GetValue(obj, new [] {"id"}); //先拿Item 然后才通过 new[] {这里放指定的key}

再来看看更详细的

    class MyClass
    {
        public int x { get; set; }
        public int y { get; set; }
        public MyClass(int i)
        {
            x = y + i;
        }
        public MyClass(int i, int j)
        {
            x = i;
            y = j;
        }
        public int sum()
        {
            return x + y;
        }
    }

我们想获取这个Class 的构造函数

            Type t = typeof(MyClass);
            ConstructorInfo[] constructors = t.GetConstructors();  //使用这个方法获取构造函数列表
            for (int i = 0; i < constructors.Length; i++)
            {
                ConstructorInfo constructor = constructors[i];
                //构造函数也是方法所以有 GetParameters
                ParameterInfo[] parameters = constructor.GetParameters(); //获取当前构造函数的参数列表
                string paraTypeName = parameters[0].ParameterType.Name; //方法的参数类型名称
                string paraName = parameters[0].Name;// 方法的参数名
            }
            //调用构造函数
            object[] args = new object[2];
            args[0] = 10;
            args[1] = 20;
            //不用new 直接实例化
            object instance = constructors[0].Invoke(args);  //实例化一个这个构造函数有两个参数的类型对象,如果参数为空，则为null            object instance = (t)Activator.CreateInstance(t); 还有这种实例的方法,不清楚可以放参数没有

调用方法

            MethodInfo[] methods = T.GetMethods(BindingFlags.Public | BindingFlags.DeclaredOnly | BindingFlags.Instance);
            foreach (MethodInfo method in methods)
            {
                string return_name = method.ReturnType.Name; //返回方法的返回类型
                string name = method.Name;
                if (name.Equals("sum", StringComparison.Ordinal)) //指定方法名调用
                {
                    int value = (int)method.Invoke(instance, null);  //instance是之前实例好的对象,方法就是在这个对象之中
                }
            }

下面是一些参考

        Type t = typeof(MyClass);
        Console.WriteLine("----------------Method------------------");
        MethodInfo[] methods = t.GetMethods();
        foreach (MethodInfo method in methods)
        {
            Console.WriteLine("Method:" + method);
            //Console.WriteLine(method);
            //Console.WriteLine("返回值：" + method.ReturnParameter);
        }
        Console.WriteLine("---------------Field-------------------"); //字段 ,比如这种  private static string name;
        FieldInfo[] fields = t.GetFields(BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.Static);
        foreach (FieldInfo field in fields)
        {
            Console.WriteLine("Field:" + field);
        }
        Console.WriteLine("--------------Member--------------------"); //成员即方法和属性
        MemberInfo[] members = t.GetMembers();
        foreach (MemberInfo member in members)
        {
            Console.WriteLine("Member:" + member);
        }
        Console.WriteLine("--------------Property--------------------"); //属性
        PropertyInfo[] properties = t.GetProperties();
        foreach (PropertyInfo property in properties)
        {
            Console.WriteLine("Property:" + property);
        }
        Console.WriteLine("--------------Constructor--------------------"); //构造函数
        ConstructorInfo[] constructors = t.GetConstructors(BindingFlags.NonPublic | BindingFlags.Instance);
        foreach (ConstructorInfo constructor in constructors)
        {
            Console.WriteLine("Constructor:" + constructor);
        }     

调用不用记太清楚，主要知道什么东西可以用反射获取和调用就可以了。

比较长使用的地方是用泛型写方法的时候，比如我们的泛型是一个不确定的类，然后我们要获取attr值等等的，就很好可以使用反射了。

还有通过string来调用方法，这个在js很长用到，比如 obj["methodName"](); 这里也可以用到反射来实现。

p.s : 反射的性能是很慢的，也可以说动态就是慢，这个很正常啦，反射的性能优化可以参考使用动态编程之类的，不过这里就不提先啦。

泛型和反射