Create a class dynamically in C#

Question

I have a class "Classea" and this has an attribute "Attribute" protected.

public class ClasseA
{
    protected string Atributo { get; set; }
    public int Codigo { get; set; }
    public ClasseA (int codigo)
    {
        Codigo = codigo;
    }
    public string Concatena()
    {
        return this.Atributo + " - " + this.Codigo;
    }

}

I would like to create classes in Runtime that inherit this class "A" and that they populate the attribute 'Attribute'.

Answer 1

The code below defines in Runtime a ClasseB you inherit from your ClasseA, where I added private fields to use in the properties instead of leaving it to the compiler.

The approach I used to ClasseB seven the property Atributo of ClasseA added a new constructor to it (in Classeb), with a more.

Tested and working: https://dotnetfiddle.net/y6M72F

using System;
using System.Reflection;
using System.Reflection.Emit;
                
public class Program
{
    public static void Main()
    {
        CriaClasseHerdandoOutra();
    }
    public static void CriaClasseHerdandoOutra() {

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

Reference: documentation of the Assemblybuilder.

The key in this example are the classes TypeBuilder, for the definition of a type in Runtime, and the ILGenerator, to add instructions to the body of defined methods.

There are other ways to achieve similar results. Namely - Codedom and Roslyn, released in April this year (an example).

Considerations about my code

It is clear that this code is for educational purposes only and needs to be much more readable if used. It is also possible to generalize this code and abstract it to a nicer API that meets a specific need.

Besides, I imagine you’d wear Attributes do . Net’s to identify which properties to change instead of doing so based on the name.

A typical example of using this type of engineering (creating class inheritance at project runtime or build time) is in frameworks that do not want to force the user to inherit their classes but need to add resources to the user objects (ORMs, for example).

Answer 2

First implement a special class to build other classes. The following code does this:

using System;
using System.Reflection;
using System.Reflection.Emit;

namespace TypeBuilderNamespace
{
    public class ObjectBuilder
    {
        public object MyObject { get; set; }
        // Key seria o nome da propriedade, e Value o tipo dela.
        public Dictionary<string, string> Fields { get; set; }

        public void CreateNewObject()
        {
            var myType = CompileResultType();
            MyObject = Activator.CreateInstance(myType);
        }

        public Type CompileResultType()
        {
            TypeBuilder tb = GetTypeBuilder();
            ConstructorBuilder constructor = tb.DefineDefaultConstructor(MethodAttributes.Public | MethodAttributes.SpecialName | MethodAttributes.RTSpecialName);

            foreach (var field in Fields)
                CreateProperty(tb, field.Key, field.Value);

            Type objectType = tb.CreateType();
            return objectType;
        }

        private TypeBuilder GetTypeBuilder()
        {
            var typeSignature = "DerivadaDeClasseA";
            var an = new AssemblyName(typeSignature);
            AssemblyBuilder assemblyBuilder = AppDomain.CurrentDomain.DefineDynamicAssembly(an, AssemblyBuilderAccess.Run);
            ModuleBuilder moduleBuilder = assemblyBuilder.DefineDynamicModule("MainModule");
            TypeBuilder tb = moduleBuilder.DefineType(typeSignature
                                , TypeAttributes.Public |
                                TypeAttributes.Class |
                                TypeAttributes.AutoClass |
                                TypeAttributes.AnsiClass |
                                TypeAttributes.BeforeFieldInit |
                                TypeAttributes.AutoLayout
                                , null);
            return tb;
        }

        private void CreateProperty(TypeBuilder tb, string propertyName, Type propertyType)
        {
            FieldBuilder fieldBuilder = tb.DefineField("_" + propertyName, propertyType, FieldAttributes.Private);

            PropertyBuilder propertyBuilder = tb.DefineProperty(propertyName, PropertyAttributes.HasDefault, propertyType, null);
            MethodBuilder getPropMthdBldr = tb.DefineMethod("get_" + propertyName, MethodAttributes.Public | MethodAttributes.SpecialName | MethodAttributes.HideBySig, propertyType, Type.EmptyTypes);
            ILGenerator getIl = getPropMthdBldr.GetILGenerator();

            getIl.Emit(OpCodes.Ldarg_0);
            getIl.Emit(OpCodes.Ldfld, fieldBuilder);
            getIl.Emit(OpCodes.Ret);

            MethodBuilder setPropMthdBldr =
                tb.DefineMethod("set_" + propertyName,
                  MethodAttributes.Public |
                  MethodAttributes.SpecialName |
                  MethodAttributes.HideBySig,
                  null, new[] { propertyType });

            ILGenerator setIl = setPropMthdBldr.GetILGenerator();
            Label modifyProperty = setIl.DefineLabel();
            Label exitSet = setIl.DefineLabel();

            setIl.MarkLabel(modifyProperty);
            setIl.Emit(OpCodes.Ldarg_0);
            setIl.Emit(OpCodes.Ldarg_1);
            setIl.Emit(OpCodes.Stfld, fieldBuilder);

            setIl.Emit(OpCodes.Nop);
            setIl.MarkLabel(exitSet);
            setIl.Emit(OpCodes.Ret);

            propertyBuilder.SetGetMethod(getPropMthdBldr);
            propertyBuilder.SetSetMethod(setPropMthdBldr);
        }
    }
}

Use:

var dicionario = new Dictionary<string, object>();
dicionario.Add("Atributo", typeof(String));

var objectBuilder = new ObjectBuilder {
    Fields = dicionario 
};

objectBuilder.CreateNewObject();
var objetoCriado = objectBuilder.MyObject;

PS: I have not tested this code, and some adjustments may be necessary, but it is a starting point.

Answer 3

use the dynamic teste = new ExpandoObject(); is much easier ;)