/// <summary>
        /// Gets one instance of <typeparamref name="T"/> from data reader.
        /// </summary>
        /// <typeparam name="T">Type of an instance.</typeparam>
        /// <param name="reader">Source data reader.</param>
        /// <param name="ctorParamMappings">Column constructor parameter mappings.</param>
        /// <param name="propMappings">Property column mappings.</param>
        /// <param name="breakAfterFirst">true to break after the first read record; false to not. if false throws exception if more than one record.</param>
        /// <returns>A single instance read from reader or null.</returns>
        private static T GetInstance <T>(DbDataReader reader, ColumnConstructorParameterMappingCollection <T> ctorParamMappings, IEnumerable <PropertyColumnMapping> propMappings, bool breakAfterFirst) where T : class
        {
            T instance = null;

            if (reader.HasRows)
            {
                //// create activator to create instance with constructor
                var activator = ActivatorFactory.GetActivator <T>(ctorParamMappings.Constructor);

                Dictionary <string, int> propertyColumnLookupTable = null;

                //// if contains property mappings, get lookup table
                if (propMappings != null)
                {
                    propertyColumnLookupTable = GetColumnIndexLookupTable(reader, propMappings.Select(x => x.ColumnName));
                }

                /// mappings between ctor params and columns
                var ctorColumnLookupTable = GetColumnIndexLookupTable(reader, ctorParamMappings.Select(x => x.ColumnName));

                bool first = true;

                while (reader.Read())
                {
                    if (!first)
                    {
                        throw new InvalidOperationException("Reader contains more than expected 1 record.");
                    }

                    object[] arguments = null;

                    //// get constructor arguments
                    if (ctorParamMappings.HasParameters)
                    {
                        arguments = GetConstructorParameters(reader, ctorColumnLookupTable, ctorParamMappings);
                    }

                    //// create instance
                    instance = activator.Invoke(arguments);

                    //// if contains property mappings, read values
                    if (propMappings != null)
                    {
                        ReadData(instance, reader, propMappings, propertyColumnLookupTable);
                    }

                    if (breakAfterFirst)
                    {
                        break;
                    }

                    first = false;
                }
            }

            return(instance);
        }
        /// <summary>
        /// Gets all instances from data reader.
        /// </summary>
        /// <typeparam name="T">Type of an object read.</typeparam>
        /// <param name="reader">The source <see cref="DbDataReader"/> instance.</param>
        /// <param name="ctorMappings">The mappings between constructor arguments and columns.</param>
        /// <param name="propMappings">The mappings between properties and columns.</param>
        /// <returns>A enumerable of <typeparamref name="T"/> instances.</returns>
        public static IEnumerable <T> GetRecords <T>(this DbDataReader reader, ColumnConstructorParameterMappingCollection <T> ctorMappings, IEnumerable <PropertyColumnMapping> propMappings) where T : class
        {
            if (reader == null)
            {
                throw new ArgumentNullException("reader");
            }

            if (ctorMappings == null)
            {
                throw new ArgumentNullException("ctorMappings");
            }

            var result = new List <T>();

            if (reader.HasRows)
            {
                var activator = ActivatorFactory.GetActivator <T>(ctorMappings.Constructor);

                Dictionary <string, int> propertyColumnLookupTable = null;

                //// if contains property mappings, get lookup table
                if (propMappings != null)
                {
                    propertyColumnLookupTable = GetColumnIndexLookupTable(reader, propMappings.Select(x => x.ColumnName));
                }

                /// mappings between ctor params and columns
                var ctorColumnLookupTable = GetColumnIndexLookupTable(reader, ctorMappings.Select(x => x.ColumnName));

                while (reader.Read())
                {
                    object[] arguments = null;

                    //// get constructor arguments
                    if (ctorMappings.HasParameters)
                    {
                        arguments = GetConstructorParameters(reader, ctorColumnLookupTable, ctorMappings);
                    }

                    var instance = activator.Invoke(arguments);

                    //// if contains property mappings, read values
                    if (propMappings != null)
                    {
                        ReadData(instance, reader, propMappings, propertyColumnLookupTable);
                    }

                    result.Add(instance);
                }
            }

            return(result);
        }