.Net中的反射

反射

使用反射，可以在程序运行时创建、调用和访问类型实例。 

程序集(Assembly)包含模块(Module)、模块包含类型(Type)，而类型包含成员(Member)。 可以使用反射动态地创建类型的实例，将类型绑定到现有对象，或从现有对象中获取类型。

简单的来说，就是平常我们创建类实例，访问类成员函数、变量等，都是在开发环境中写好代码再去执行。使用反射后，可以在程序运行时，执行上述操作。

 

反射有时候也会用，这算是一个比较系统的总结了吧。

 

反射的典型用法

• 使用 Assembly 来定义和加载程序集，加载程序集清单中列出的模块，以及在此程序集中定位一个类型并创建一个它的实例。

• 使用 Module 发现信息，如包含模块的程序集和模块中的类。 还可以获取所有全局方法或模块上定义的其它特定的非全局方法。

• 使用 ConstructorInfo 发现信息，如名称、参数、访问修饰符（如 public 或 private）和构造函数的实现详细信息（如 abstract或 virtual）。 使用 Type 的 GetConstructors 或 GetConstructor 方法来调用特定构造函数。

• 使用 MethodInfo 发现信息，如名称、返回类型、参数、访问修饰符（如 public 或 private）和方法的实现详细信息（如 abstract 或 virtual）。 使用 Type 的 GetMethods 或 GetMethod 方法来调用特定方法。

• 使用 FieldInfo 发现信息，如名称、访问修饰符（如 public 或 private）和一个字段的实现详细信息 （如 static）；并获取或设置字段值。

• 使用 EventInfo 发现信息（如名称、事件处理程序的数据类型、自定义特性、声明类型以及事件的反射的类型），并添加或删除事件处理程序。

• 使用 PropertyInfo 发现信息（如名称、数据类型、声明类型，反射的类型和属性的只读或可写状态），并获取或设置属性值。

• 使用 ParameterInfo 发现信息，如参数的名称、数据类型、参数是输入参数还是输出参数以及参数在方法签名中的位置。

• 使用 CustomAttributeData 在于应用程序域的仅反射上下文中工作时发现有关自定义特性的信息。 CustomAttributeData 使你能够检查特性，而无需创建它们的实例。

 

System.Type

表示类型声明：类类型、接口类型、数组类型、值类型、枚举类型、类型参数、泛型类型定义，以及开放或封闭构造的泛型类型

 

Type是一个抽象的基类，实例化了一个Type对象，实际上就实例化了Type的一个派生类。

获取给定类型的Type引用有3种常用方式：

1、使用typeof运算符

var strType = typeof(string);

2、使用GetType()方法，所有的类都会从System.Object继承这个方法

     string str = "HelloWorld";
     var strType2 = str.GetType();

3、使用Type类的静态方法GetType

var t = Type.GetType("System.String");

 

System.Type常用属性

属性	返回值
Name	数据类型名
FullName	数据类型的完全限定名（包括命名空间）
Namespace	数据类型的命名空间
BaseType	该Type的直接基本类型
Module	该类型的模块 (DLL)
Assembly	该类型的 Assembly

 

 

class Program
    {
        static void Main(string[] args)
        {
            var t = Type.GetType("System.String");
            Console.WriteLine(t);


            Console.WriteLine("Name:" + t.Name);
            Console.WriteLine("FullName:" + t.FullName);
            Console.WriteLine("Namespce:" + t.Namespace);
            Console.WriteLine("BaseType:" + t.BaseType);
            Console.WriteLine("Assembly:" + t.Assembly.FullName);
            Console.WriteLine("Module:" + t.Module.Name);
        }
    } 

 

Type类包含许多Is开头的属性，这些属性用于判断该Type是否属于该类型。常用的如下：

属性	说明
IsAbstract	是否是抽象类型
IsArray	是否为数组
IsByRef	是否是引用传递
IsClass	是否是一个类或委托
IsCOMObject	是否为 COM 对象
IsConstructedGenericType	是否表示构造的泛型类型的值
IsContextful	指示 Type 在上下文中是否可以被承载
IsEnum	是否是枚举
IsExplicitLayout	是否放置在显式指定的偏移量处的值
IsGenericMethodParameter	是否表示泛型方法定义中的类型参数
IsGenericParameter	是否表示泛型类型或方法的定义中的类型参数
IsGenericType	是否是泛型类型
IsGenericTypeDefinition	是否表示可以用来构造其他泛型类型的泛型类型定义
IsGenericTypeParameter	是否表示泛型类型定义中的类型参数
IsImport	是否应用了 ComImportAttribute 属性
IsInterface	是否是接口
IsLayoutSequential	是否按顺序（定义顺序或发送到元数据的顺序）放置的值
IsMarshalByRef	是否按引用进行封送
IsNested	是否表示其定义嵌套在另一个类型的定义之内的类型的值
IsNestedAssembly	是否是嵌套的并且只能在它自己的程序集内可见
IsPointer	是否是指针
IsPrimitive	是否为基元类型之一
IsPublic	是否声明为公共类型
IsSealed	是否声明为密封的
IsSerializable	是否为可序列化的
IsValueType	是否为值类型
IsVisible	是否可由程序集之外的代码访问的值

 

System.Type常用方法

System.Type的大多数方法都用于获取对应数据类型的成员信息：构造函数、属性、方法和事件等。

方法	说明
GetConstructors	获取所有公共构造函数
GetEvents	获取所有公共事件所有公共事件
GetFields	获取所有公共字段
GetMembers	获取所有公共成员
GetMethods	获取所有公共方法
GetProperties	获取所有公共属性

 

这里我们用WPF的Button类来进行演示：

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace ReflectionDemo
{
    class Program
    {
        static void Main(string[] args)
        {
            var buttonType = typeof(System.Windows.Controls.Button);

            var ctors = buttonType.GetConstructors();
            var events = buttonType.GetEvents();
            var fields = buttonType.GetFields();
            var members = buttonType.GetMembers();
            var methods = buttonType.GetMethods();
            var properties = buttonType.GetProperties();

            Console.WriteLine(buttonType.Assembly.FullName);
            PrintResult(ctors, "Constructors");
            PrintResult(events, "Events");
            PrintResult(fields, "Fields");
            PrintResult(members, "Members");
            PrintResult(methods, "Methods");
            PrintResult(properties, "Properties");
        }

        static void PrintResult(object[] array, string title = "")
        {
            Console.WriteLine(title);
            foreach (var item in array)
            {
                Console.WriteLine(item);
            }
            Console.WriteLine();
            Console.WriteLine();
        }
    }
}

 

此外，System.Type还提供了单数形式的方法，如t.GetMethod()、t.GetEvent()。单数形式的方式用于返回指定名称的值。

如：

var buttonType = typeof(System.Windows.Controls.Button);
var clickEvent = buttonType.GetEvent("Click");

 

在前面的示例代码中，我们输出 了string类型的Assembly，如下：

Assembly:mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089

 

mscorlib.dll是我们引用的程序集，如果需要加载外部 程序集并获取类型信息，就需要使用Assembly类

 

System.Reflection.Assembly

Assembly类允许访问给定程序集的元数据，同时它也包含可以加载程序集的方法。

 

要将程序集加载到正在运行的程序中，可以通过两个方法：Assembly.Load()和Assembly.LoadFrom()。

这两个方法的区别是：

Assembly.Load()的参数是指定程序集名称，运行库会在各个位置（运行目录和GAC）搜索该程序集，试图找到该程序集。

Assembly.LoadFrom()的参数是指定程序集的完整路径，它不会在其它位置搜索该程序集

 

 

如何判断类型是否实现了某个接口

typeof(XXInterface).IsAssignableFrom(XXType)

 

如何调用带有out参数的方法

这里以数值类型的TryParse函数为例

parameters[1]就是out返回的参数

var tryParseFunc = xxxx;

            if(tryParseFunc != null)
            {
                object[] parameters = new object[] { getValue.ToString(), null };
                object result = tryParseFunc.Invoke(null, parameters);
                bool blResult = (bool)result;
                if (blResult)
                {
                    //parameters[1];
                }
            }

 

如何获取可空类型的实际声明类型

如Nullable<int>/int?在获取type时，会返回Nullable，而不是int。可以用下面的方法获取int类型

     public static Type GetNullableDeclaringType(Type type)
        {
            if (type.IsGenericType && type.GetGenericTypeDefinition() == typeof(Nullable<>))
            {
                return Nullable.GetUnderlyingType(type);
            }

            return type;
        }

 

动态实例化类型

以CLR FileInfo类型为例

因为FileInfo需要一个string类型的参数，所以这里传递了参数。

 var systemIOAssembly = Assembly.Load("System.IO");
 var type = typeof(FileInfo);
 var instance =  Activator.CreateInstance(type,"D:\\output.txt");

 

对于没有参数的类型，直接使用下面的代码即可

var instance =  Activator.CreateInstance(type);

 

动态调用成员函数

动态实例化类型后，我们可以调用实例的成员函数。

这里以FileInfo.Delete函数为例

首先通过GetMethod函数获取函数类型，然后再调用Invoke函数以调用函数。Invoke函数可以传递调用函数时需要的参数。

Invoke函数的返回值就是函数的返回值。

instance.GetType().GetMethod("Delete").Invoke(instance, null);

 

使用动态类型调用成员函数

也可以使用dynamic关键字，调用方法如下：

 var systemIOAssembly = Assembly.Load("System.IO");
 var type = typeof(FileInfo);
 dynamic instance = Activator.CreateInstance(type, "D:\\output.txt");
 instance.Delete();

这种方法看起来像是用强类型的方式调用一个方法，但是Visual Studio并不会提示，也不会在编译时进行检查。

如果函数名输入错误，则程序会报错。

对于dynamic类型，编译器在编译期间会忽略类型检查。编译器会假设dynamic类型的对象定义的操作都是有效的。

 

使用反射实例化泛型类型

Type d1 = typeof(List<>);


Type listStringType = d1.MakeGenericType(typeof(string));

object instance = Activator.CreateInstance(listStringType);

 

使用反射挂钩委托

这里以WPF程序为例，我们使用反射，为窗口添加一个MouseDown事件处理程序。

首先我们创建一个WPF工程，并添加一个MyWindow窗口类型，同时在MainWindow上增加一个按钮，当按钮点击时，就创建MyWindow类型并显示。

 

MainWindow.xaml

<Window x:Class="ReflectionHookupDelegate.MainWindow"
        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
        xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
        xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
        xmlns:local="clr-namespace:ReflectionHookupDelegate"
        mc:Ignorable="d"
        Title="MainWindow" Height="450" Width="800">
    <Grid>
        <Button Content="动态创建Window" HorizontalAlignment="Center" VerticalAlignment="Center" Click="Button_Click"></Button>
    </Grid>
</Window>

 

挂钩步骤

1、加载程序集

这里因为是在同一个程序集下，所以我们使用Assembly.GetExecutingAssembly即可

 var assembly = Assembly.GetExecutingAssembly();

 

2、获取类型，并创建实例

  Type myWindow = assembly.GetType("MyWindow");
  var myWindowInstance = Activator.CreateInstance(myWindow);

 

3、获取表示该事件的 EventInfo 对象，并使用 EventHandlerType 属性来获取用于处理事件的委托类型。

EventInfo mouseDown = myWindow.GetEvent("MouseDown");
Type tDelegate = mouseDown.EventHandlerType;

 

4、获取表示处理事件的方法的 MethodInfo 对象。 

MouseDown的事件处理程序委托声明如下：

public delegate void MouseButtonEventHandler(object sender, MouseButtonEventArgs e);

 

我们创建一个类 EventProcClass，并添加一个处理函数MyWindowMouseDownHandler

    public class EventProcClass
    {
        public void MyWindowMouseDownHandler(object sender, MouseButtonEventArgs e)
        {
            MessageBox.Show("HelloWorld");
        }
    }

 

然后我们获取表示处理事件的方法的MethodInfo对象

var eventProcClassType = assembly.GetType("ReflectionHookupDelegate.EventProcClass");
MethodInfo myHandler = eventProcClassType.GetMethod("MyWindowMouseDownHandler", BindingFlags.Public | BindingFlags.Instance);

 

5、使用 CreateDelegate 方法创建委托的实例

//创建事件处理程序类型的实例
var evetProcInstance = Activator.CreateInstance(eventProcClassType);

//创建委托
Delegate myEventProcDelegate = Delegate.CreateDelegate(tDelegate, evetProcInstance, myHandler);

 

6、获取 add 访问器方法，并调用该方法以将事件挂钩。 所有事件都有一个 add 访问器和一个 remove 访问器。

MethodInfo addHandler = mouseDown.GetAddMethod();
Object[] addHandlerArgs = { myEventProcDelegate };
addHandler.Invoke(myWindowInstance, addHandlerArgs);

 

7、测试事件（完整代码）

 private void Button_Click(object sender, RoutedEventArgs e)
 {
     //加载程序集
     var assembly = Assembly.GetExecutingAssembly();

     //创建窗口实例
     Type myWindow = assembly.GetType("ReflectionHookupDelegate.MyWindow");
     var myWindowInstance = Activator.CreateInstance(myWindow);

     //获取事件委托类型
     EventInfo mouseDown = myWindow.GetEvent("MouseDown");
     Type tDelegate = mouseDown.EventHandlerType;

     //获取表示处理事件的方法的MethodInfo对象
     var eventProcClassType = assembly.GetType("ReflectionHookupDelegate.EventProcClass");
     MethodInfo myHandler = eventProcClassType.GetMethod("MyWindowMouseDownHandler", BindingFlags.Public | BindingFlags.Instance);

     //创建事件处理程序类型的实例
     var evetProcInstance = Activator.CreateInstance(eventProcClassType);

     //创建委托
     Delegate myEventProcDelegate = Delegate.CreateDelegate(tDelegate, evetProcInstance, myHandler);

     //挂钩事件处理程序
     MethodInfo addHandler = mouseDown.GetAddMethod();
     Object[] addHandlerArgs = { myEventProcDelegate };
     addHandler.Invoke(myWindowInstance, addHandlerArgs);

     //测试显示窗口
     myWindow.GetMethod("Show").Invoke(myWindowInstance, null);
 }

此时我们在界面上点击 ，会弹框并显示"HelloWorld"

 

使用动态方法在运行时生成事件处理程序

在前面的例子中，我们添加了一个类EventProcClass，及一个成员函数MyWindowMouseDownHandler。这都是预先定义好的。

下面的教程演示如何动态生成MyWindowMouseDownHandler函数。

注意：动态方法需要具备一定的IL知识。

https://learn.microsoft.com/en-us/dotnet/standard/managed-code

https://en.wikipedia.org/wiki/Common_Intermediate_Language

 

实现步骤如下：

1、使用轻量动态方法和反射发出可在运行时生成事件处理程序方法。

     若要构造事件处理程序，需要委托的返回类型和参数类型。 可通过检查委托的 Invoke 方法来获取这些类型。

private Type GetDelegateReturnType(Type d)
{
    if (d.BaseType != typeof(MulticastDelegate))
        throw new ArgumentException("Not a delegate.", nameof(d));

    MethodInfo invoke = d.GetMethod("Invoke");
    if (invoke == null)
        throw new ArgumentException("Not a delegate.", nameof(d));

    return invoke.ReturnType;
}

private Type[] GetDelegateParameterTypes(Type d)
{
    if (d.BaseType != typeof(MulticastDelegate))
        throw new ArgumentException("Not a delegate.", nameof(d));

    //可通过检查委托的 Invoke 方法来获取参数类型
    MethodInfo invoke = d.GetMethod("Invoke");
    if (invoke == null)
        throw new ArgumentException("Not a delegate.", nameof(d));

    //获取参数
    ParameterInfo[] parameters = invoke.GetParameters();
    Type[] typeParameters = new Type[parameters.Length];
    for (int i = 0; i < parameters.Length; i++)
    {
        typeParameters[i] = parameters[i].ParameterType;
    }
    return typeParameters;
}

 

Type returnType = GetDelegateReturnType(tDelegate);
if (returnType != typeof(void))
    throw new ArgumentException("Delegate has a return type.");

DynamicMethod handler = new DynamicMethod("",null, GetDelegateParameterTypes(tDelegate),typeof(MainWindow));

 

2、生成方法体

此方法加载字符串、调用带有字符串的 MessageBox.Show 方法重载、从堆栈弹出返回值（因为处理程序没有返回类型）并返回这些值。

关于动态方法生成，可以参考下面的资料：https://learn.microsoft.com/zh-cn/dotnet/fundamentals/reflection/how-to-define-and-execute-dynamic-methods

ILGenerator ilgen = handler.GetILGenerator();

Type[] showParameters = { typeof(String) };
MethodInfo simpleShow = typeof(MessageBox).GetMethod("Show", showParameters);

ilgen.Emit(OpCodes.Ldstr,
    "This event handler was constructed at run time.");
ilgen.Emit(OpCodes.Call, simpleShow);
ilgen.Emit(OpCodes.Pop);
ilgen.Emit(OpCodes.Ret);

 

3、通过调用动态方法的 CreateDelegate 方法完成该动态方法

然后再使用使用 add 访问器向事件的调用列表添加委托。

            //创建委托
            Delegate dEmitted = handler.CreateDelegate(tDelegate);


            //挂钩事件处理程序
            MethodInfo addHandler = mouseDown.GetAddMethod();
            Object[] addHandlerArgs = { dEmitted };
            addHandler.Invoke(myWindowInstance, addHandlerArgs);

 

4、测试

            //测试显示窗口
            myWindow.GetMethod("Show").Invoke(myWindowInstance, null);

 

示例代码

 

推荐阅读：

反射

https://docs.microsoft.com/zh-cn/dotnet/framework/reflection-and-codedom/reflection

动态方法

https://learn.microsoft.com/zh-cn/dotnet/fundamentals/reflection/how-to-define-and-execute-dynamic-methods