Dynamically creating types using reflection and setting properties using Reflection.Emit.

I came across a requirement where we needed to create types dynamically based on XML Configuration files, so that in the furture new types are required we dont need to update the application again by creating a new class.
The additional requirement was to populate the property names of the class based on the Cml configuration and its values using the Querystring values from the HttpWebRequest.
I earlier thought about using Dynamic methods from .NET Framework 2.0, but that did not fit my purpose since I didn't need to execute methods from the dynamic type that was created.

So here is the code:
I created three helper methods
1. Generates the AssemblyBuilder and Module Builder objects
2. Generates the TypeBuilder object.. which will be used for generating an instance of the dynamic type using Activator.CreateInstance
3. Create properties using Relection.Emit

   1: public class DynamicType

   2: {

   3:  

   4:     public static AssemblyBuilder asmBuilder = null;

   5:     public static ModuleBuilder modBuilder = null;

   6:     public static void GenerateAssemblyAndModule()

   7:     {

   8:         if (asmBuilder == null)

   9:         {

  10:             AssemblyName assemblyName = new AssemblyName();

  11:             assemblyName.Name = "DWBeacons";

  12:             AppDomain thisDomain = Thread.GetDomain();

  13:             asmBuilder = thisDomain.DefineDynamicAssembly(

  14:                          assemblyName, AssemblyBuilderAccess.Run);

  15:             modBuilder = asmBuilder.DefineDynamicModule(

  16:                          asmBuilder.GetName().Name, false);

  17:         }

  18:     }

  19:  

  20:     public static TypeBuilder CreateType(ModuleBuilder modBuilder, string typeName)

  21:     {

  22:         TypeBuilder typeBuilder = modBuilder.DefineType(typeName,

  23:                     TypeAttributes.Public |

  24:                     TypeAttributes.Class |

  25:                     TypeAttributes.AutoClass |

  26:                     TypeAttributes.AnsiClass |

  27:                     TypeAttributes.BeforeFieldInit |

  28:                     TypeAttributes.AutoLayout,

  29:                     typeof(object));

  30:         return typeBuilder;

  31:     }

  32:  

  33:  

  34:     public static void CreateProperty(TypeBuilder t, string name, Type typ)

  35:     {

  36:         string field = "_" + name.ToLower();

  37:         FieldBuilder fieldBldr = t.DefineField(field, typ, FieldAttributes.Private);

  38:         PropertyBuilder propBldr = t.DefineProperty(name, PropertyAttributes.HasDefault, typ, null);

  39:         MethodAttributes getSetAttr = MethodAttributes.Public | MethodAttributes.SpecialName | MethodAttributes.HideBySig;

  40:  

  41:         MethodBuilder getPropBldr = t.DefineMethod("get_" + name, getSetAttr, typ, Type.EmptyTypes);

  42:  

  43:         ILGenerator getIL = getPropBldr.GetILGenerator();

  44:         getIL.Emit(OpCodes.Ldarg_0);

  45:         getIL.Emit(OpCodes.Ldfld, fieldBldr);

  46:         getIL.Emit(OpCodes.Ret);

  47:  

  48:         MethodBuilder setPropBldr = t.DefineMethod("set_" + name, getSetAttr, null, new Type[] { typ });

  49:  

  50:         ILGenerator setIL = setPropBldr.GetILGenerator();

  51:  

  52:         setIL.Emit(OpCodes.Ldarg_0);

  53:         setIL.Emit(OpCodes.Ldarg_1);

  54:         setIL.Emit(OpCodes.Stfld, fieldBldr);

  55:         setIL.Emit(OpCodes.Ret);

  56:  

  57:         propBldr.SetGetMethod(getPropBldr);

  58:         propBldr.SetSetMethod(setPropBldr);

  59:  

  60:     }

  61:  

  62: }

Then to use these helper methods from the Main program I used the following:

   1: if (DynamicType.asmBuilder == null)

   2:     DynamicType.GenerateAssemblyAndModule();

   3: finalType = DynamicType.modBuilder.GetType("Beacon11");

   4:  

   5: TypeBuilder tb = DynamicType.CreateType(DynamicType.modBuilder, typeName);

   6:  

   7: foreach (XElement e in beaconNode.Descendants())

   8: {

   9:     string pname = e.Attribute("qs").Value;

  10:     string ptype = e.Attribute("type").Value;

  11:     DynamicType.CreateProperty(tb, pname, Type.GetType(ptype));

  12: }

  13: finalType = tb.CreateType();

  14:  

  15: Object obj = Activator.CreateInstance(finalType);

  16: // this sets the properties of the just instantiated class

  17: finalType.InvokeMember("bv", BindingFlags.SetProperty, null, data, new object[] { 1.0 });

  18: finalType.InvokeMember("tp", BindingFlags.SetProperty, null, data, new object[] { 2.0 });

  19: //this sets the properties of the type by using values from the querystring

  20: foreach (XElement e in beaconNode.Descendants())

  21: {

  22:     string pname = e.Attribute("qs").Value;

  23:     object value = context.Request.QueryString[pname];

  24:     finalType.InvokeMember(pname, BindingFlags.SetProperty, null, data, new object[] { value });

  25: }

For more information visit : msdn - PropertyBuilder