C#中利用反射创建各种对象

发表于 | 更新于 | 分类于 | 评论数： | 阅读次数：

反射构造各种类型实例

在使用反射时，经常要动态的创建各种类型的实例对象，下面就总结一下，如何使用反射创建普通类型对象、数组、委托、泛型对象。

一般类型对象

对于一般类型，直接使用Activity.CreateInstance(Type)进行创建。

1
2
3
4
5
6
7
8
9
10
11
public class Data{}

public class Program
{
    static void Main()
    {
        Type type = typeof(Data);

        object obj = Activitor.CreateInstance(type);
    }
}

创建数组对象

  1. 使用Activitor.CreateInstance创建 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
public class Data{}

public class Program
{

    static void Main()
    {
        //数组元素类型
        Type elementType = typeof(Data);

        //根据数组元素类型，生成数据类型，MakeArrayType可以传递int参数，表示数组的维数
        //默认不传递的话，表示一维数组
        Type arrayType = elementType.MakeArrayType();

        //利用Activitor.CreateInstance创建数组对象实例
        //注意，必须向构造器传递数组的长度，这里为10
        object arrObj = Activator.CreateInstance(arrayType,10);

        Console.WriteLine(((Data[])arrObj).Length);
    }
}
  1. 使用Array.CreateInstance进行创建
1
2
3
4
5
6
7
8
9
10
11
12
13
14
public class Data{}

public class Program
{
    static void Main()
    {
        //数组元素类型
        Type elementType = typeof(Data);

        //第一个参数为数据元素的类型，第二个为数组长度
        //Array.CreateInstance还提供了其他几个重写方法，可以支持多为数组的创建
        Array arrObj = Array.CreateInstancee(elementType,10);
    }
}

委托类型创建

委托类型创建，可以通过Delegate.CreateDelegate(Type,object,MethodInfo);

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
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
public delete void CustomDele();

public class Program
{
    static void Main()
    {
        //创建静态函数的委托
        CreateStaticDelete();

        //创建成员函数的委托
        CreateInstanceDelete();
    }

    static void CreateStaticDelete()
    {
        //要生成委托的类型
        Type delType = typeof(CustomDele);

        //要绑定的方法
        MethodInfo mInfo = typeof(Program).GetMethod("SayHello",BindingFlags.Public|BindingFlags.NonPublic|BindingFlags.Static);

        //利用Delegate.CreateDelegate()创建委托
        //第一个参数为委托类型
        //第二个参数为方法实体对象，如果是成员函数，需要制定，静态则不需要指定
        //第三个参数为绑定方法的MethodInfo
        Delegate deleObj = Delegate.CreateDelegate(delType,null,mInfo);

        //调用委托，如果委托具备参数，可以向DynamicInvoke传递参数
        deleObj.DynamicInvoke();
    }

    static void CreateInstanceDelete()
    {
        //获取委托类型
        Type delType =typeof(CustomDele);

        //创建实例对象
        Cat cat = new Cat();

        //获取方法
        MethodInfo mInfo = typeof(Cat).GetMethod("Sleep");

        //因为委托要绑定的是成员函数，所以要传递类实例
        Delegate deleObj = Delegate.CreateDelegate(delType,cat,mInfo);

        //调用委托
        CustomDele act = (CustomDele)deleObj;
        act();
    }
    static void SayHello(){}
}

public class Cat
{
    public void Sleep(){}
}

创建泛型对象

在创建泛型对象之前，首先要了解一下泛型相关的知识，泛型可以分为开发类型和封闭类型。
开放类型是指未指定了泛型的类型参数的泛型，如Dictionary就是开放类型，开放类型是不能构造实例的，很好理解，因为不知道创建的TKey，TValue是什么类型。
封闭类型是指指定了泛型类型参数的，如Dictionary这里的string类型和int类型称之为类型实参。

下面看一下如何具体创建一个泛型实例对象

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
public class Program
{
    static void Main()
    {
        //首先获取泛型的开放类型
        Type openType = typeof(Dictionary<,>);

        //然后获取封闭类型
        Type closeType = openType.MakeGenericType(typeof(string),typeof(int));

        //然后根据封闭类型创建类型实例
        object obj = Activitor.CreateInstance(closeType);

        Console.WriteLine(obj.GetType());
    }
}