How to use C# reflection to add methods to a class.

1 year ago
Sophia Anderson
3 minutes

To add methods to a class using C# reflection, you can follow these steps:

  1. To get the type information: first, you need to obtain the type information of the class to which the method will be added. This can be done using the Type.GetType() method or by getting the type information through an existing instance’s GetType() method.
  2. Create method information: Instantiate a new method information object using the constructor of the MethodInfo class. The method’s name, return type, and parameter list must be provided.
  3. Create dynamic methods: Use the TypeBuilder class and MethodBuilder class to create a new dynamic method. First, create a new method using the DefineMethod() method of the TypeBuilder class. Then, use the GetILGenerator() method of the MethodBuilder class to obtain the IL generator of the method, which can be used to write IL code for the method body.
  4. Write the method body: In the method body, you can use methods of IL generator to add IL instructions, in order to implement the specific logic of the method.
  5. Create a new version of the class by using the CreateType() method of the TypeBuilder class to create a new class that includes the newly added methods.

Here is an example demonstrating how to use reflection to add a method named NewMethod to the class MyClass.

using System;
using System.Reflection;
using System.Reflection.Emit;

public class MyClass
{
    public void ExistingMethod()
    {
        Console.WriteLine("Existing method.");
    }
}

public class Program
{
    public static void Main(string[] args)
    {
        Type type = typeof(MyClass);

        // 创建方法信息
        MethodInfo methodInfo = typeof(Program).GetMethod("NewMethod");

        // 创建动态方法
        TypeBuilder typeBuilder = CreateTypeBuilder();
        MethodBuilder methodBuilder = typeBuilder.DefineMethod(methodInfo.Name, MethodAttributes.Public | MethodAttributes.Static, methodInfo.ReturnType, new[] { typeof(MyClass) });

        // 编写方法体
        ILGenerator ilGenerator = methodBuilder.GetILGenerator();
        ilGenerator.EmitWriteLine("New method.");
        ilGenerator.Emit(OpCodes.Ret);

        // 创建类的新版本
        Type newType = typeBuilder.CreateType();

        // 实例化新版本的类
        object instance = Activator.CreateInstance(newType);

        // 调用新方法
        MethodInfo newMethodInfo = instance.GetType().GetMethod(methodInfo.Name);
        newMethodInfo.Invoke(null, new[] { new MyClass() });
    }

    // 创建类型生成器
    private static TypeBuilder CreateTypeBuilder()
    {
        AssemblyName assemblyName = new AssemblyName("MyAssembly");
        AssemblyBuilder assemblyBuilder = AssemblyBuilder.DefineDynamicAssembly(assemblyName, AssemblyBuilderAccess.Run);
        ModuleBuilder moduleBuilder = assemblyBuilder.DefineDynamicModule("MyModule");
        TypeBuilder typeBuilder = moduleBuilder.DefineType("MyClassNew", TypeAttributes.Public);
        typeBuilder.SetParent(typeof(MyClass));
        return typeBuilder;
    }

    public static void NewMethod(MyClass instance)
    {
        Console.WriteLine("New method.");
    }
}

In the example above, first use typeof(Program).GetMethod(“NewMethod”) to retrieve the method information for the new method. Next, create a type builder using the CreateTypeBuilder() method to generate a new version of the class. Then, use DefineMethod() to create the new method and GetILGenerator() to obtain the IL generator for the method. Within the IL generator, use Emit() to add IL instructions and complete the logic for the new method. Finally, use CreateType() to generate the new version of the class, instantiate it, and call the new method.

bannerAds