Dapper的完整扩展

真心想说：其实。。。我不想用Dapper，如果OrmLite.Net支持参数化的话，也就没Dapper的什么事情了，对于OrmLite.Net只能做后续跟踪......

这个其实是看了Dapper作者的扩展后觉得不爽，然后自己按照他的设计思路重写了代码，只支持单个数据的增删改查，根据Expression来查的真心无能为力......

另外作者似乎已经支持了属性、字段等与数据库中的映射.....

具体包含了

1、对字符串的扩展

2、对主键的定义，支持单或多主键，当单主键并且类型为数字时，认为该主键为自增列

3、对表名的定义

 

实际代码如下：

DapperExtensions部分

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

namespace Dapper
{
    /// <summary>
    /// Dapper扩展POCO信息类，为应用此扩展，在原Dapper的第1965行增加了对此类的应用
    /// </summary>
    public class DapperPocoInfo
    {
        private Type _type;
        private ConcurrentDictionary<string, KeyValuePair<DbType, int>> _stringColumns
            = new ConcurrentDictionary<string, KeyValuePair<DbType, int>>();
        private IEnumerable<PropertyInfo> _typeProperties;
        private IList<PropertyInfo> _keyProperties = new List<PropertyInfo>();
        private IEnumerable<PropertyInfo> _defaultKeyPropeties;
        private string _tableName;
        /// <summary>
        /// 对应表名
        /// </summary>
        public string TableName
        {
            get
            {
                if (string.IsNullOrWhiteSpace(this._tableName))
                {
                    this._tableName = this._type.Name;
                }
                return this._tableName;
            }
            set
            {
                this._tableName = value;
            }
        }
        /// <summary>
        /// 所有Public的属性集合
        /// </summary>
        public IEnumerable<PropertyInfo> TypeProperties
        {
            get { return this._typeProperties; }
        }
        /// <summary>
        /// 获取主键集合，如果主键数量大于1，则认为是联合主键，等于0认为不存在主键，等于1并且类型为数字型则认为自增主键
        /// </summary>
        /// <returns></returns>
        public IEnumerable<PropertyInfo> KeyProperties
        {
            get
            {
                if (this._keyProperties.Count == 0)
                {//如果未设定KeyProperties，则默认认为第一个后缀为ID的PropertyInfo为主键
                    if (this._defaultKeyPropeties == null)
                    {
                        this._defaultKeyPropeties = this._typeProperties.Where(p => p.Name.ToLower().EndsWith("id")).Take(1).ToArray();
                    }
                    return this._defaultKeyPropeties;
                }
                else
                {
                    return this._keyProperties;
                }
            }
        }
        /// <summary>
        /// .oct
        /// </summary>
        /// <param name="type"></param>
        internal DapperPocoInfo(Type type)
        {
            if (type == null)
            {
                throw new ArgumentNullException();
            }
            this._type = type;
            this._typeProperties = type.GetProperties();
        }
        /// <summary>
        /// 添加字符串参数化映射
        /// </summary>
        /// <param name="propertyName">属性名</param>
        /// <param name="dbType">必须为AnsiString、AnsiStringFixedLength、String、StringFixedLength</param>
        /// <param name="len">值范围为1~8000</param>
        public virtual void AddStringColumnMap(string propertyName, DbType dbType = DbType.AnsiString, int len = 50)
        {
            this.GetProperty(propertyName);
            if (len <= 0 || len > 8000)
            {//长度范围1~8000,此处暂时对应sql，如果其它关系型数据库长度范围与此不一致，可继承修改
                throw new ArgumentException("The param len's value must between 1 and 8000.");
            }
            if (dbType != DbType.AnsiString && dbType != DbType.AnsiStringFixedLength && dbType != DbType.String && dbType != DbType.StringFixedLength)
            {
                return;
            }
            this._stringColumns.TryAdd(propertyName, new KeyValuePair<DbType, int>(dbType, len));
        }
        /// <summary>
        /// 获取字符串映射
        /// </summary>
        /// <param name="propertyName"></param>
        /// <returns></returns>
        public KeyValuePair<DbType, int>? GetStringColumnMap(string propertyName)
        {
            KeyValuePair<DbType, int> kvp;
            if (this._stringColumns.TryGetValue(propertyName, out kvp))
            {
                return kvp;
            }
            return null;
        }
        private PropertyInfo GetProperty(string propertyName)
        {
            if (string.IsNullOrWhiteSpace(propertyName))
            {
                throw new ArgumentNullException("propertyName can not be null or empty value");
            }
            PropertyInfo pi = this._typeProperties.Where(p => p.Name.ToLower() == propertyName.ToLower()).FirstOrDefault();
            if (pi == null)
            {
                throw new ArgumentOutOfRangeException(string.Format("The class '{0}' does not contains property '{1}'.", this._type.FullName, propertyName));
            }
            return pi;
        }
        /// <summary>
        /// 添加主键映射
        /// </summary>
        /// <param name="propertyName"></param>
        public void AddKeyMap(string propertyName)
        {
            var pi = this.GetProperty(propertyName);
            if (this._keyProperties.Where(p => p.Name == pi.Name).FirstOrDefault() == null)
            {
                this._keyProperties.Add(pi);
                this._unWriteKey = null;//赋值时取消已经确认的是否可写键值
            }
        }
        /// <summary>
        /// 不需要插入数据的主键类型，除了Guid，其它均认为自增
        /// </summary>
        private static Type[] UnWriteTypes = { typeof(int), typeof(short), typeof(long), typeof(byte), typeof(Guid) };
        private bool? _unWriteKey;
        /// <summary>
        /// 主键是否可写
        /// </summary>
        /// <returns></returns>
        public bool IsUnWriteKey()
        {
            if (!this._unWriteKey.HasValue)
            {
                this._unWriteKey = false;
                IList<PropertyInfo> keys = this.KeyProperties.ToList();
                if (keys.Count == 1)
                {
                    this._unWriteKey = UnWriteTypes.Contains(keys[0].PropertyType);
                }
            }
            return this._unWriteKey.Value;
        }
    }
    /// <summary>
    /// Dapper扩展类
    /// </summary>
    public static class DapperExtensions
    {
        private static ConcurrentDictionary<RuntimeTypeHandle, DapperPocoInfo> PocoInfos
            = new ConcurrentDictionary<RuntimeTypeHandle, DapperPocoInfo>();
        /// <summary>
        /// 已实现的ISqlAdapter集合
        /// </summary>
        private static readonly Dictionary<string, ISqlAdapter> AdapterDictionary
            = new Dictionary<string, ISqlAdapter>() {
            {"sqlconnection", new MsSqlServerAdapter()}
            };

        public static DapperPocoInfo GetPocoInfo<T>()
            where T : class
        {
            return GetPocoInfo(typeof(T));
        }
        public static DapperPocoInfo GetPocoInfo(this Type type)
        {
            DapperPocoInfo pi;
            RuntimeTypeHandle hd = type.TypeHandle;
            if (!PocoInfos.TryGetValue(hd, out pi))
            {
                pi = new DapperPocoInfo(type);
                PocoInfos[hd] = pi;
            }
            return pi;
        }

        public static ISqlAdapter GetSqlAdapter(this IDbConnection connection)
        {
            string name = connection.GetType().Name.ToLower();
            ISqlAdapter adapter;
            if (!AdapterDictionary.TryGetValue(name, out adapter))
            {
                throw new NotImplementedException(string.Format("Unknow sql connection '{0}'", name));
            }
            return adapter;
        }

        /// <summary>
        /// 新增数据，如果T只有一个主键，且新增的主键为数字，则会将新增的主键赋值给entity相应的字段，如果为多主键，或主键不是数字和Guid,则主键需输入
        /// 如果要进行匿名类型新增，因为匿名类型无法赋值，需调用ISqlAdapter的Insert，由数据库新增的主键需自己写方法查询
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="connection"></param>
        /// <param name="entity"></param>
        /// <param name="transaction"></param>
        /// <param name="commandTimeout"></param>
        /// <returns></returns>
        public static bool Insert<T>(this IDbConnection connection, T entity, IDbTransaction transaction = null, int? commandTimeout = null)
            where T : class
        {
            ISqlAdapter adapter = GetSqlAdapter(connection);
            return adapter.Insert<T>(connection, entity, transaction, commandTimeout);
        }
        /// <summary>
        /// 更新数据，如果entity为T,则全字段更新，如果为匿名类型，则修改包含的字段，但匿名类型必须包含主键对应的字段
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="connection"></param>
        /// <param name="entity"></param>
        /// <param name="transaction"></param>
        /// <param name="commandTimeout"></param>
        /// <returns></returns>
        public static bool Update<T>(this IDbConnection connection, object entity, IDbTransaction transaction = null, int? commandTimeout = null)
            where T : class
        {
            ISqlAdapter adapter = GetSqlAdapter(connection);
            return adapter.UpdateByKey<T>(connection, entity, transaction, commandTimeout);
        }
        /// <summary>
        /// 删除数据，支持匿名，但匿名类型必须包含主键对应的字段
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="connection"></param>
        /// <param name="param"></param>
        /// <param name="transaction"></param>
        /// <param name="commandTimeout"></param>
        /// <returns></returns>
        public static bool DeleteByKey<T>(this IDbConnection connection, object param, IDbTransaction transaction = null, int? commandTimeout = null)
            where T : class
        {
            ISqlAdapter adapter = GetSqlAdapter(connection);
            return adapter.DeleteByKey<T>(connection, param, transaction, commandTimeout);
        }
        /// <summary>
        /// 查询数据，支持匿名，但匿名类型必须包含主键对应的字段
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="connection"></param>
        /// <param name="param"></param>
        /// <param name="transaction"></param>
        /// <param name="commandTimeout"></param>
        /// <returns></returns>
        public static T QueryByKey<T>(this IDbConnection connection, object param, IDbTransaction transaction = null, int? commandTimeout = null)
            where T : class
        {
            ISqlAdapter adapter = GetSqlAdapter(connection);
            return adapter.QueryByKey<T>(connection, param, transaction, commandTimeout);
        }
        /// <summary>
        /// 获取最后新增的ID值，仅对Indentity有效
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="connection"></param>
        /// <returns></returns>
        public static long GetLastInsertIndentityID<T>(this IDbConnection connection)
            where T : class
        {
            ISqlAdapter adapter = GetSqlAdapter(connection);
            return adapter.GetLastInsertID<T>(connection);
        }
    }

    public interface ISqlAdapter
    {
        string GetFullQueryByKeySql(Type type);
        string GetFullInsertSql(Type type);
        string GetFullUpdateByKeySql(Type type);
        string GetDeleteByKeySql(Type type);
        bool Insert<T>(IDbConnection connection, object entity, IDbTransaction transaction, int? commandTimeout)
            where T : class;
        bool UpdateByKey<T>(IDbConnection connection, object entity, IDbTransaction transaction, int? commandTimeout)
            where T : class;
        bool DeleteByKey<T>(IDbConnection connection, object param, IDbTransaction transaction, int? commandTimeout)
            where T : class;
        T QueryByKey<T>(IDbConnection connection, object param, IDbTransaction transaction, int? commandTimeout)
            where T : class;
        long GetLastInsertID<T>(IDbConnection connection)
            where T : class;
    }

    internal class BasicSql
    {
        public string FullQueryByKeySql { get; set; }
        public string FullInsertSql { get; set; }
        public string FullUpdateByKeySql { get; set; }
        public string DeleteByKeySql { get; set; }
    }

    public class MsSqlServerAdapter : ISqlAdapter
    {
        private static ConcurrentDictionary<RuntimeTypeHandle, BasicSql> BasicSqls
            = new ConcurrentDictionary<RuntimeTypeHandle, BasicSql>();
        private static readonly char SqlParameterChar = '@';

        internal MsSqlServerAdapter() { }

        private string GetParameterName(PropertyInfo pi)
        {
            return string.Format("{0}{1}", SqlParameterChar, pi.Name);
        }
        private BasicSql GetBasicSql(Type type)
        {
            BasicSql basicSql;
            RuntimeTypeHandle hd = type.TypeHandle;
            if (!BasicSqls.TryGetValue(hd, out basicSql))
            {
                basicSql = new BasicSql();
                BasicSqls[hd] = basicSql;
            }
            return basicSql;
        }
        private void AppendKeyParameter(StringBuilder tmp, IEnumerable<PropertyInfo> keys)
        {
            if (keys.Any())
            {
                tmp.AppendLine(" WHERE");
                foreach (PropertyInfo key in keys)
                {
                    tmp.Append(key.Name);
                    tmp.Append("=");
                    tmp.Append(this.GetParameterName(key));
                    tmp.Append(" AND ");
                }
                tmp.Remove(tmp.Length - 5, 5);
            }
        }
        public string GetFullQueryByKeySql(Type type)
        {
            BasicSql basicSql = this.GetBasicSql(type);
            if (string.IsNullOrEmpty(basicSql.FullQueryByKeySql))
            {
                DapperPocoInfo dpi = type.GetPocoInfo();
                StringBuilder tmp = new StringBuilder();
                tmp.Append("SELECT * FROM ");
                tmp.Append(dpi.TableName);
                tmp.Append(" (NOLOCK) ");
                this.AppendKeyParameter(tmp, dpi.KeyProperties);
                basicSql.FullQueryByKeySql = tmp.ToString();
            }
            return basicSql.FullQueryByKeySql;
        }

        public string GetFullInsertSql(Type type)
        {
            BasicSql basicSql = this.GetBasicSql(type);
            if (string.IsNullOrEmpty(basicSql.FullInsertSql))
            {
                DapperPocoInfo dpi = type.GetPocoInfo();
                basicSql.FullInsertSql = this.GetInsertSql(dpi, dpi.TypeProperties);
            }
            return basicSql.FullInsertSql;
        }

        private string GetInsertSql(DapperPocoInfo dpi, IEnumerable<PropertyInfo> props)
        {
            StringBuilder tmp = new StringBuilder();
            tmp.Append("INSERT INTO ");
            tmp.AppendLine(dpi.TableName);
            tmp.Append('(');

            IEnumerable<PropertyInfo> valueProps = props;
            if (dpi.IsUnWriteKey())
            {
                valueProps = this.GetExceptProps(props, dpi.KeyProperties);
            }

            this.AppendColumnList(tmp, valueProps, '\0');
            tmp.Append(')');
            tmp.AppendLine(" VALUES ");
            tmp.Append('(');
            this.AppendColumnList(tmp, valueProps, SqlParameterChar);
            tmp.Append(')');

            return tmp.ToString();
        }
        private void AppendColumnList(StringBuilder tmp, IEnumerable<PropertyInfo> valueProps, char addChar)
        {
            foreach (PropertyInfo p in valueProps)
            {
                tmp.Append(addChar);
                tmp.Append(p.Name);
                tmp.Append(',');
            }
            tmp.Remove(tmp.Length - 1, 1);
        }
        private IEnumerable<PropertyInfo> GetExceptProps(IEnumerable<PropertyInfo> props1, IEnumerable<PropertyInfo> props2)
        {
            //return props1.Except(props2, new EqualityCompareProperty()).ToArray();
            IList<PropertyInfo> list = new List<PropertyInfo>();
            foreach (PropertyInfo pi in props1)
            {
                string name = pi.Name.ToLower();
                if (!props2.Any(p => p.Name.ToLower() == name))
                {
                    list.Add(pi);
                }
            }
            return list;
        }
        private string GetUpdateSql(DapperPocoInfo dpi, IEnumerable<PropertyInfo> props)
        {
            StringBuilder tmp = new StringBuilder();
            tmp.Append("UPDATE ");
            tmp.AppendLine(dpi.TableName);
            tmp.Append("SET ");
            IEnumerable<PropertyInfo> valueProps = this.GetExceptProps(props, dpi.KeyProperties);
            foreach (PropertyInfo p in valueProps)
            {
                tmp.Append(p.Name);
                tmp.Append('=');
                tmp.Append(SqlParameterChar);
                tmp.Append(p.Name);
                tmp.Append(',');
            }
            tmp.Remove(tmp.Length - 1, 1);
            tmp.AppendLine();
            this.AppendKeyParameter(tmp, dpi.KeyProperties);
            return tmp.ToString();
        }

        public string GetFullUpdateByKeySql(Type type)
        {
            BasicSql basicSql = this.GetBasicSql(type);
            if (string.IsNullOrEmpty(basicSql.FullUpdateByKeySql))
            {
                DapperPocoInfo dpi = type.GetPocoInfo();
                basicSql.FullUpdateByKeySql = this.GetUpdateSql(dpi, dpi.TypeProperties);
            }
            return basicSql.FullUpdateByKeySql;
        }

        public string GetDeleteByKeySql(Type type)
        {
            BasicSql basicSql = this.GetBasicSql(type);
            if (string.IsNullOrEmpty(basicSql.DeleteByKeySql))
            {
                DapperPocoInfo dpi = type.GetPocoInfo();
                StringBuilder tmp = new StringBuilder();
                tmp.Append("DELETE FROM ");
                tmp.AppendLine(dpi.TableName);
                this.AppendKeyParameter(tmp, dpi.KeyProperties);
                basicSql.DeleteByKeySql = tmp.ToString();
            }
            return basicSql.DeleteByKeySql;
        }

        public bool Insert<T>(IDbConnection connection, object entity, IDbTransaction transaction = null, int? commandTimeout = null) where T : class
        {
            Type type = typeof(T);
            string insertSql;
            Type entityType = entity.GetType();
            DapperPocoInfo dpi = type.GetPocoInfo();
            if (entityType.IsAssignableFrom(type))
            {
                insertSql = this.GetFullInsertSql(type);
            }
            else
            {
                insertSql = this.GetInsertSql(dpi, entityType.GetProperties());
            }

            if (connection.Execute<T>(insertSql, entity, transaction, commandTimeout) > 0)
            {
                if (entityType.IsAssignableFrom(type) && dpi.IsUnWriteKey())
                {
                    PropertyInfo key = dpi.KeyProperties.First();
                    if (key.PropertyType != typeof(Guid))
                    {
                        var idValue = this.GetLastInsertID(connection, dpi, transaction, commandTimeout);
                        key.SetValue(entity, idValue, null);
                    }
                }
                return true;
            }
            return false;
        }

        public bool UpdateByKey<T>(IDbConnection connection, object entity, IDbTransaction transaction = null, int? commandTimeout = null) where T : class
        {
            Type type = typeof(T);
            string updateSql;
            Type entityType = entity.GetType();
            DapperPocoInfo dpi = type.GetPocoInfo();
            if (entityType.IsAssignableFrom(type))
            {
                updateSql = this.GetFullUpdateByKeySql(type);
            }
            else
            {
                updateSql = this.GetUpdateSql(dpi, entityType.GetProperties());
            }
            return connection.Execute<T>(updateSql, entity, transaction, commandTimeout) > 0;
        }

        public bool DeleteByKey<T>(IDbConnection connection, object param, IDbTransaction transaction = null, int? commandTimeout = null) where T : class
        {
            string deleteSql = this.GetDeleteByKeySql(typeof(T));
            return connection.Execute<T>(deleteSql, param, transaction: transaction, commandTimeout: commandTimeout) > 0;
        }

        public T QueryByKey<T>(IDbConnection connection, object param, IDbTransaction transaction = null, int? commandTimeout = null) where T : class
        {
            string querySql = this.GetFullQueryByKeySql(typeof(T));
            return connection.Query<T>(querySql, param, transaction: transaction, commandTimeout: commandTimeout).FirstOrDefault();
        }

        private object GetLastInsertID(IDbConnection connection, DapperPocoInfo dpi, IDbTransaction transaction = null, int? commandTimeout = null)
        {
            var r = connection.Query("SELECT IDENT_CURRENT('" + dpi.TableName + "') ID", transaction: transaction, commandTimeout: commandTimeout);
            return Convert.ChangeType(r.First().ID, dpi.KeyProperties.First().PropertyType);
        }

        public long GetLastInsertID<T>(IDbConnection connection)
            where T : class
        {
            DapperPocoInfo dpi = typeof(T).GetPocoInfo();
            return Convert.ToInt64(this.GetLastInsertID(connection, dpi));
        }
    }
}

 

原Dapper部分，在1965行开始做了些修改：

/*
 License: http://www.apache.org/licenses/LICENSE-2.0
 Home page: http://code.google.com/p/dapper-dot-net/

 Note: to build on C# 3.0 + .NET 3.5, include the CSHARP30 compiler symbol (and yes,
 I know the difference between language and runtime versions; this is a compromise).
 */

using System;
using System.Collections;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Linq;
using System.Reflection;
using System.Reflection.Emit;
using System.Text;
using System.Threading;
using System.Text.RegularExpressions;
using System.Diagnostics;


namespace Dapper
{
    /// <summary>
    /// Dapper, a light weight object mapper for ADO.NET
    /// </summary>
    static partial class SqlMapper
    {
        /// <summary>
        /// Implement this interface to pass an arbitrary db specific set of parameters to Dapper
        /// </summary>
        public partial interface IDynamicParameters
        {
            /// <summary>
            /// Add all the parameters needed to the command just before it executes
            /// </summary>
            /// <param name="command">The raw command prior to execution</param>
            /// <param name="identity">Information about the query</param>
            void AddParameters(IDbCommand command, Identity identity);
        }

        /// <summary>
        /// Implement this interface to pass an arbitrary db specific parameter to Dapper
        /// </summary>
        public interface ICustomQueryParameter
        {
            /// <summary>
            /// Add the parameter needed to the command before it executes
            /// </summary>
            /// <param name="command">The raw command prior to execution</param>
            /// <param name="name">Parameter name</param>
            void AddParameter(IDbCommand command, string name);
        }

        /// <summary>
        /// Implement this interface to change default mapping of reader columns to type memebers
        /// </summary>
        public interface ITypeMap
        {
            /// <summary>
            /// Finds best constructor
            /// </summary>
            /// <param name="names">DataReader column names</param>
            /// <param name="types">DataReader column types</param>
            /// <returns>Matching constructor or default one</returns>
            ConstructorInfo FindConstructor(string[] names, Type[] types);

            /// <summary>
            /// Gets mapping for constructor parameter
            /// </summary>
            /// <param name="constructor">Constructor to resolve</param>
            /// <param name="columnName">DataReader column name</param>
            /// <returns>Mapping implementation</returns>
            IMemberMap GetConstructorParameter(ConstructorInfo constructor, string columnName);

            /// <summary>
            /// Gets member mapping for column
            /// </summary>
            /// <param name="columnName">DataReader column name</param>
            /// <returns>Mapping implementation</returns>
            IMemberMap GetMember(string columnName);
        }

        /// <summary>
        /// Implements this interface to provide custom member mapping
        /// </summary>
        public interface IMemberMap
        {
            /// <summary>
            /// Source DataReader column name
            /// </summary>
            string ColumnName { get; }

            /// <summary>
            ///  Target member type
            /// </summary>
            Type MemberType { get; }

            /// <summary>
            /// Target property
            /// </summary>
            PropertyInfo Property { get; }

            /// <summary>
            /// Target field
            /// </summary>
            FieldInfo Field { get; }

            /// <summary>
            /// Target constructor parameter
            /// </summary>
            ParameterInfo Parameter { get; }
        }

        static Link<Type, Action<IDbCommand, bool>> bindByNameCache;
        static Action<IDbCommand, bool> GetBindByName(Type commandType)
        {
            if (commandType == null) return null; // GIGO
            Action<IDbCommand, bool> action;
            if (Link<Type, Action<IDbCommand, bool>>.TryGet(bindByNameCache, commandType, out action))
            {
                return action;
            }
            var prop = commandType.GetProperty("BindByName", BindingFlags.Public | BindingFlags.Instance);
            action = null;
            ParameterInfo[] indexers;
            MethodInfo setter;
            if (prop != null && prop.CanWrite && prop.PropertyType == typeof(bool)
                && ((indexers = prop.GetIndexParameters()) == null || indexers.Length == 0)
                && (setter = prop.GetSetMethod()) != null
                )
            {
                var method = new DynamicMethod(commandType.Name + "_BindByName", null, new Type[] { typeof(IDbCommand), typeof(bool) });
                var il = method.GetILGenerator();
                il.Emit(OpCodes.Ldarg_0);
                il.Emit(OpCodes.Castclass, commandType);
                il.Emit(OpCodes.Ldarg_1);
                il.EmitCall(OpCodes.Callvirt, setter, null);
                il.Emit(OpCodes.Ret);
                action = (Action<IDbCommand, bool>)method.CreateDelegate(typeof(Action<IDbCommand, bool>));
            }
            // cache it
            Link<Type, Action<IDbCommand, bool>>.TryAdd(ref bindByNameCache, commandType, ref action);
            return action;
        }
        /// <summary>
        /// This is a micro-cache; suitable when the number of terms is controllable (a few hundred, for example),
        /// and strictly append-only; you cannot change existing values. All key matches are on **REFERENCE**
        /// equality. The type is fully thread-safe.
        /// </summary>
        partial class Link<TKey, TValue> where TKey : class
        {
            public static bool TryGet(Link<TKey, TValue> link, TKey key, out TValue value)
            {
                while (link != null)
                {
                    if ((object)key == (object)link.Key)
                    {
                        value = link.Value;
                        return true;
                    }
                    link = link.Tail;
                }
                value = default(TValue);
                return false;
            }
            public static bool TryAdd(ref Link<TKey, TValue> head, TKey key, ref TValue value)
            {
                bool tryAgain;
                do
                {
                    var snapshot = Interlocked.CompareExchange(ref head, null, null);
                    TValue found;
                    if (TryGet(snapshot, key, out found))
                    { // existing match; report the existing value instead
                        value = found;
                        return false;
                    }
                    var newNode = new Link<TKey, TValue>(key, value, snapshot);
                    // did somebody move our cheese?
                    tryAgain = Interlocked.CompareExchange(ref head, newNode, snapshot) != snapshot;
                } while (tryAgain);
                return true;
            }
            private Link(TKey key, TValue value, Link<TKey, TValue> tail)
            {
                Key = key;
                Value = value;
                Tail = tail;
            }
            public TKey Key { get; private set; }
            public TValue Value { get; private set; }
            public Link<TKey, TValue> Tail { get; private set; }
        }
        partial class CacheInfo
        {
            public DeserializerState Deserializer { get; set; }
            public Func<IDataReader, object>[] OtherDeserializers { get; set; }
            public Action<IDbCommand, object> ParamReader { get; set; }
            private int hitCount;
            public int GetHitCount() { return Interlocked.CompareExchange(ref hitCount, 0, 0); }
            public void RecordHit() { Interlocked.Increment(ref hitCount); }
        }
        static int GetColumnHash(IDataReader reader)
        {
            unchecked
            {
                int colCount = reader.FieldCount, hash = colCount;
                for (int i = 0; i < colCount; i++)
                {   // binding code is only interested in names - not types
                    object tmp = reader.GetName(i);
                    hash = (hash * 31) + (tmp == null ? 0 : tmp.GetHashCode());
                }
                return hash;
            }
        }
        struct DeserializerState
        {
            public readonly int Hash;
            public readonly Func<IDataReader, object> Func;

            public DeserializerState(int hash, Func<IDataReader, object> func)
            {
                Hash = hash;
                Func = func;
            }
        }

        /// <summary>
        /// Called if the query cache is purged via PurgeQueryCache
        /// </summary>
        public static event EventHandler QueryCachePurged;
        private static void OnQueryCachePurged()
        {
            var handler = QueryCachePurged;
            if (handler != null) handler(null, EventArgs.Empty);
        }
#if CSHARP30
        private static readonly Dictionary<Identity, CacheInfo> _queryCache = new Dictionary<Identity, CacheInfo>();
        // note: conflicts between readers and writers are so short-lived that it isn't worth the overhead of
        // ReaderWriterLockSlim etc; a simple lock is faster
        private static void SetQueryCache(Identity key, CacheInfo value)
        {
            lock (_queryCache) { _queryCache[key] = value; }
        }
        private static bool TryGetQueryCache(Identity key, out CacheInfo value)
        {
            lock (_queryCache) { return _queryCache.TryGetValue(key, out value); }
        }
        private static void PurgeQueryCacheByType(Type type)
        {
            lock (_queryCache)
            {
                var toRemove = _queryCache.Keys.Where(id => id.type == type).ToArray();
                foreach (var key in toRemove)
                    _queryCache.Remove(key);
            }
        }
        /// <summary>
        /// Purge the query cache
        /// </summary>
        public static void PurgeQueryCache()
        {
            lock (_queryCache)
            {
                _queryCache.Clear();
            }
            OnQueryCachePurged();
        }
#else
        static readonly System.Collections.Concurrent.ConcurrentDictionary<Identity, CacheInfo> _queryCache = new System.Collections.Concurrent.ConcurrentDictionary<Identity, CacheInfo>();
        private static void SetQueryCache(Identity key, CacheInfo value)
        {
            if (Interlocked.Increment(ref collect) == COLLECT_PER_ITEMS)
            {
                CollectCacheGarbage();
            }
            _queryCache[key] = value;
        }

        private static void CollectCacheGarbage()
        {
            try
            {
                foreach (var pair in _queryCache)
                {
                    if (pair.Value.GetHitCount() <= COLLECT_HIT_COUNT_MIN)
                    {
                        CacheInfo cache;
                        _queryCache.TryRemove(pair.Key, out cache);
                    }
                }
            }

            finally
            {
                Interlocked.Exchange(ref collect, 0);
            }
        }

        private const int COLLECT_PER_ITEMS = 1000, COLLECT_HIT_COUNT_MIN = 0;
        private static int collect;
        private static bool TryGetQueryCache(Identity key, out CacheInfo value)
        {
            if (_queryCache.TryGetValue(key, out value))
            {
                value.RecordHit();
                return true;
            }
            value = null;
            return false;
        }

        /// <summary>
        /// Purge the query cache
        /// </summary>
        public static void PurgeQueryCache()
        {
            _queryCache.Clear();
            OnQueryCachePurged();
        }

        private static void PurgeQueryCacheByType(Type type)
        {
            foreach (var entry in _queryCache)
            {
                CacheInfo cache;
                if (entry.Key.type == type)
                    _queryCache.TryRemove(entry.Key, out cache);
            }
        }

        /// <summary>
        /// Return a count of all the cached queries by dapper
        /// </summary>
        /// <returns></returns>
        public static int GetCachedSQLCount()
        {
            return _queryCache.Count;
        }

        /// <summary>
        /// Return a list of all the queries cached by dapper
        /// </summary>
        /// <param name="ignoreHitCountAbove"></param>
        /// <returns></returns>
        public static IEnumerable<Tuple<string, string, int>> GetCachedSQL(int ignoreHitCountAbove = int.MaxValue)
        {
            var data = _queryCache.Select(pair => Tuple.Create(pair.Key.connectionString, pair.Key.sql, pair.Value.GetHitCount()));
            if (ignoreHitCountAbove < int.MaxValue) data = data.Where(tuple => tuple.Item3 <= ignoreHitCountAbove);
            return data;
        }

        /// <summary>
        /// Deep diagnostics only: find any hash collisions in the cache
        /// </summary>
        /// <returns></returns>
        public static IEnumerable<Tuple<int, int>> GetHashCollissions()
        {
            var counts = new Dictionary<int, int>();
            foreach (var key in _queryCache.Keys)
            {
                int count;
                if (!counts.TryGetValue(key.hashCode, out count))
                {
                    counts.Add(key.hashCode, 1);
                }
                else
                {
                    counts[key.hashCode] = count + 1;
                }
            }
            return from pair in counts
                   where pair.Value > 1
                   select Tuple.Create(pair.Key, pair.Value);

        }
#endif


        static readonly Dictionary<Type, DbType> typeMap;

        static SqlMapper()
        {
            typeMap = new Dictionary<Type, DbType>();
            typeMap[typeof(byte)] = DbType.Byte;
            typeMap[typeof(sbyte)] = DbType.SByte;
            typeMap[typeof(short)] = DbType.Int16;
            typeMap[typeof(ushort)] = DbType.UInt16;
            typeMap[typeof(int)] = DbType.Int32;
            typeMap[typeof(uint)] = DbType.UInt32;
            typeMap[typeof(long)] = DbType.Int64;
            typeMap[typeof(ulong)] = DbType.UInt64;
            typeMap[typeof(float)] = DbType.Single;
            typeMap[typeof(double)] = DbType.Double;
            typeMap[typeof(decimal)] = DbType.Decimal;
            typeMap[typeof(bool)] = DbType.Boolean;
            typeMap[typeof(string)] = DbType.String;
            typeMap[typeof(char)] = DbType.StringFixedLength;
            typeMap[typeof(Guid)] = DbType.Guid;
            typeMap[typeof(DateTime)] = DbType.DateTime;
            typeMap[typeof(DateTimeOffset)] = DbType.DateTimeOffset;
            typeMap[typeof(TimeSpan)] = DbType.Time;
            typeMap[typeof(byte[])] = DbType.Binary;
            typeMap[typeof(byte?)] = DbType.Byte;
            typeMap[typeof(sbyte?)] = DbType.SByte;
            typeMap[typeof(short?)] = DbType.Int16;
            typeMap[typeof(ushort?)] = DbType.UInt16;
            typeMap[typeof(int?)] = DbType.Int32;
            typeMap[typeof(uint?)] = DbType.UInt32;
            typeMap[typeof(long?)] = DbType.Int64;
            typeMap[typeof(ulong?)] = DbType.UInt64;
            typeMap[typeof(float?)] = DbType.Single;
            typeMap[typeof(double?)] = DbType.Double;
            typeMap[typeof(decimal?)] = DbType.Decimal;
            typeMap[typeof(bool?)] = DbType.Boolean;
            typeMap[typeof(char?)] = DbType.StringFixedLength;
            typeMap[typeof(Guid?)] = DbType.Guid;
            typeMap[typeof(DateTime?)] = DbType.DateTime;
            typeMap[typeof(DateTimeOffset?)] = DbType.DateTimeOffset;
            typeMap[typeof(TimeSpan?)] = DbType.Time;
            typeMap[typeof(Object)] = DbType.Object;
        }
        /// <summary>
        /// Configire the specified type to be mapped to a given db-type
        /// </summary>
        public static void AddTypeMap(Type type, DbType dbType)
        {
            typeMap[type] = dbType;
        }

        internal const string LinqBinary = "System.Data.Linq.Binary";
        internal static DbType LookupDbType(Type type, string name)
        {
            DbType dbType;
            var nullUnderlyingType = Nullable.GetUnderlyingType(type);
            if (nullUnderlyingType != null) type = nullUnderlyingType;
            if (type.IsEnum && !typeMap.ContainsKey(type))
            {
                type = Enum.GetUnderlyingType(type);
            }
            if (typeMap.TryGetValue(type, out dbType))
            {
                return dbType;
            }
            if (type.FullName == LinqBinary)
            {
                return DbType.Binary;
            }
            if (typeof(IEnumerable).IsAssignableFrom(type))
            {
                return DynamicParameters.EnumerableMultiParameter;
            }


            throw new NotSupportedException(string.Format("The member {0} of type {1} cannot be used as a parameter value", name, type));
        }


        /// <summary>
        /// Identity of a cached query in Dapper, used for extensability
        /// </summary>
        public partial class Identity : IEquatable<Identity>
        {
            internal Identity ForGrid(Type primaryType, int gridIndex)
            {
                return new Identity(sql, commandType, connectionString, primaryType, parametersType, null, gridIndex);
            }

            internal Identity ForGrid(Type primaryType, Type[] otherTypes, int gridIndex)
            {
                return new Identity(sql, commandType, connectionString, primaryType, parametersType, otherTypes, gridIndex);
            }
            /// <summary>
            /// Create an identity for use with DynamicParameters, internal use only
            /// </summary>
            /// <param name="type"></param>
            /// <returns></returns>
            public Identity ForDynamicParameters(Type type)
            {
                return new Identity(sql, commandType, connectionString, this.type, type, null, -1);
            }

            internal Identity(string sql, CommandType? commandType, IDbConnection connection, Type type, Type parametersType, Type[] otherTypes)
                : this(sql, commandType, connection.ConnectionString, type, parametersType, otherTypes, 0)
            { }
            private Identity(string sql, CommandType? commandType, string connectionString, Type type, Type parametersType, Type[] otherTypes, int gridIndex)
            {
                this.sql = sql;
                this.commandType = commandType;
                this.connectionString = connectionString;
                this.type = type;
                this.parametersType = parametersType;
                this.gridIndex = gridIndex;
                unchecked
                {
                    hashCode = 17; // we *know* we are using this in a dictionary, so pre-compute this
                    hashCode = hashCode * 23 + commandType.GetHashCode();
                    hashCode = hashCode * 23 + gridIndex.GetHashCode();
                    hashCode = hashCode * 23 + (sql == null ? 0 : sql.GetHashCode());
                    hashCode = hashCode * 23 + (type == null ? 0 : type.GetHashCode());
                    if (otherTypes != null)
                    {
                        foreach (var t in otherTypes)
                        {
                            hashCode = hashCode * 23 + (t == null ? 0 : t.GetHashCode());
                        }
                    }
                    hashCode = hashCode * 23 + (connectionString == null ? 0 : SqlMapper.connectionStringComparer.GetHashCode(connectionString));
                    hashCode = hashCode * 23 + (parametersType == null ? 0 : parametersType.GetHashCode());
                }
            }

            /// <summary>
            ///
            /// </summary>
            /// <param name="obj"></param>
            /// <returns></returns>
            public override bool Equals(object obj)
            {
                return Equals(obj as Identity);
            }
            /// <summary>
            /// The sql
            /// </summary>
            public readonly string sql;
            /// <summary>
            /// The command type
            /// </summary>
            public readonly CommandType? commandType;

            /// <summary>
            ///
            /// </summary>
            public readonly int hashCode, gridIndex;
            /// <summary>
            ///
            /// </summary>
            public readonly Type type;
            /// <summary>
            ///
            /// </summary>
            public readonly string connectionString;
            /// <summary>
            ///
            /// </summary>
            public readonly Type parametersType;
            /// <summary>
            ///
            /// </summary>
            /// <returns></returns>
            public override int GetHashCode()
            {
                return hashCode;
            }
            /// <summary>
            /// Compare 2 Identity objects
            /// </summary>
            /// <param name="other"></param>
            /// <returns></returns>
            public bool Equals(Identity other)
            {
                return
                    other != null &&
                    gridIndex == other.gridIndex &&
                    type == other.type &&
                    sql == other.sql &&
                    commandType == other.commandType &&
                    SqlMapper.connectionStringComparer.Equals(connectionString, other.connectionString) &&
                    parametersType == other.parametersType;
            }
        }

#if CSHARP30
        /// <summary>
        /// Execute parameterized SQL
        /// </summary>
        /// <returns>Number of rows affected</returns>
        public static int Execute(this IDbConnection cnn, string sql, object param)
        {
            return Execute(cnn, sql, param, null, null, null);
        }

        /// <summary>
        /// Execute parameterized SQL
        /// </summary>
        /// <returns>Number of rows affected</returns>
        public static int Execute(this IDbConnection cnn, string sql, object param, IDbTransaction transaction)
        {
            return Execute(cnn, sql, param, transaction, null, null);
        }

        /// <summary>
        /// Execute parameterized SQL
        /// </summary>
        /// <returns>Number of rows affected</returns>
        public static int Execute(this IDbConnection cnn, string sql, object param, CommandType commandType)
        {
            return Execute(cnn, sql, param, null, null, commandType);
        }

        /// <summary>
        /// Execute parameterized SQL
        /// </summary>
        /// <returns>Number of rows affected</returns>
        public static int Execute(this IDbConnection cnn, string sql, object param, IDbTransaction transaction, CommandType commandType)
        {
            return Execute(cnn, sql, param, transaction, null, commandType);
        }

        /// <summary>
        /// Executes a query, returning the data typed as per T
        /// </summary>
        /// <returns>A sequence of data of the supplied type; if a basic type (int, string, etc) is queried then the data from the first column in assumed, otherwise an instance is
        /// created per row, and a direct column-name===member-name mapping is assumed (case insensitive).
        /// </returns>
        public static IEnumerable<T> Query<T>(this IDbConnection cnn, string sql, object param)
        {
            return Query<T>(cnn, sql, param, null, true, null, null);
        }

        /// <summary>
        /// Executes a query, returning the data typed as per T
        /// </summary>
        /// <returns>A sequence of data of the supplied type; if a basic type (int, string, etc) is queried then the data from the first column in assumed, otherwise an instance is
        /// created per row, and a direct column-name===member-name mapping is assumed (case insensitive).
        /// </returns>
        public static IEnumerable<T> Query<T>(this IDbConnection cnn, string sql, object param, IDbTransaction transaction)
        {
            return Query<T>(cnn, sql, param, transaction, true, null, null);
        }

        /// <summary>
        /// Executes a query, returning the data typed as per T
        /// </summary>
        /// <returns>A sequence of data of the supplied type; if a basic type (int, string, etc) is queried then the data from the first column in assumed, otherwise an instance is
        /// created per row, and a direct column-name===member-name mapping is assumed (case insensitive).
        /// </returns>
        public static IEnumerable<T> Query<T>(this IDbConnection cnn, string sql, object param, CommandType commandType)
        {
            return Query<T>(cnn, sql, param, null, true, null, commandType);
        }

        /// <summary>
        /// Executes a query, returning the data typed as per T
        /// </summary>
        /// <returns>A sequence of data of the supplied type; if a basic type (int, string, etc) is queried then the data from the first column in assumed, otherwise an instance is
        /// created per row, and a direct column-name===member-name mapping is assumed (case insensitive).
        /// </returns>
        public static IEnumerable<T> Query<T>(this IDbConnection cnn, string sql, object param, IDbTransaction transaction, CommandType commandType)
        {
            return Query<T>(cnn, sql, param, transaction, true, null, commandType);
        }

        /// <summary>
        /// Execute a command that returns multiple result sets, and access each in turn
        /// </summary>
        public static GridReader QueryMultiple(this IDbConnection cnn, string sql, object param, IDbTransaction transaction)
        {
            return QueryMultiple(cnn, sql, param, transaction, null, null);
        }

        /// <summary>
        /// Execute a command that returns multiple result sets, and access each in turn
        /// </summary>
        public static GridReader QueryMultiple(this IDbConnection cnn, string sql, object param, CommandType commandType)
        {
            return QueryMultiple(cnn, sql, param, null, null, commandType);
        }

        /// <summary>
        /// Execute a command that returns multiple result sets, and access each in turn
        /// </summary>
        public static GridReader QueryMultiple(this IDbConnection cnn, string sql, object param, IDbTransaction transaction, CommandType commandType)
        {
            return QueryMultiple(cnn, sql, param, transaction, null, commandType);
        }
#endif

        private static int Execute(
#if CSHARP30
this IDbConnection cnn, string sql,Type type, object param, IDbTransaction transaction, int? commandTimeout, CommandType? commandType
#else
this IDbConnection cnn, string sql, Type type, dynamic param = null, IDbTransaction transaction = null, int? commandTimeout = null, CommandType? commandType = null
#endif
)
        {
            IEnumerable multiExec = (object)param as IEnumerable;
            Identity identity;
            CacheInfo info = null;
            if (multiExec != null && !(multiExec is string))
            {
                bool isFirst = true;
                int total = 0;
                using (var cmd = SetupCommand(cnn, transaction, sql, null, null, commandTimeout, commandType))
                {

                    string masterSql = null;
                    foreach (var obj in multiExec)
                    {
                        if (isFirst)
                        {
                            masterSql = cmd.CommandText;
                            isFirst = false;
                            identity = new Identity(sql, cmd.CommandType, cnn, type, obj.GetType(), null);
                            info = GetCacheInfo(identity);
                        }
                        else
                        {
                            cmd.CommandText = masterSql; // because we do magic replaces on "in" etc
                            cmd.Parameters.Clear(); // current code is Add-tastic
                        }
                        info.ParamReader(cmd, obj);
                        total += cmd.ExecuteNonQuery();
                    }
                }
                return total;
            }

            // nice and simple
            if ((object)param != null)
            {
                identity = new Identity(sql, commandType, cnn, type, (object)param == null ? null : ((object)param).GetType(), null);
                info = GetCacheInfo(identity);
            }
            return ExecuteCommand(cnn, transaction, sql, (object)param == null ? null : info.ParamReader, (object)param, commandTimeout, commandType);
        }

        /// <summary>
        /// Execute parameterized SQL
        /// </summary>
        /// <returns>Number of rows affected</returns>
        public static int Execute<T>(
#if CSHARP30
this IDbConnection cnn, string sql, object param, IDbTransaction transaction, int? commandTimeout, CommandType? commandType
#else
this IDbConnection cnn, string sql, dynamic param = null, IDbTransaction transaction = null, int? commandTimeout = null, CommandType? commandType = null
#endif
)
            where T : class
        {
            return Execute(cnn, sql, typeof(T), param, transaction, commandTimeout, commandType);
        }
        /// <summary>
        /// Execute parameterized SQL
        /// </summary>
        /// <returns>Number of rows affected</returns>
        public static int Execute(
#if CSHARP30
this IDbConnection cnn, string sql, object param, IDbTransaction transaction, int? commandTimeout, CommandType? commandType
#else
this IDbConnection cnn, string sql, dynamic param = null, IDbTransaction transaction = null, int? commandTimeout = null, CommandType? commandType = null
#endif
)
        {
            return Execute(cnn, sql, null, param, transaction, commandTimeout, commandType);
        }

#if !CSHARP30
        /// <summary>
        /// Return a list of dynamic objects, reader is closed after the call
        /// </summary>
        public static IEnumerable<dynamic> Query(this IDbConnection cnn, string sql, dynamic param = null, IDbTransaction transaction = null, bool buffered = true, int? commandTimeout = null, CommandType? commandType = null)
        {
            return Query<DapperRow>(cnn, sql, param as object, transaction, buffered, commandTimeout, commandType);
        }
#else
        /// <summary>
        /// Return a list of dynamic objects, reader is closed after the call
        /// </summary>
        public static IEnumerable<IDictionary<string, object>> Query(this IDbConnection cnn, string sql, object param)
        {
            return Query(cnn, sql, param, null, true, null, null);
        }

        /// <summary>
        /// Return a list of dynamic objects, reader is closed after the call