Coder Perfect

How to dynamically create a class?


This is the structure of my class:

public class Field
    public string FieldName;
    public string FieldType;

And a ListField> object with values:


I’d like to make a class that looks somewhat like this:

Class DynamicClass
    int EmployeeID,
    String EmployeeName,
    String Designation

Is there a way to make this happen?

This is something I’d want to have generated at runtime. A tangible CS file in my filesystem is not something I desire.

Asked by ashwnacharya

Solution #1

Yes, System.Reflection can be used. For this, emit a namespace. It is not simple if you have no prior expertise, but it is surely achievable.

Edit: While this code may be faulty, it will provide you with a broad notion and, perhaps, get you started on your way to achieving your objective.

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

namespace TypeBuilderNamespace
    public static class MyTypeBuilder
        public static void CreateNewObject()
            var myType = CompileResultType();
            var myObject = Activator.CreateInstance(myType);
        public static Type CompileResultType()
            TypeBuilder tb = GetTypeBuilder();
            ConstructorBuilder constructor = tb.DefineDefaultConstructor(MethodAttributes.Public | MethodAttributes.SpecialName | MethodAttributes.RTSpecialName);

            // NOTE: assuming your list contains Field objects with fields FieldName(string) and FieldType(Type)
            foreach (var field in yourListOfFields)
                CreateProperty(tb, field.FieldName, field.FieldType);

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

        private static TypeBuilder GetTypeBuilder()
            var typeSignature = "MyDynamicType";
            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 |
            return tb;

        private static 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.Ldfld, fieldBuilder);

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

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

            setIl.Emit(OpCodes.Stfld, fieldBuilder);



Answered by danijels

Solution #2

It will require some effort, but it is not insurmountable.

What I’ve done is this:

Instead of having to emit MSIL, you can interact with the C# code you already know.

However, this only works if your class implements an interface (or is derived from a baseclass); otherwise, how will the calling code (read: compiler) be aware of the class that will be generated at runtime?

Answered by Hans Kesting

Solution #3

DynamicObject can also be used to construct a class dynamically.

public class DynamicClass : DynamicObject
    private Dictionary<string, KeyValuePair<Type, object>> _fields;

    public DynamicClass(List<Field> fields)
        _fields = new Dictionary<string, KeyValuePair<Type, object>>();
        fields.ForEach(x => _fields.Add(x.FieldName,
            new KeyValuePair<Type, object>(x.FieldType, null)));

    public override bool TrySetMember(SetMemberBinder binder, object value)
        if (_fields.ContainsKey(binder.Name))
            var type = _fields[binder.Name].Key;
            if (value.GetType() == type)
                _fields[binder.Name] = new KeyValuePair<Type, object>(type, value);
                return true;
            else throw new Exception("Value " + value + " is not of type " + type.Name);
        return false;

    public override bool TryGetMember(GetMemberBinder binder, out object result)
        result = _fields[binder.Name].Value;
        return true;

I keep all of the class fields, along with their types and values, in a dictionary called _fields. Both techniques can be used to get or set values for various properties. To make an instance of this class, you must use the dynamic keyword.

In your case, here’s how to use it:

var fields = new List<Field>() { 
    new Field("EmployeeID", typeof(int)),
    new Field("EmployeeName", typeof(string)),
    new Field("Designation", typeof(string)) 

dynamic obj = new DynamicClass(fields);

obj.EmployeeID = 123456;
obj.EmployeeName = "John";
obj.Designation = "Tech Lead";

obj.Age = 25;             //Exception: DynamicClass does not contain a definition for 'Age'
obj.EmployeeName = 666;   //Exception: Value 666 is not of type String

Console.WriteLine(obj.EmployeeID);     //123456
Console.WriteLine(obj.EmployeeName);   //John
Console.WriteLine(obj.Designation);    //Tech Lead

Edit: And here’s how my class field looks:

public class Field
    public Field(string name, Type type)
        this.FieldName = name;
        this.FieldType = type;

    public string FieldName;

    public Type FieldType;

Answered by Termininja

Solution #4

I realize I’m reopening an old task, but with C# 4.0, this process is a breeze.

dynamic expando = new ExpandoObject();

//or more dynamic
AddProperty(expando, "Language", "English");

See for additional information.

Answered by user1235183

Solution #5

I’m not sure what such dynamic classes are supposed to be used for, and code generation and run-time compilation can be done, but it requires some effort. Perhaps Anonymous Types could assist you, such as:

var v = new { EmployeeID = 108, EmployeeName = "John Doe" };

Answered by Amittai Shapira

Post is based on