反射

来源http://www.cnblogs.com/yaozhenfa/p/CSharp_Reflection_1.html

使用反射的一种思路：面向接口编程中，一个方法要兼容多个数据库链接，不知道可以使用哪一种数据库，所以数据库操作类是未知的，这时就可以通过反射获取操作类信息，进行判断是属于那一类的数据库，做出相应的措施。

自己的代码实践：

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Windows.Forms;
using System.Net;
using System.Net.Sockets;
using System.Reflection;

namespace WindowsFormsApplication1
{
    //测试类
    public class TestClass
    {
        // 共有/私有/受保护的字段
        // 属性和字段区别：属性可以存储数据
        //get set 其实就是方法
        public int publicT1 { get; set; }
        private int privateT2 { get; set; }
        protected int protectedT3 { get; set; }
        public int T4 = 1;
        //公有/私有/受保护的方法
        public void publicShow() { }
        private void privateShow() { }
        protected void protectedShow() { }
        //静态方法
        public static void StaticF()
        {

        }

    }
    public partial class Form1 : Form
    {
        /**
         * 目的：学习反射
         * 1.创建一个类：有公共/私有/受保护的字段和方法
         * 2.通过学习反射获取改类的内部信息
         * 3.在窗口中程序中进行测试，用label控件反馈内容
         * 步骤：
         * 1.前期准备
         * 2.窥视内部
         * 3.深入窥视字段
         * 4.深入窥视属性
         * 5.深入窥视方法
         */
        public Form1()
        {
            InitializeComponent();
        }
        //测试的前提假设：TestClass类是一个我们不知道的类
        private void Form1_Load(object sender, EventArgs e)
        {

            //label1.Text = Easy(); 
            //label1.Text = Easy2(); 
            //label1.Text = Easy3(); 
            //label1.Text = Easy4(); 
            //label1.Text = Field();
            //label1.Text = Properties();
            label1.Text = Method();

        }
        //简单方法：窥视内部，可以获取公共的属性和方法，除了静态成员，包含基类属性和方法。
        string Easy() 
        {
            string str = "";
            //Type：表示类型声明。告诉系统，这是一个类
            Type t = typeof(TestClass);
            //MemberInfo:封装成员信息，并提供对其元数据的访问，的数组。
            MemberInfo[] m = t.GetMembers();
            foreach(MemberInfo mb in m)
            {
                str += mb.Name +"
";
            }
            return str;
        }
        //简单方法2：窥视内部，通过重载GetMembers（）方法，可以获取所有的的属性和方法，除了静态成员，包含基类属性和方法。
        string Easy2()
        {
            string str = "";
            Type t = typeof(TestClass);
            //传入了枚举类型，分别是“包含公开”、“包含非公开”、“包含实例成员”。然后我们就可以获取到所有成员了。
            //BindingFlags这个枚举可以告诉GetMembers方法你需要返回什么内容。
            MemberInfo[] m = t.GetMembers(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance);
            foreach (MemberInfo mb in m)
            {
                str += mb.Name + "
";
            }
            return str;
        }
        //简单方法3：窥视内部，通过重载GetMembers（）方法，可以获取所有的的属性和方法，除了静态成员，不包含基类属性和方法。
        string Easy3()
        {
            string str = "";
            Type t = typeof(TestClass);
            //只需要新加上一个枚举类型BindingFlags.DeclaredOnly
            MemberInfo[] m = t.GetMembers(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly);  
            foreach (MemberInfo mb in m)
            {
                str += mb.Name + "
";
            }
            return str;
        }
        //简单方法4：窥视内部，通过重载GetMembers（）方法，可以获取所有的的属性和方法，包含静态成员，不包含基类属性和方法。
        string Easy4()
        {
            //Lambda表达式，Func是有返回值的泛型委托,是一个匿名函数：Func<参数类型，返回值类型>  getType = (形参列表) => 函数体
            //意思就是:创建一个委托，里面存储一个匿名函数，通过调用该委托实现方法的使用。
            //达到的效果是：方法中定义方法，然后调用
            Func<MemberTypes, string> getType = (x) =>  
            {
                switch (x)
                {
                    case MemberTypes.Field:
                        return "字段";
                    case MemberTypes.Method:
                        return "方法";
                    case MemberTypes.Property:
                        return "属性";
                    default:
                        return "未知";
                }
            };
            string str = "";
            Type t = typeof(TestClass);
            //只需要新加上一个枚举类型BindingFlags.Static
            MemberInfo[] m = t.GetMembers(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly |BindingFlags.Static);
            foreach (MemberInfo mb in m)
            {
                str += mb.Name + ",类型:" 
                    + getType(mb.MemberType) //调用委托，启用匿名方法
                    + "
"; 
            }
            return str;
        }
        //字段方法：深入窥视字段，不再全部获取，单单获取字段
        string Field() 
        {
            string str = "";
            Type t = typeof(TestClass);
            //FieldInfo封装字段信息
            FieldInfo[] f = t.GetFields(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly );
            foreach (FieldInfo fi in f)
            {
                str += fi.Name 
                    + "
";
            }
            return str;
        }
        //属性方法：深入窥视属性，单单获取属性
        string Properties() 
        {
            string str = "";
            Type t = typeof(TestClass);
            //FieldInfo封装字段信息
            PropertyInfo[] f = t.GetProperties(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly);
            foreach (PropertyInfo fi in f)
            {
                str += fi.Name
                    + "
";
            }
            return str;
        }
        //函数方法：深入窥视方法，单单获取方法
        string Method()
        {
            string str = "";
            Type t = typeof(TestClass);
            //FieldInfo封装字段信息
            MethodInfo[] f = t.GetMethods(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly);
            foreach (MethodInfo fi in f)
            {
                str += fi.Name
                    + "
";
            }
            return str;
        }
    }
    
}