Question

This is a custom ORM thing we’re working on. It’s not awesome, but it’s what we’ve decided on doing.

Basically the base class Entity is extended by any number of other classes. These child classes must be annotated using attributes.

There is one particular type of attribute which is a collection. The attribute defines the sub-type of the collection.

eg.

public class Blah2 : Entity
{
    ...
}

public class Blah : Entity 
{
    [QRel(Type = typeof(Blah2)]
    public IEnumerable<Blah2> blahs;
}

Loading these child objects is easily done, but they are loaded as the base type, Entity.

Via reflection, so at run time I have, in the ORM manager:

• The type marked in the attribute: Type t
• The field info of blahs: FieldInfo f
• The entity instance of type Blah: i
• A generic loaded list containing a set of Blah2 instances: List<Entity> l

I need to create a list lt using the derived type t (i.e. dynamically create and fill a List<Blah2>) and assign it to the field of type Blah:

var lt = ...
f.SetValue(i, lt);

Notice that because this is all done via reflection the types of the objects I have are: t -> Type, i -> Entity, f -> FieldInfo, l -> List<Entity>.

Answer 1

I would suggest that you create a helper class, Helper<T> which does the allocation of the properly typed generic list, and fills the list with the items. You could cache an instance of the helper class in order to reduce the cost of reflection.

abstract class Helper
{
    public abstract IEnumerable<Entity> CreateList(IEnumerable<Entity> loadedList);
}

sealed class Helper<T> : Helper where T : Entity
{
    public override IEnumerable<Entity> CreateList(IEnumerable<Entity> loadedList)
    {
        return new List<T> (loadedList.OfType<T> ());
    }
}

To create an instance of the Helper<T>, just do this:

var helperType = typeof (Helper<>).MakeGenericType (t);
var helper = Activator.CreateInstance (helperType) as Helper;

and then to allocate and fill the list of Blah2 based on the generic list:

var lt = helper.CreateList (l);