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;

    }

}