c# 4.0 - Cómo crear un método en tiempo de ejecución usando Reflection.emit

c#-4.0

Question

Estoy creando un objeto en tiempo de ejecución usando reflection emit. Creé con éxito los campos, las propiedades y los métodos get set. Ahora quiero agregar un método. En aras de la simplicidad, digamos que el método simplemente devuelve un número aleatorio. ¿Cómo defino el cuerpo del método?

EDITAR:

Sí, he estado buscando en la documentación de msdn junto con otras referencias y estoy empezando a pensar en esto. Veo cómo el ejemplo anterior está agregando y / o multiplicando, pero ¿qué ocurre si mi método está haciendo otras cosas? ¿Cómo puedo definir ese "material" Supongamos que estoy generando la clase a continuación dinámicamente, ¿cómo crearía el cuerpo del método GetDetails ()?

class TestClass
{
public string Name { get; set; }
public int Size { get; set; }
public TestClass()
{
}
public TestClass(string Name, int Size)
{
this.Name = Name;
this.Size = Size;
}
public string GetDetails()
{
string Details = "Name = " + this.Name + ", Size = " + this.Size.ToString();
return Details;
}
}

Answer 1

Utiliza un MethodBuilder para definir métodos. Para definir el cuerpo del método, llame a GetILGenerator () para obtener un ILGenerator , y luego llame a los métodos Emit para emitir instrucciones IL individuales. Hay un ejemplo en la documentación de MSDN para MethodBuilder, y puede encontrar otros ejemplos de cómo usar la emisión de reflejo en la página Usar emisión de reflexión :

public static void AddMethodDynamically(TypeBuilder myTypeBld,
string mthdName,
Type[] mthdParams,
Type returnType,
string mthdAction)
{
MethodBuilder myMthdBld = myTypeBld.DefineMethod(
mthdName,
MethodAttributes.Public |
MethodAttributes.Static,
returnType,
mthdParams);
ILGenerator ILout = myMthdBld.GetILGenerator();
int numParams = mthdParams.Length;
for (byte x = 0; x < numParams; x++)
{
ILout.Emit(OpCodes.Ldarg_S, x);
}
if (numParams > 1)
{
for (int y = 0; y < (numParams - 1); y++)
{
switch (mthdAction)
{
case "A": ILout.Emit(OpCodes.Add);
break;
case "M": ILout.Emit(OpCodes.Mul);
break;
default: ILout.Emit(OpCodes.Add);
break;
}
}
}
ILout.Emit(OpCodes.Ret);
}

Parece que estás buscando recursos para escribir MSIL. Un recurso importante es la clase OpCodes , que tiene un miembro para cada instrucción IL. La documentación describe cómo funciona cada instrucción. Otro recurso importante es Ildasm o Reflector . Esto le permitirá ver el IL para el código compilado, que lo ayudará a comprender qué IL desea escribir. Ejecutando su GetDetailsMethod a través de Reflector y estableciendo el idioma en IL produce:

.method public hidebysig instance string GetDetails() cil managed
{
.maxstack 4
.locals init (
[0] string Details,
[1] string CS$1$0000,
[2] int32 CS$0$0001)
L_0000: nop
L_0001: ldstr "Name = "
L_0006: ldarg.0
L_0007: call instance string ConsoleApplication1.TestClass::get_Name()
L_000c: ldstr ", Size = "
L_0011: ldarg.0
L_0012: call instance int32 ConsoleApplication1.TestClass::get_Size()
L_0017: stloc.2
L_0018: ldloca.s CS$0$0001
L_001a: call instance string [mscorlib]System.Int32::ToString()
L_001f: call string [mscorlib]System.String::Concat(string, string, string, string)
L_0024: stloc.0
L_0025: ldloc.0
L_0026: stloc.1
L_0027: br.s L_0029
L_0029: ldloc.1
L_002a: ret
}

Para generar un método así dinámicamente, deberá llamar a ILGenerator.Emit para cada instrucción:

ilGen.Emit(OpCodes.Nop);
ilGen.Emit(OpCodes.Ldstr, "Name = ");
ilGen.Emit(OpCodes.Ldarg_0);
ilGen.Emit(OpCodes.Call, nameProperty.GetGetMethod());
// etc..

También puede buscar introducciones a MSIL, como esta: Introducción al lenguaje de ensamblado IL .