CSharp · Console
using System;
using System.Reflection;
using System.Reflection.Emit;
public class Program
{
public static void Main()
{
DefineEmRuntimeUmaClasseHerdandoOutra();
}
public static void DefineEmRuntimeUmaClasseHerdandoOutra() {
AssemblyName aName = new AssemblyName("DynamicAssemblyExample");
AssemblyBuilder ab = AppDomain.CurrentDomain.DefineDynamicAssembly(aName, AssemblyBuilderAccess.RunAndSave);
ModuleBuilder mb = ab.DefineDynamicModule(aName.Name, aName.Name + ".dll");
// define tipo "ClasseB" herdando de "ClasseA"
Type typeClasseA = Type.GetType("ClasseA");
TypeBuilder tb = mb.DefineType("ClasseB", TypeAttributes.Public, typeClasseA);
// obtém informação de atributos da "ClasseA" que serão setados
// no novo construtor da classe filha "ClasseB"
FieldInfo codigo = typeClasseA.GetField("_codigo", BindingFlags.NonPublic | BindingFlags.Instance);
FieldInfo atributo = typeClasseA.GetField("_atributo", BindingFlags.NonPublic | BindingFlags.Instance);
// cria no tipo "ClasseB" o construtor exigido por sua classe base
Type[] parameterTypes = {typeof(int)};
ConstructorBuilder ctor1 = tb.DefineConstructor(
MethodAttributes.Public,
CallingConventions.Standard,
parameterTypes);
// adiciona no construtor instruções para setar
// o atributo "Codigo" da classe base "ClasseA"
ILGenerator ctor1IL = ctor1.GetILGenerator();
ctor1IL.Emit(OpCodes.Ldarg_0);
ctor1IL.Emit(OpCodes.Call, typeof(object).GetConstructor(Type.EmptyTypes));
ctor1IL.Emit(OpCodes.Ldarg_0);
ctor1IL.Emit(OpCodes.Ldarg_1);
ctor1IL.Emit(OpCodes.Stfld, codigo);
ctor1IL.Emit(OpCodes.Ret);
// cria no tipo "ClasseB" um novo construtor,
// que recebe dois parâmetros
Type[] parameterTypes2 = { typeof(int), typeof(string)};
ConstructorBuilder ctor2 = tb.DefineConstructor(
MethodAttributes.Public,
CallingConventions.Standard,
parameterTypes2);
// adiciona no novo construtor instruções para setar
// os atributos "Codigo" e "Atributo" da classe base "ClasseA"
ILGenerator ctor2IL = ctor2.GetILGenerator();
ctor2IL.Emit(OpCodes.Ldarg_0);
ctor2IL.Emit(OpCodes.Call, typeof(object).GetConstructor(Type.EmptyTypes));
ctor2IL.Emit(OpCodes.Ldarg_0);
ctor2IL.Emit(OpCodes.Ldarg_1);
ctor2IL.Emit(OpCodes.Stfld, codigo);
ctor2IL.Emit(OpCodes.Ldarg_0);
ctor2IL.Emit(OpCodes.Ldarg_2);
ctor2IL.Emit(OpCodes.Stfld, atributo);
ctor2IL.Emit(OpCodes.Ret);
// cria o tipo que foi definido para "ClasseB"
Type ClasseBType = tb.CreateType();
// cria uma instância da "ClasseB", que acaba de ser definida
// em runtime (herdando de "ClasseA"), invocando seu novo construtor
// de dois parâmetros.
ClasseA objClasseB = (ClasseA)System.Activator.CreateInstance(ClasseBType, 1, "Rá!");
// invoca o método da classe base "ClasseA",
// o qual teve seu resultado afetado pela classe filha "ClasseB"
Console.WriteLine(objClasseB.Concatena());
}
}
public class ClasseA
{
protected string _atributo;
protected int _codigo;
protected string Atributo
{
get {return _atributo;}
set {_atributo = value; }
}
public int Codigo
{
get {return _codigo;}
set {_codigo = value; }
}
public ClasseA (int codigo)
{
Codigo = codigo;
}
public string Concatena()
{
return this.Atributo + " - " + this.Codigo;
}
}