High Performance Reflection ORM Layer

using System;
using System.Collections.Generic;
using System.Text;
using System.Reflection;
using System.Data;

namespace ReflectionOrmLayer
{
    public delegate object ReturnObject(IDataReader dr);
    public delegate void SetValue(IDataReader dr, object obj);

    public static class Helper
    {
        private static Dictionary<string, ConstructorInfo> _constructorCache = new Dictionary<string, ConstructorInfo>();
        private static Dictionary<string, PropertyInfo[]> _propertyInfoCache = new Dictionary<string, PropertyInfo[]>();
        private static Dictionary<string, ReturnObject> _mappingCache = new Dictionary<string, ReturnObject>();

        public static ConstructorInfo GetDefaultConstructor<T>()
        {
            Type type = typeof(T);

            if (!_constructorCache.ContainsKey(type.FullName))
            {
                _constructorCache.Add(type.FullName, type.GetConstructor(Type.EmptyTypes));
            }
            return _constructorCache[type.FullName];
        }

        private static T CreateInstance<T>()
        {
            ConstructorInfo constructor = GetDefaultConstructor<T>();
            return (T)constructor.Invoke(new object[0]);
        }

        static string GetMappingSignature(IDataReader dr, Type type)
        {
            DataTable table = dr.GetSchemaTable();
            StringBuilder builder = new StringBuilder();

            foreach (DataColumn c in table.Columns)
            {
                builder.Append(c.ColumnName);
            }

            builder.Append(type.FullName);

            return builder.ToString();
        }

        private static SetValue CreateSetValueAction(PropertyInfo info, Type columnType, string columnName)
        {
            Type propType = info.PropertyType;
            SetValue setValue;
            
            if (propType.BaseType.Equals(typeof(Enum)))
            {
                setValue = delegate(IDataReader dr, object obj)
                               {
                                   if (IsNumeric(dr[columnName]))
                                       info.SetValue(obj, Enum.ToObject(propType, Convert.ToInt32(dr[columnName])), null);
                                   else
                                       info.SetValue(obj, Enum.ToObject(propType, dr[columnName]), null);
                               };
            }
            else if (propType.Equals(columnType))
            {
                setValue = delegate(IDataReader dr, object obj)
                               {
                                   info.SetValue(obj, dr[columnName], null);
                               };
            }
            else
            {
                setValue = delegate(IDataReader dr, object obj)
                               {
                                 info.SetValue(obj, Convert.ChangeType(dr[columnName], propType), null);  
                               };
            }

            return delegate(IDataReader dr, object obj)
                       {
                           if (Convert.IsDBNull(dr[columnName]))
                               info.SetValue(obj, Null.GetNull(info), null);
                           else
                               setValue(dr, obj);
                       };
        }

        public static T CreateObject<T>(IDataReader dr)
        {
            string mappingSignature = GetMappingSignature(dr, typeof(T));

            if (!_mappingCache.ContainsKey(mappingSignature))
            {
                _mappingCache.Add(mappingSignature, CreateObjectMapping<T>());
            }

            return (T)_mappingCache[mappingSignature](dr);
        }

        private static ReturnObject CreateObjectMapping<T>()
        {
            return delegate(IDataReader dr)
                       {
                           object obj = CreateInstance<T>();
                           List<SetValue> mapping = CreatePropertyMapping<T>(dr);
                           foreach (SetValue setValue in mapping)
                           {
                               setValue(dr, obj);
                           }
                           return obj;
                       };
        }

        private static List<SetValue> CreatePropertyMapping<T>(IDataRecord dr)
        {
            List<PropertyInfo> properties = GetPropertyInfo<T>();
            List<SetValue> mapping = new List<SetValue>();

            for (int i = 0; i < dr.FieldCount; i++)
            {
                string columnName = dr.GetName(i);
                PropertyInfo propMatch = properties.Find(delegate(PropertyInfo p)
                                                        {
                                                            return p.Name.ToLower() == columnName.ToLower();
                                                        });
                if (propMatch != null)
                {
                    Type columnType = dr.GetFieldType(i);
                    mapping.Add(CreateSetValueAction(propMatch, columnType, columnName));
                }
            }
            return mapping;
        }

        public static bool IsNumeric(object expression)
        {
            double retNum;

            bool isNum = Double.TryParse(Convert.ToString(expression), 
                                         System.Globalization.NumberStyles.Any,
                                         System.Globalization.NumberFormatInfo.InvariantInfo, 
                                         out retNum);
            return isNum;
        }

        public static List<PropertyInfo> GetPropertyInfo<T>()
        {
            Type type = typeof(T);

            if (!_propertyInfoCache.ContainsKey(type.FullName))
            {
                _propertyInfoCache.Add(type.FullName, type.GetProperties());
            }

            return new List<PropertyInfo>(_propertyInfoCache[type.FullName]);
        }

        public static int ExecuteNonQuery<T>(IDbCommand command, T item)
        {
            FillParameters<T>(item, command);
            return command.ExecuteNonQuery();
        }

        public static void FillParameters<T>(object obj, IDbCommand command)
        {
            List<PropertyInfo> properties = GetPropertyInfo<T>();

            foreach (IDbDataParameter dbDataParameter in command.Parameters)
            {
                //find the right property
                IDbDataParameter param = dbDataParameter;
                PropertyInfo property = properties.Find(delegate(PropertyInfo p)
                                                            {
                                                                return p.Name.ToLower() == param.SourceColumn.ToLower();
                                                            });

                object value = property.GetValue(obj, null);

                dbDataParameter.Value = Null.IsNull(value) ? DBNull.Value : value;
            }
        }
    }
}