menu 首页 主站 标签 归档 关于
search more_vert
CSharp反射之类(3)

一言加载中...

本篇文章暂不介绍反射获取：非public 修饰的方法、字段、属性等。

前置类

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
public class Animal
{
    public int ID = 1001;

    public int Age { get; set; }
    public string Name { get; set; }

    public Animal() { }
    public Animal(string name, int age) { Name = name; Age = age; }
    public void Speak() { Console.WriteLine("沉默中..."); }
    public void Speak(string msg) { Console.WriteLine(Name + " says: " + msg); }
    public string Calculate() { return "test"; }

    public static string MSG = "hello!";
    public static int Exp { get; set; }
    public static int Calculate(int a, int b) { return a + b; }

    public void RefMethod1(int a, ref int b) { b = a + 1; }
    public void RefMethod2(ref int a, ref int b) { 
        int temp = a; a = b; b = temp;
    }
}

public class Cat:Animal{ public Cat() : base() { } }

判断是类，获取基类

1
2
3
4
5
6
Console.WriteLine("IsClass: " + typeof(Cat).IsClass);
//> IsClass: True

//获取基类
Console.WriteLine("BaseClass: " + typeof(Cat).BaseType);
//> BaseClass: Demo.Animal

成员

成员是指：除了Assembly,Module外所有的类型，如：构造方法，方法，属性，字段，委托等所有的集合。

反射创建对象

方式多多，这里记录两种方式

1
2
3
4
5
6
7
8
9
10
11
Type type = typeof(Animal);

// 方式一（无参，两个参数）
var kitty1 = (Animal)Activator.CreateInstance(type);
var kitty2 = (Animal)Activator.CreateInstance(type, new object[] { "Kitty", 3 });

//方式二 通过构造方法(无参，两个参数)
ConstructorInfo constructor0 = type.GetConstructor(Type.EmptyTypes);
ConstructorInfo constructor2 = type.GetConstructor(new Type[] { typeof(string), typeof(Int32) });
var tom1 = constructor0.Invoke(new object[] { }) as Animal;
var tom2 = constructor2.Invoke(new object[] { "Tom", 3 }) as Animal;

类的属性

通过GetProperty、GetProperties获取一个或多个属性。

1
2
3
4
5
6
7
8
9
10
11
12
13
// 获取属性(非静态)
var ageProperty = typeof(Animal).GetProperty("Age");
// 获取属性的值(非静态)
Animal dog = new Animal();
Console.WriteLine(ageProperty.GetValue(dog));
ageProperty.SetValue(dog, 999);
Console.WriteLine(ageProperty.GetValue(dog));

// 静态属性
var property = typeof(Animal).GetProperty("Exp");
Console.WriteLine(property.GetValue(null, null));
property.SetValue(null, 999);
Console.WriteLine(property.GetValue(null));

类的字段

通过GetField、GetFields获取一个或多个字段。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
// 公有非静态
FieldInfo[] fields = type.GetFields();      // 获取所有字段

Animal bird = new Animal();
FieldInfo field = type.GetField("ID");     // 获取某个字段
Console.WriteLine(field.GetValue(bird));   // 获取字段的值
field.SetValue(bird, 999);                 // 设置字段的值
Console.WriteLine(field.GetValue(bird));   

// 公有静态
var field = typeof(Animal).GetField("MSG1");
Console.WriteLine(field.GetValue(null));
field.SetValue(null, "hi");
Console.WriteLine(field.GetValue(null));

类中的方法

通过GetMethod、GetMethods获取一个或多个方法。特殊的有构造方法，使用GetConstructor获取。

构造方法

上面通过反射创建对象时有记录到，不再赘述。

非静态方法

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
Animal bird = new Animal();
// 无参方法
var method0 = typeof(Animal).GetMethod("Speak", Type.EmptyTypes);
method0.Invoke(bird,new Type[] {});

// 有参数方法
var method1 = typeof(Animal).GetMethod("Speak", new Type[] { typeof(string) });
method1.Invoke(bird, new object[] { "早上好" });

// 有返回值
var method2 = typeof(Animal).GetMethod("Calculate", Type.EmptyTypes);
object result = method2.Invoke(bird, new Type[] { });

// 部分参数含有ref
object[] objs = new object[] { 100, null };
var method4 = typeof(Animal).GetMethod("refMethod1");
method4.Invoke(bird, objs);
Console.WriteLine(objs[0]+" : "+ objs[1]);
//> 100 : 101

//所有参数含有ref
object[] objs = new object[] { 0, 99 };
var method3 = typeof(Animal).GetMethod("RefMethod2");
method3.Invoke(bird, objs);
Console.WriteLine(objs[0]+" : "+ objs[1]);
//> 99 : 0

静态方法

1
2
3
4
// 有返回值
var method4 = typeof(Animal).GetMethod("Calculate", new Type[] { typeof(Int32), typeof(Int32) });
object sum = method4.Invoke(null, new object[]{ 100, 100 });
Console.WriteLine(sum.ToString());

泛型类

泛型可以当作普通的类进行使用，但是实例化泛型时必须指定泛型类型。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
public class MyClass<T>
{
    public MyClass() { Console.WriteLine("执行构造方法"); }
    public void ShowInfo(T a) { Console.WriteLine(a); }
}

public class Program{
    static void Main(string[] args){
        // 获取泛型类型(两种方式效果相同)
        Type type = typeof(MyClass<int>);
        Type type = typeof(MyClass<>).MakeGenericType(new Type[] { typeof(int) });

        // 实例化对象(两种方式效果相同)
        var obj = Activator.CreateInstance(type);
        ConstructorInfo method = typeof(MyClass<int>).GetConstructor(Type.EmptyTypes);
        var obj = method.Invoke(new object[] { });

        // 调用泛型方法
        MethodInfo method = typeof(MyClass<int>).GetMethod("ShowInfo");
        method.Invoke(obj, new object[] { 100 });
        //> 执行构造方法
        //> 100
    }
}

这里对泛型绑定了int类型，可以通过GetGenericTypeDefinition去除泛型与参数类型的绑定。下面举例重新绑定为string类型。

1
2
3
4
5
6
7
8
9
10
11
12
Console.WriteLine(type.FullName);
Type _type = type.GetGenericTypeDefinition();
Console.WriteLine(_type.FullName);
//> Study.MyClass`1[[System.Int32, mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089]]
//> Study.MyClass`1

Type new_type = _type.MakeGenericType(new Type[] { typeof(string) });
var o2 = Activator.CreateInstance(new_type);
var method2 = new_type.GetMethod("ShowInfo");
method2.Invoke(o2, new object[] { "hello" });
//> 执行构造方法
//> hello
写博客不易，请我喝杯咖啡？

评论

arrow_upward