C#反射中的GetConstructor与GetConstructors构造函数参数的获取

C#编写代码时构造函数参数的获取需要用到反射中的GetConstructor与GetConstructors来实现，在具体使用的时候难点就在于他们的参数相对其他的反射类的内置函数要复杂一些，这里我们用代码实例的方式介绍给大家。

一、GetConstructor

GetConstructor这个函数的用法，相比GetConstructors显得更复杂，复杂就复杂在它自身的参数有些多，当仔细看清楚各种参数的功能。

1、构建一个多重载构造函数类

假定我们设计了一个类，并且设计了有个构造函数重载的RegValidator类（原本这个类是用来做正则式校验的，这里我将构造函数部分抽取出来作用实例），而且特别注意我们还为它设计了一个多参数的构造函数，如下：

  class RegValidator
    {

        private string name;
        private int inputLen;
        private bool checkState;

        public string Name{get{return name;}}
        public int InputLen { get { return inputLen; } }
        public bool CheckState { get{ return checkState; } }

        public RegValidator()
        {

        }

        public RegValidator(string str)
        {
            this.name = str;
        }

        private RegValidator(int len)
        {
            this.inputLen = len;
        }

        static RegValidator()
        {

        }

        public RegValidator(string str,int len,bool ischeck)
        {
            this.name = str;
            this.inputLen = len;
            this.checkState = ischeck;
        }
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38

2、单参数和无参数构造函数获取

我们该如何调用呢？这里的调用必须要配合type类数组，这个数字就是用来描述参数的类型的，也就是说构造函数的参数有几个参数，我们的这个数字就有多长。当然，我们如果要过滤多个重载的构造函数就必须使用BindingFlags（这个在后面会详细说）参数。下面是使用实例：

 static void Main(string[] args)
    {
        Type type = typeof(RegValidator);

        //对私有构造函数访问（单参数int类型）
        ConstructorInfo privateConstructor = type.GetConstructor(BindingFlags.Instance | BindingFlags.NonPublic,
            null, new[] { typeof(int) }, null);
        Console.WriteLine(privateConstructor.IsPrivate); //return true

        //对公有构造函数访问（单参数string类型）
        ConstructorInfo publicConstructor = type.GetConstructor(BindingFlags.Instance | BindingFlags.Public,
            null, new[] { typeof(string) }, null);
        Console.WriteLine(publicConstructor.IsPublic); //return true

        //对默认构造函数访问（无参）
        ConstructorInfo publicDefaultConstructor = type.GetConstructor(Type.EmptyTypes);
        Console.WriteLine(publicDefaultConstructor.IsPublic); //return true

        //对静态构造函数访问（无参）
        ConstructorInfo staticConstructor = type.GetConstructor(BindingFlags.Static | BindingFlags.NonPublic,
            null, new Type[] { }, null);
        Console.WriteLine(staticConstructor.IsStatic); //return true
        Console.ReadLine();
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

从运行的结果看，都是正确的获取了构造函数

3、多参数构造函数获取

那如果是多个参数的构造函数呢？我们如何通过反射来获取构造函数的参数呢？这个就必须要对应的参数类型数组

 ConstructorInfo paras = type.GetType().GetConstructor(new Type[] {typeof(string),typeof(int),typeof(bool)});
  foreach (ParameterInfo p in paras.GetParameters())
   {
       Console.WriteLine(p.Name+s.get);
   }
1
2
3
4
5

4、关于参数BindingFlags

利用BindingFlags来过滤搜索构造函数的标记，下面是BindingFlags里面的常用标记的作用：
BindingFlags.Static ，搜索静态的构造函数
BindingFlags.Public，搜索公有的构造函数
BindingFlags.NonPublic，搜索中包涵非公有构造函数如（private, internal, protected ），但基类的构造函数则不返回。
这些标记用或标记“|”来叠加在一起，如：
BindingFlags bf = BindingFlags.Public
| BindingFlags.Static
| BindingFlags.NonPublic
| BindingFlags.Instance;

二、GetConstructors

1、无参重载

GetConstructors完全可以无参运行，这个无参的重载利于我们使用。但无过滤作用。

 ConstructorInfo[] cinfos = type.GetConstructors();
 
        // Display all the public instance constructors
      Type type = typeof(RegValidator);
       Console.WriteLine("All constructors are shown below");
       ConstructorInfo[] cinfos = type.GetConstructors();
            foreach(ConstructorInfo ci in cinfos)
                Console.WriteLine(ci);
1
2
3
4
5
6
7
8

输出的效果如下：

2、有参重载

GetConstructors也可以带参数运行，这样就可以对众多的构造函数进行过滤了。如：

 Type type = typeof(RegValidator);
 
        //利用BindingFlags来过滤搜索构造函数
        BindingFlags bf = BindingFlags.Public
                          | BindingFlags.Static
                          | BindingFlags.NonPublic
                          | BindingFlags.Instance;
 
 		 Console.WriteLine("All constructors are shown below");
         ConstructorInfo[] cinfos = type.GetConstructors(bf);
            foreach(ConstructorInfo ci in cinfos)
                Console.WriteLine(ci);
   
1
2
3
4
5
6
7
8
9
10
11
12
13