Quickly generate and use Dynamic Class

// Loop over the attributes that will be used as the properties names in my new type
string propertyName = null;
Type propertyType = null;
var baseClassObj = Activator.CreateInstance(baseClassType);
foreach (var word in dict)
{
propertyName = word.Key;
propertyType = word.Value;

//is it already in the base class?
var src_pi = baseClassObj.GetType().GetProperty(propertyName);
if (src_pi != null)
{
continue;
}

// Generate a private field for the property
FieldBuilder fldBldr = typeBldr.DefineField("_" + propertyName, propertyType, FieldAttributes.Private);
// Generate a public property
PropertyBuilder prptyBldr = typeBldr.DefineProperty(propertyName, PropertyAttributes.None, propertyType,
new Type[] { propertyType });

// The property set and property get methods need the following attributes:
MethodAttributes GetSetAttr = MethodAttributes.Public | MethodAttributes.HideBySig;
// Define the "get" accessor method for newly created private field.
MethodBuilder currGetPropMthdBldr = typeBldr.DefineMethod("get_value", GetSetAttr, propertyType, null);

// Intermediate Language stuff... as per MS
ILGenerator currGetIL = currGetPropMthdBldr.GetILGenerator();
currGetIL.Emit(OpCodes.Ldarg_0);
currGetIL.Emit(OpCodes.Ldfld, fldBldr);
currGetIL.Emit(OpCodes.Ret);

// Define the "set" accessor method for the newly created private field.
MethodBuilder currSetPropMthdBldr = typeBldr.DefineMethod("set_value", GetSetAttr, null, new Type[] { propertyType });

// More Intermediate Language stuff...
ILGenerator currSetIL = currSetPropMthdBldr.GetILGenerator();
currSetIL.Emit(OpCodes.Ldarg_0);
currSetIL.Emit(OpCodes.Ldarg_1);
currSetIL.Emit(OpCodes.Stfld, fldBldr);
currSetIL.Emit(OpCodes.Ret);

// Assign the two methods created above to the PropertyBuilder's Set and Get
prptyBldr.SetGetMethod(currGetPropMthdBldr);
prptyBldr.SetSetMethod(currSetPropMthdBldr);
noNewProperties = false; //I added at least one property
}
if (noNewProperties == true)
{
return baseClassType; //deliver the base class
}
// Generate (and deliver) my type
return typeBldr.CreateType();
}

The following code illustrates how to use the above method and how to use the same dictionary to populate the new type/class.

protected Dictionary ExtendedColumnsDict = null;

public void start(XElement dynamicQuery)
{
ExtendedColumnsDict = ExtractFromXelement(dynamicQuery);
}

protected override ClassicP CreateClassicP(dynamic src, Dictionary extendedColumnsDict)
{
//create the dynamic type & class based on the dictionary - hold the extended class in a variable of the base-type
ClassicP classicEx = DynamicFactory.CreateClass(GetExtendedType(extendedColumnsDict));
//fill in the base-type's properties
classicEx.Composer = src.ComposerName;
classicEx.Composition = src.CompositionName;
classicEx.Orquestra = src.Orquestra;
classicEx.Conductor = src.Conductor;
classicEx.SubCategory = src.SubCategory;
classicEx.Maker = src.Make;
classicEx.Details = src;
classicEx.Id = src.RecordingId;
classicEx.CdBoxId = src.CD_BoxId;
//fill in the dynamically created properties
SetExtendedProperties(classicEx as dynamic, src, extendedColumnsDict);
return classicEx;
}

//generic method that will extend dynamically the type T. keeping a global vraible that holds the dynamic type
//makes usre i create type only once (the class on the other hand has to be instantiated for each data-row
protected Type GetExtendedType(Dictionary extendedColumnsDict) where T : class
{
if (ExtendedType == null)
{
ExtendedType = DynamicFactory.ExtendTheType(ExtendedColumnsDict);
}
return ExtendedType;
}

//generic method that enumarets the dictionary and populate the dynamic class with values from the source
//class that contains all the 20 columns.
//there is an assumption here that the newly created properties have the same name as the original ones
//in the source class.
//the dynamic class (destination) is passed-in using the keyword dynamic in order defer the GetType()
//operation until runtime when the dynamic type is available.
protected void SetExtendedProperties(dynamic dest, T src, Dictionary extendedPropsDict)
{
foreach (var word in extendedPropsDict)
{
var src_pi = src.GetType().GetProperty(word.Key);
var dest_pi = dest.GetType().GetProperty(word.Key) as PropertyInfo;
var val = src_pi.GetValue(src, null);
//format the data based on its type
if (val is DateTime)
{
dest_pi.SetValue(dest, ((DateTime) val).ToShortDateString(), null);
}
else if (val is decimal)
{
dest_pi.SetValue(dest, ((decimal) val).ToString("C"), null);
}
else
{
dest_pi.SetValue(dest, val, null);
}
}
}

A word about the demo's source code

The Demo uses the free DataGrid from DevExpress. Microsoft's grid doesn't behave as expected with the dynamic class while Telerik and DevExpress controls handles the dynamic properties as expected.

On the other hand for some reason DevExpress control didn't respond as expected to the NotifyPropertyChanged event, therefore I needed to assign the DataContext as part of the submit button. Microsoft and Telerik controls both behaved properly to the event.