Definindo nova classe em tempo de execução, herdando de classe previamente existente.

CSharp · Console

/Program.cs

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;
    }
}
;