DataTable into List<T> *without* where T : class, new() - potential problems?

Question

Hi all,

I've been looking on SO this morning to find a way of creating a List of specific objects from a System.Data.DataTable. So far, I have this in my DomainModel base class:

    protected static List<T> ConvertTo<T>(DataTable dt) where T : class, new()
    {
        int count = dt != null ? dt.Rows.Count : 0;
        List<T> list = new List<T>(count);

        if (dt != null & dt.Rows.Count > 0)
        {
            foreach (DataRow row in dt.Rows)
            {
                T item = new T(); // ????
                FillObjectFromDataRow(item, row);
                list.Add((T)item);
            }
        }

        return list;
    }

Note: I want an empty list returned, as mostly it just gets bound to datagrids, repeaters, etc., mostly.

However, it doesn't work as the classes generally have a private constructor to prevent unauthorised instantiation (I'm mean that way), so I get the "type 'typename' must be a non-abstract type with a public parameterless constructor" error.

I am loathe to introduce a public parameterless constructor to my classes as they contain 90% of static methods (which are used with ObjectDataSources) and having an "empty" class being created would not make sense. I.e. a new Employee object would be blank instead of being created by public static Employee Get(string employeeID), which would contain far more useful information.

Any ideas on how I can create a "thing" of T at the '????' marked row without using the new() constraint? Can I instantiate a "thing" via a Type parm?

Thanks for any ideas, just trying to DRY in my apps by having this...

Kind regards,

Mike K.

PS And yes, maybe the dt.Rows.Count > 0 call is unnecessary...

Answer 1

You can use Activator.CreateInstance<T>().

The CreateInstance generic method is used by compilers to implement the instantiation of types specified by type parameters.

Answer 2

You can use either Activator.CreateInstance<T>() or invoke the constructor via typeof(T).GetConstructor(...).Invoke(new object[] { ... });

If you need alot of this operations; you can also use Expression.New to create them; as CreateInstance and via the constructor are quite expensive methods.

---

Example of doing it the Expression based way.

    private void Foo()
    {
        TestJan myObject = CreateObject<TestJan>("Jan", 21);
    }

    private T CreateObject<T>(string name, int age)
    {
        //first get a reference to the ConstructorInfo
        //we know constructor has 2 params, string and int32. Names are not important.
        System.Reflection.ConstructorInfo ci = typeof(T).GetConstructor(new[] { typeof(string), typeof(int) });

        //we now have to define the types
        ParameterExpression stringParam = Expression.Parameter(typeof(string), "stringExp");
        ParameterExpression intParam = Expression.Parameter(typeof(int), "intExp");

        //create an expression
        NewExpression constructor = Expression.New(ci, stringParam, intParam);

        //wrap this in a lambda-expression, which returns basically
        //    (stringExp, intExp) => new T(stringExp, intExp);
        LambdaExpression lambda = Expression.Lambda(constructor, stringParam, intParam);

        //compile into delegate
        var constructorDelegate = (Func<string, int, T>)lambda.Compile();

        //invoke the delegate. Normally you would cache this in a static Dictionary<Type, Delegate>.
        //when you cache this, it's lightning fast. As it's just as fast as hard program
        //    (stringExp, intExp) => new T(stringExp, intExp);
        return constructorDelegate.Invoke(name, age);
    }

You can vary of course with the parameters and such, I find this the way best way to create an object, because it's both fast and flexible.

Answer 3

As mentioned already, the Activator.CreateInstance approach should do the job - the class, new() is a convenience, and expresses what we know should be the case, of course... is there any particular reason you don't want it?

Another approach would be to pass in a factory method - this might help in particular with any DI concerns etc:

protected static List<T> ConvertTo<T>(DataTable dt, Func<T> ctor)
{
    {loop}
        T newItem = ctor();
        {fill row}
    {/loop}
}

You could then call as (for example):

List<Person> people = ConvertTo<Person>(dataTable, () => new Person());

or:

List<Person> people = ConvertTo<Person>(
     dataTable, () => diContainer.Create<Person>()); // for your DI service

Answer 4

An alternative to the reflection solution could perhaps be to use a creator lambda:

protected static List<T> ConvertTo<T>(DataTable dt, Func<DataRow, T> create) {
    int count = dt != null ? dt.Rows.Count : 0;
    List<T> list = new List<T>(count);
    if (dt != null & dt.Rows.Count > 0)
    {
        foreach (DataRow row in dt.Rows)
        {
            list.Add(create(row));
        }
    }
    return list;
}

which you then invoke like:

var result = ConvertTo(dt, row => CreateObjectFromRow(row));