.NET内存中动态构造类并重载某函数

开发中，经常需要用到很多容器功能，而容器级别的功能大都是Reflection(类反射）所提供的，本文就是借这个名来看看如何在.NET 内存中动态构造类并重载某函数，具体的例子代码如下：

原类：TestClass

内存中动态生成类: TestClassEx

内存中动态生成类的工厂类：DynamicFactory

接口: ITest

复制以及重载的目标方法：TestMethod

调用集成采用Console方式进行，我们分别看看各个类的代码；

TestClass.cs

public class TestClass
{
private long m_lUsers = 0;
private int m_iUsers = 0;
private string m_strTest = null;
private object m_oTest = null;

public TestClass()
{
m_lUsers++;
m_iUsers++;
m_strTest = "aa";
m_oTest = new object();
}

public long Users
{
set
{
m_lUsers = value;
}
get
{
return m_lUsers;
}
}

public void TestMethod()
{
System.Console.WriteLine("TestMethod: Message output from Emit Console...");

m_lUsers = 50;
m_lUsers += 100;
System.Console.WriteLine("Users :" + Convert.ToString(m_lUsers) + " people in current context");
}

public void EndMethod()
{
System.Console.WriteLine("EndMethod:Ending message logic*****");
}

}

ITest.cs

public interface ITest
{
void TestMethod();
}

DynamicFactory.cs

public class DynamicFactory
{
private AssemblyBuilder assemblyBuilder = null;
private ModuleBuilder moduleBuilder = null;
private TypeBuilder typeBuilder = null;
private ILGenerator generator = null;

public DynamicFactory()
{
}

public Type GenerateClass(Type typeForMirror)
{
this.GenerateAssembly();

//build a type
this.typeBuilder = moduleBuilder.DefineType("TestClassEx",
TypeAttributes.Public | TypeAttributes.BeforeFieldInit,
typeForMirror, new Type[] { typeof(ITest) });

this.GenerateConstruct(typeBuilder);
this.BuildFields(typeForMirror);

this.BuildMethod(typeForMirror);

Type typeReturn = this.typeBuilder.CreateType(); //Close the type
assemblyBuilder.Save("ExtendingAssembly.dll");
return typeReturn;
}

private void BuildFields(Type typeForMirror)
{
FieldInfo[] fieldInfos = typeForMirror.GetFields(BindingFlags.NonPublic | BindingFlags.Public);
for (int i = 0; i < fieldInfos.Length; i++)
{
FieldInfo fi = fieldInfos[i];
typeBuilder.DefineField(fi.Name, fi.FieldType, fi.Attributes);
}
}

private void GenerateAssembly()
{
AppDomain currentDomain = Thread.GetDomain();
AssemblyName assemblyName = new AssemblyName();
assemblyName.Name = "Extending";
assemblyBuilder = currentDomain.DefineDynamicAssembly(assemblyName, AssemblyBuilderAccess.RunAndSave);
this.moduleBuilder = assemblyBuilder.DefineDynamicModule(
"ExtendingAssembly",
"ExtendingAssembly.dll");
}

private void GenerateConstruct(TypeBuilder typeBuilder)
{
ConstructorBuilder constructorBuilder = typeBuilder.DefineConstructor(
MethodAttributes.Public,
CallingConventions.Standard,
System.Type.EmptyTypes);

this.generator = constructorBuilder.GetILGenerator();
generator.Emit(OpCodes.Ldarg_0);
generator.Emit(OpCodes.Call, typeBuilder.BaseType.GetConstructor(System.Type.EmptyTypes));
generator.Emit(OpCodes.Ret);
}

/// <summary>
/// Attention: here we need to overload the specified TestMethod function for our EmitConsole project.
/// So the MethodAttributes.Virtual is necessary when we rebuild this function in memory.
/// </summary>
/// <param name="typeForMirror"></param>
private void BuildMethod(Type typeForMirror)
{
// Now, let's build a method and add a custom attribute to it.
MethodBuilder methodBuilder = typeBuilder.DefineMethod("TestMethod",
MethodAttributes.Public | MethodAttributes.HideBySig |
MethodAttributes.Virtual | MethodAttributes.NewSlot,
null,
new Type[] {});

this.generator = methodBuilder.GetILGenerator();

generator.Emit(OpCodes.Ldarg_0);
generator.Emit(OpCodes.Call, typeForMirror.GetMethod("TestMethod"));

generator.Emit(OpCodes.Ldarg_0);
generator.Emit(OpCodes.Call, typeForMirror.GetMethod("EndMethod"));

generator.Emit(OpCodes.Ret);
}

}

console的集成类program.cs:

class Program
{
static void Main(string[] args)
{
DynamicFactory df = new DynamicFactory();

// type for mirroring testing method
Type typeMirror = df.GenerateClass(typeof(TestClass));

object o = Activator.CreateInstance(typeMirror);
TestClass tc = (TestClass)o;
tc.TestMethod();

ITest it = (ITest)Activator.CreateInstance(typeMirror);
it.TestMethod();

System.Console.WriteLine("Ending finally...");
}
}

从最后的运行效果大家可以分析看看，采用TestClass强转后的instance与不转使用interface来直接集成的program最后的结果不一样，自己可以分析看看是啥原因产生的。

本文中未提及到的Enum, Property等的复制产生可以参照：http://www.codeproject.com/KB/cs/DLR.aspx

能够在内存中动态重组类的作用非常大，可以实现基于AOP的拦截，实现基于标注的各类应用譬如自动组装Transaction、依赖注入等众多的高级应用，对于编写框架应用作用无疑巨大。