c#反射的一些总结

最新推荐文章于 2024-04-19 15:52:09 发布

w343516704

最新推荐文章于 2024-04-19 15:52:09 发布

阅读量395

点赞数

分类专栏： c#语言基础文章标签： c# 反射 Reflection

c#语言基础专栏收录该内容

37 篇文章 8 订阅

订阅专栏

c#反射是一种用于获取结构元素据的技术，由于效率的问题，在开发应用程序中用的比较少

新建一个控制台app，创建如下类：

 public class RefClass
          {
             private int _test3;
             private int _test1 { get; set; }
             protected int Test2 { get; set; }
            public int Test3 { get; set; }

            public void Show()
            {

          }
        }

之所以在类中以不同的访问修饰符创建了属性，主要是研究反射的权限问题。

接下来，可以研究反射了。在研究之前，先总结一句：C#的反射的关键是创建一个System.Type类的实例，可以通过Object.GetType()方法，该方法主要是反射实例（对象），也可以通过操作符typeof来反射一个静态的或者没有实例化的类从而得到type。然后，System.Type的方法都会返回一个System.Reflection命名空间中的类型的数组（对应的都有单类型，比如说Type.GetMethods(),有对应的type.GetMethod(),上述两个方法分别返回MethodInfo[]和MethodInfo等等）。

首先研究MemberInfo：

之所以先说MemberInfo，是因为它是PropertyInfo和MethodInfo的基类，下面是反射代码：

static void Main(string[] args)
        {
            Type t = typeof(RefClass);
            MemberInfo[] minfos = t.GetMembers();
            foreach (MemberInfo minfo in minfos)
            {
                Console.WriteLine(minfo.Name);
            }
            Console.ReadKey();
        }

在这里我们获取这个类的类型，然后获取了其中的公共成员（可能很多人都会认为GetMembers是获取全部，但其实只是获取公开的所有成员。）然后我们通过foreach将所有的成员的名称循环输出。

然后我们可以查看控制台的输出：

在这里我们可以看到其中不仅仅输出了我们所写类中的成员，同时还输出了父类的成员（如果不理解的这里帮你们补充下基础，Object是所有类的基类。），细心的读者一定会发现这里的输出并没有包含private和protected访问权限的成员。这就应了上面的那句话：GetMembers默认返回公开的成员。

仅仅只能看到这些公开的成员对我们来说意义并不大，所以我们需要查看到那些非公有的成员。

下面我们将上面的代码改成如下所示：

static void Main(string[] args)
        {
            Type t = typeof(RefClass);
            MemberInfo[] minfos = t.GetMembers(BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.Public );
            foreach (MemberInfo minfo in minfos)
            {
                Console.WriteLine(minfo.Name);
            }
            Console.ReadKey();
        }

从中我们看到我们使用了GetMembers的重载版本，并且传入了枚举类型，分别是“包含非公开”、“包含实例成员”和“包含公开”。然后我们就可以获取到所有成员了。

最终我们将会得出下面这些成员：

到这里你可能会认为我们已经检索结束了，但是你有没有发现属性很多，而且还包含了大量的父类中的属性，假设我们只关注该类中的成员，并不关注父类中的成员该如何做呢？

其实我们只需要加上一个枚举类型（BindingFlags.DeclaredOnly）：

1 MemberInfo[] minfos = t.GetMembers(BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.Public | BindingFlags.DeclaredOnly );

然后我们再查看结果：

此时就只包含该类中的成员了。

下面我们在RefClass类中添加两个静态方法，如下所示：

public class RefClass
        {
            private int _test3;
            private int _test1 { get; set; }
            protected int Test2 { get; set; }
            public int Test3 { get; set; }

            private static void Show2()
            {
            }

            public static void Show3()
            {
            }

public void Show()
{

}
}

然后我们继续查看，可以发现最终的结果并没有输出这些静态成员。这个时候我们只需要在GetMembers中加上一个枚举：BindingFlags.Static即可。

这里我们仅仅输出了所有的成员，但是却没有区分出是方法还是属性所以我们在Main中添加一个方法：

static void Main(string[] args)
        {
            Type t = typeof(RefClass);
            Func<MemberTypes, String> getType = (x) =>
            {
                switch (x)
                {
                    case MemberTypes.Field:
                        {
                            return "字段";
                        }
                    case MemberTypes.Method:
                        {
                            return "方法";
                        }
                    case MemberTypes.Property:
                        {
                            return "属性";
                        }
                    default:
                        {
                            return "未知";
                        }
                }
            };
            MemberInfo[] minfos = t.GetMembers(BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.Public | BindingFlags.DeclaredOnly | BindingFlags.Static );
            foreach (MemberInfo minfo in minfos)
            {
                Console.WriteLine(minfo.Name + ";类型:" + getType(minfo.MemberType));
            }
            Console.ReadKey();
        }

这里我用了一个局部方法来根据类型输出对应的文本，因为篇幅的原因我就只判断了几个基本的类型。

最终输出的结果如下：

到此为止我们已经能够窥视整个结构。

深入窥视字段

通过上面的内容我们仅仅纵览了全局，下面我们将要继续深入，首先我们先拿字段下手。

这里我们不在使用GetMembers而需要使用GetFields（当然跟GetMembers一样如果不传入指定的枚举只返回公开的字段），代码如下所示：

static void Main(string[] args)
        {
            Type t = typeof(RefClass);
            FieldInfo[] finfos = t.GetFields(BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly);
            foreach (FieldInfo finfo in finfos)
            {
                Console.WriteLine("字段名称：{0} 字段类型:{1} ", finfo.Name, finfo.FieldType.ToString());
            }
            Console.ReadKey();
        }

最终的输出结果如下所示：

一直到这里大家都会认为我们仅仅只是分析，感觉没有什么实质的东西，下面就来点实质的东西，你可以看到_test3、_test1和Test2是私有和保护类型，

是不可以获取到它们的值的，但是我们通过反射却可以，具体的代码如下所示：

static void Main(string[] args)
        {
            Type t = typeof(RefClass);
            RefClass rc = new RefClass();
            rc.Test3 = 3;
            FieldInfo[] finfos = t.GetFields(BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly);
            foreach (FieldInfo finfo in finfos)
            {
                Console.WriteLine("字段名称：{0} 字段类型:{1} rc中的值为:{2}", finfo.Name, finfo.FieldType.ToString(), finfo.GetValue(rc));
            }
            Console.ReadKey();
        }

可以看到我实例化了这个类，并且设置了Test3为3，下面我通过finfo.GetValue输出了这个值，结果如下图：

现在是不是感觉有点酷了？这还没完呢，我们光获取不算什么，下面我们还要修改它的值：

static void Main(string[] args)
        {
            Type t = typeof(RefClass);
            RefClass rc = new RefClass();
            rc.Test3 = 3;
            FieldInfo[] finfos = t.GetFields(BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly);
            foreach (FieldInfo finfo in finfos)
            {
                finfo.SetValue(rc, 100);
                Console.WriteLine("字段名称：{0} 字段类型:{1} rc中的值为:{2}", finfo.Name, finfo.FieldType.ToString(), finfo.GetValue(rc));
            }
            Console.ReadKey();
        }

这里我只是在foreach中增加了一条语句finfo.SetValue(rc,100)，下面我们继续看最终输出的结果：

是不是现在感觉可以为所欲为了？但是还没有完。

深入窥视属性

因为属性存在get和set，并且两者都是方法，所以比较棘手。我们需要通过属性对象获取get和set方法，在通过调用他们才达到修改这个属性的值。

比如下面的代码：

static void Main(string[] args)
        {
            Type t = typeof(RefClass);
            RefClass rc = new RefClass();
            rc.Test3 = 3;
            PropertyInfo[] finfos = t.GetProperties(BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly);
            foreach (PropertyInfo finfo in finfos)
            {
                MethodInfo getinfo = finfo.GetGetMethod(true);
                Console.WriteLine("get方法的名称{0} 返回值类型:{1} 参数数量:{2} MSIL代码长度:{3} 局部变量数量:{4}", getinfo.Name, getinfo.ReturnType.ToString(),
                    getinfo.GetParameters().Count(),
                    getinfo.GetMethodBody().GetILAsByteArray().Length,
                    getinfo.GetMethodBody().LocalVariables.Count);

                MethodInfo setinfo = finfo.GetSetMethod(true);
                Console.WriteLine("get方法的名称{0} 返回值类型:{1} 参数数量:{2} MSIL代码长度:{3} 局部变量数量:{4}", setinfo.Name, setinfo.ReturnType.ToString(),
                    setinfo.GetParameters().Count(),
                    setinfo.GetMethodBody().GetILAsByteArray().Length,
                    setinfo.GetMethodBody().LocalVariables.Count);

                setinfo.Invoke(rc, new object[] { 123 });
                object obj = getinfo.Invoke(rc, null);
                Console.WriteLine("方法名:{0} 内部值:{1}", finfo.Name, obj);
            }
            Console.ReadKey();
        }

这里我们循环每个属性，通过GetGetMethod获取get方法（调用该方法时如果传入true则无法获取非公开的get方法set也是一样），接着我们输出了该方法的返回类型和参数数量和MSIL代码长度以及局部变量的数量，

当然你如果有兴趣可以继续分析输入参数以及局部变量等，这里由于篇幅的缘故就不能介绍太多了。最后我们调用了set方法将值改变，然后再通过调用get方法获取这个属性的值。

最终的结果如下所示:

深入窥视方法

首先我们需要将RefClass修改成如下所示:

public class RefClass
        {
            private int _test3;
            private int _test1 { get; set; }
            protected int Test2 { get; set; }
            public int Test3 { get; set; }

private static void Show2()
{

}

            public static string Show3(string s)
            {
                int b;
                int c;
                return s;
            }

            public string Show(string s)
            {
                string a;
                return s;
            }
        }

主要是在方法中增加局部变量并且加上返回值，避免最后输出的时候没有值。其实这里的方法跟属性部分类似，但是为了能够完整的描述所有，所以笔者依然会讲解一遍。

下面我们直接上代码：

static void Main(string[] args)
        {
            Type t = typeof(RefClass);
            RefClass rc = new RefClass();
            rc.Test3 = 3;
            MethodInfo[] finfos = t.GetMethods(BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly | BindingFlags.Static );
            foreach (MethodInfo finfo in finfos)
            {
                if (finfo.GetParameters().Count() > 0 && finfo.GetParameters()[0].ParameterType == typeof(string) )
                {
                    object obj = finfo.Invoke(rc, new[] { "123" });
                    MethodBody mbody = finfo.GetMethodBody();
                    Console.WriteLine("拥有参数的方法名:{0} 返回值类型:{1} 参数1类型:{2} 参数1名称:{3} 方法调用后返回的值:{4}",
                        finfo.Name,
                        finfo.ReturnType.ToString(),
                        finfo.GetParameters()[0].ParameterType.ToString(),
                        finfo.GetParameters()[0].Name,
                        obj.ToString());
                }
                else
                {
                    MethodBody mbody = finfo.GetMethodBody();
                    Console.WriteLine("没有参数的方法名:{0} 返回值类型:{1}",
                        finfo.Name,
                        finfo.ReturnType.ToString());
                }
            }
            Console.ReadKey();
        }