/// <summary>    /// 表示Dapper默认的类型映射策略    /// Represents default type mapping strategy used by Dapper    /// </summary>    sealed partial class DefaultTypeMap : SqlMapper.ITypeMap    {        /// <summary>        /// 要映射的实体，所有的字段        /// </summary>        private readonly List<FieldInfo> _fields;        /// <summary>        /// 要映射的实体，所有的属性        /// </summary>        private readonly List<PropertyInfo> _properties;        /// <summary>        /// 要映射的实体类型        /// </summary>        private readonly Type _type;        /// <summary>        /// 构造函数，创建缺省的类型映射策略        /// Creates default type map        /// </summary>        /// <param name="type">Entity type</param>        public DefaultTypeMap(Type type)        {            if (type == null)                throw new ArgumentNullException("type");            _fields = GetSettableFields(type);            _properties = GetSettableProps(type);            _type = type;        }        /// <summary>        /// 获取属性的setter访问器        /// </summary>        /// <param name="propertyInfo"></param>        /// <param name="type"></param>        /// <returns></returns>        internal static MethodInfo GetPropertySetter(PropertyInfo propertyInfo, Type type)        {            return propertyInfo.DeclaringType == type ?                propertyInfo.GetSetMethod(true) :                propertyInfo.DeclaringType.GetProperty(                   propertyInfo.Name,                   BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance,                   Type.DefaultBinder,                   propertyInfo.PropertyType,                   propertyInfo.GetIndexParameters().Select(p => p.ParameterType).ToArray(),                   null).GetSetMethod(true);        }        /// <summary>        /// 获取某类型所有可写（有set,包括私有）的成员属性        /// </summary>        /// <param name="t"></param>        /// <returns></returns>        internal static List<PropertyInfo> GetSettableProps(Type t)        {            return t                  .GetProperties(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance)                  .Where(p => GetPropertySetter(p, t) != null)                  .ToList();        }        /// <summary>        /// 获取某类型所有的成员字段        /// </summary>        /// <param name="t"></param>        /// <returns></returns>        internal static List<FieldInfo> GetSettableFields(Type t)        {            return t.GetFields(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance).ToList();        }        /// <summary>        /// 获取最佳的成员构造器，优先顺序：public的构造器0, 其它构造器1, private的构造器2,然后再按参数匹配        /// 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>        public ConstructorInfo FindConstructor(string[] names, Type[] types)        {            var constructors = _type.GetConstructors(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);            foreach (ConstructorInfo ctor in constructors.OrderBy(c => c.IsPublic ? 0 : (c.IsPrivate ? 2 : 1)).ThenBy(c => c.GetParameters().Length))            {                ParameterInfo[] ctorParameters = ctor.GetParameters();                if (ctorParameters.Length == 0)                    return ctor;                if (ctorParameters.Length != types.Length)                    continue;                int i = 0;                for (; i < ctorParameters.Length; i++)                {                    if (!String.Equals(ctorParameters[i].Name, names[i], StringComparison.OrdinalIgnoreCase))                        break;                    if (types[i] == typeof(byte[]) && ctorParameters[i].ParameterType.FullName == SqlMapper.LinqBinary)                        continue;                    var unboxedType = Nullable.GetUnderlyingType(ctorParameters[i].ParameterType) ?? ctorParameters[i].ParameterType;                    if (unboxedType != types[i]                        && !(unboxedType.IsEnum && Enum.GetUnderlyingType(unboxedType) == types[i])                        && !(unboxedType == typeof(char) && types[i] == typeof(string)))                        break;                }                if (i == ctorParameters.Length)                    return ctor;            }            return null;        }        /// <summary>        /// 查找带ExplicitConstructorAttribute特性标识的构造器        /// Returns the constructor, if any, that has the ExplicitConstructorAttribute on it.        /// </summary>        public ConstructorInfo FindExplicitConstructor()        {            var constructors = _type.GetConstructors(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);            var withAttr = constructors.Where(c => c.GetCustomAttributes(typeof(ExplicitConstructorAttribute), true).Length > 0).ToList();            if (withAttr.Count == 1)            {                return withAttr[0];            }            return null;        }        /// <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>        public SqlMapper.IMemberMap GetConstructorParameter(ConstructorInfo constructor, string columnName)        {            var parameters = constructor.GetParameters();            //注意构造器参数名与列名是相同的(忽略大小写)            return new SimpleMemberMap(columnName, parameters.FirstOrDefault(p => string.Equals(p.Name, columnName, StringComparison.OrdinalIgnoreCase)));        }        /// <summary>        /// 为某列找到映射关系，返回IMemberMap        /// Gets member mapping for column        /// </summary>        /// <param name="columnName">DataReader column name</param>        /// <returns>Mapping implementation</returns>        public SqlMapper.IMemberMap GetMember(string columnName)        {            //优先找与列名相同的属性名（优先找大小写相同的，再找不同的）。            var property = _properties.FirstOrDefault(p => string.Equals(p.Name, columnName, StringComparison.Ordinal))               ?? _properties.FirstOrDefault(p => string.Equals(p.Name, columnName, StringComparison.OrdinalIgnoreCase));            //如果找不到，就尝试去掉列名下划线，再找一次。            if (property == null && MatchNamesWithUnderscores)            {                property = _properties.FirstOrDefault(p => string.Equals(p.Name, columnName.Replace("_", ""), StringComparison.Ordinal))                    ?? _properties.FirstOrDefault(p => string.Equals(p.Name, columnName.Replace("_", ""), StringComparison.OrdinalIgnoreCase));            }            //如果找到就返回一个成员映射对象            if (property != null)                return new SimpleMemberMap(columnName, property);            //如果没有找到匹配的属性，就找DomainObject.Field，按照上面的套路再找一次。            var field = _fields.FirstOrDefault(p => string.Equals(p.Name, columnName, StringComparison.Ordinal))               ?? _fields.FirstOrDefault(p => string.Equals(p.Name, columnName, StringComparison.OrdinalIgnoreCase));            if (field == null && MatchNamesWithUnderscores)            {                field = _fields.FirstOrDefault(p => string.Equals(p.Name, columnName.Replace("_", ""), StringComparison.Ordinal))                    ?? _fields.FirstOrDefault(p => string.Equals(p.Name, columnName.Replace("_", ""), StringComparison.OrdinalIgnoreCase));            }            if (field != null)                return new SimpleMemberMap(columnName, field);            return null;        }        /// <summary>        /// 按列名匹配属性时，忽略下划线（有些时习惯在数据库中使用下划线）。        /// Should column names like User_Id be allowed to match properties/fields like UserId ?        /// </summary>        public static bool MatchNamesWithUnderscores { get; set; }    }