目录：
Dapper源码学习和源码修改（上篇主要讲解入参解析）
Dapper源码学习和源码修改（下篇主要讲解出参解析）
继上篇讲了下自己学习Dapper的心得之后，下篇也随之而来，上篇主要讲的入参解析那下篇自然主打出参映射了。
好了，废话不多说，开始吧。
学习之前你的先学习怎么使用Dapper，这个我在上篇都提过，如果没使用过Dapper的同学，先去看看怎么使用吧，我这也简单贴一部分代码吧。
使用查询的Demo
//查询
sql = "select * from Teacher";
var list = SqlMapper.Query<Teacher>(conn, sql, null).ToList();
sql = "select * from Teacher left join Student on Teacher.Id=Student.Tid";
//一对一
var list1 = SqlMapper.Query<Teacher, Student, Teacher>(conn, sql,
(t, s) =>
{
if (t.Student == null) t.Student = new List<Student>(); t.Student.Add(s); return t; } , null, true, null, "Id", null, null); //一对多 Dictionary<string, Teacher> list2Dict = new Dictionary<string, Teacher>();//这个才是最后的结果 var list2 = SqlMapper.Query<Teacher, Student, Teacher>(conn, sql, (t, s) => { Teacher temp; if (!list2Dict.TryGetValue(t.Id, out temp)) { temp = t; list2Dict.Add(temp.Id, temp); } if (temp.Student == null) temp.Student = new List<Student>(); temp.Student.Add(s); return temp; } , null, true, null, "Id", null, null);
好了，我也不解释，自己体会。
我们先看看Dapper提供了哪些对外的查询方法呢，既然是将出参，只有查询才会涉及到DataReader转实体的呢，所以主要就看那几个查询方法就行了。
前两个是一个实体映射的，后面三个是多个实体映射，正常情况下一个实体对应一个表，你也可以一个表对应多个实体也是可行的。
由浅入深，先看单个实体的查询。
private static IEnumerable<T> QueryInternal<T>(IDbConnection cnn, string sql, object param, IDbTransaction transaction, int? commandTimeout, CommandType? commandType)
{
var identity = new Identity(sql, commandType, cnn, typeof(T), param == null ? null : param.GetType(), null);
var info = GetCacheInfo(identity);
using (var cmd = SetupCommand(cnn, transaction, sql, info.ParamReader, param, commandTimeout, commandType))
{
using (var reader = cmd.ExecuteReader())
{
Func<Func<IDataReader, object>> cacheDeserializer = delegate() { info.Deserializer = GetDeserializer(typeof(T), reader, 0, -1, false); SetQueryCache(identity, info); return info.Deserializer; }; if (info.Deserializer == null) { cacheDeserializer(); } var deserializer = info.Deserializer; while (reader.Read()) { object next; try { next = deserializer(reader); } catch (DataException) { deserializer = cacheDeserializer(); next = deserializer(reader); } yield return (T)next; } } } }
这个就是单个实体的查询方法，用一张图片说明
很明显在读取reader的时候 next = deserializer(reader); 就是这个将reader转成实体的，那这个deserializer是什么呢，往上看啊，上面重点二字的地方就是创建deserializer 委托的地方，对了这里插一句这里委托Func（有返回值的泛型委托），之前在入参讲解的时候那里委托是Action（无返回值的泛型委托）。
也就是说deserializer就是创建委托的地方，我们去看看它的庐山真面目。
private static Func<IDataReader, object> GetDeserializer(Type type, IDataReader reader, int startBound, int length, bool returnNullIfFirstMissing)
{
Func<IDataReader, object> func = null;
if (IsSimpleValue(type))
{
func = GetSimpleDeserializer(type, startBound);
}
else if (typeof(IDictionary).IsAssignableFrom(type))
{
func = GetDictionaryDeserializer(type, startBound); } else if (type.IsClass) { func = GetClassDeserializer(type, reader, startBound, length, returnNullIfFirstMissing); } return func; }
func = GetSimpleDeserializer(type, startBound); func = GetDictionaryDeserializer(type, startBound); 这两个是我扩展的两种类型，就是为了让出参支持简单类型和继承IDictionary的类型。
而 func = GetClassDeserializer(type, reader, startBound, length, returnNullIfFirstMissing); 这个才是重点中的难点，这个就是将reader转成实体的委托。
private static Func<IDataReader, object> GetClassDeserializer(Type type, IDataReader reader, int startBound, int length, bool returnNullIfFirstMissing)
{
var dm = new DynamicMethod(string.Format("Deserialize{0}", Guid.NewGuid()), type, new[] { typeof(IDataReader) }, true);
var il = dm.GetILGenerator();
il.DeclareLocal(typeof(int));
il.DeclareLocal(type);
bool haveEnumLocal = false;
il.Emit(OpCodes.Ldc_I4_0);
il.Emit(OpCodes.Stloc_0);
List<PropertyInfo> properties = GetSettableProps(type); List<FieldInfo> fields = GetSettableFields(type); if (length == -1) { length = reader.FieldCount - startBound; } if (reader.FieldCount <= startBound) { throw new ArgumentException("When using the multi-mapping APIs ensure you set the splitOn param if you have keys other than Id", "splitOn"); } var names = new List<string>(); for (int i = startBound; i < startBound + length; i++) { names.Add(reader.GetName(i)); } var setters = new List<DynamicSetter>(); foreach (var name in names) { PropertyInfo p = FirstOrDefault(properties, new Func<PropertyInfo, bool>(delegate(PropertyInfo pro) { return Equals(pro.Name, name, StringComparison.Ordinal); })) ?? FirstOrDefault(properties, new Func<PropertyInfo, bool>(delegate(PropertyInfo pro) { return Equals(pro.Name, name, StringComparison.OrdinalIgnoreCase); })); FieldInfo f = FirstOrDefault(fields, new Func<FieldInfo, bool>(delegate(FieldInfo fin) { return Equals(fin.Name, name, StringComparison.Ordinal); })) ?? FirstOrDefault(fields, new Func<FieldInfo, bool>(delegate(FieldInfo fin) { return Equals(fin.Name, name, StringComparison.OrdinalIgnoreCase); })); setters.Add(new DynamicSetter { Name = name, Property = p, Field = f }); } int index = startBound; il.BeginExceptionBlock(); // stack is empty il.Emit(OpCodes.Newobj, type.GetConstructor(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic, null, Type.EmptyTypes, null)); // stack is now [target] bool first = true; var allDone = il.DefineLabel(); foreach (var item in setters) { if (item.Property != null || item.Field != null) { il.Emit(OpCodes.Dup); // stack is now [target][target] Label isDbNullLabel = il.DefineLabel(); Label finishLabel = il.DefineLabel(); il.Emit(OpCodes.Ldarg_0); // stack is now [target][target][reader] EmitInt32(il, index); // stack is now [target][target][reader][index] il.Emit(OpCodes.Dup);// stack is now [target][target][reader][index][index] il.Emit(OpCodes.Stloc_0);// stack is now [target][target][reader][index] il.Emit(OpCodes.Callvirt, getItem); // stack is now [target][target][value-as-object] Type memberType = item.Property != null ? item.Property.PropertyType : item.Field.FieldType; if (memberType == typeof(char) || memberType == typeof(char?)) { il.EmitCall(OpCodes.Call, typeof(SqlMapper).GetMethod( memberType == typeof(char) ? "ReadChar" : "ReadNullableChar", BindingFlags.Static | BindingFlags.Public), null); // stack is now [target][target][typed-value] } else { il.Emit(OpCodes.Dup); // stack is now [target][target][value][value] il.Emit(OpCodes.Isinst, typeof(DBNull)); // stack is now [target][target][value-as-object][DBNull or null] il.Emit(OpCodes.Brtrue_S, isDbNullLabel); // stack is now [target][target][value-as-object] // unbox nullable enums as the primitive, i.e. byte etc var nullUnderlyingType = Nullable.GetUnderlyingType(memberType); var unboxType = nullUnderlyingType != null && nullUnderlyingType.IsEnum ? nullUnderlyingType : memberType; if (unboxType.IsEnum) { if (!haveEnumLocal) { il.DeclareLocal(typeof(string)); haveEnumLocal = true; } Label isNotString = il.DefineLabel(); il.Emit(OpCodes.Dup); // stack is now [target][target][value][value] il.Emit(OpCodes.Isinst, typeof(string)); // stack is now [target][target][value-as-object][string or null] il.Emit(OpCodes.Dup);// stack is now [target][target][value-as-object][string or null][string or null] il.Emit(OpCodes.Stloc_2); // stack is now [target][target][value-as-object][string or null] il.Emit(OpCodes.Brfalse_S, isNotString); // stack is now [target][target][value-as-object] il.Emit(OpCodes.Pop); // stack is now [target][target] il.Emit(OpCodes.Ldtoken, unboxType); // stack is now [target][target][enum-type-token] il.EmitCall(OpCodes.Call, typeof(Type).GetMethod("GetTypeFromHandle"), null);// stack is now [target][target][enum-type] il.Emit(OpCodes.Ldloc_2); // stack is now [target][target][enum-type][string] il.Emit(OpCodes.Ldc_I4_1); // stack is now [target][target][enum-type][string][true] il.EmitCall(OpCodes.Call, enumParse, null); // stack is now [target][target][enum-as-object] il.Emit(OpCodes.Unbox_Any, unboxType); // stack is now [target][target][typed-value] if (nullUnderlyingType != null) { il.Emit(OpCodes.Newobj, memberType.GetConstructor(new[] { nullUnderlyingType })); } if (item.Property != null) { var setter = item.Property.DeclaringType == type ? item.Property.GetSetMethod(true) : item.Property.DeclaringType.GetProperty(item.Property.Name).GetSetMethod(true); il.Emit(OpCodes.Callvirt, setter); // stack is now [target] } else { il.Emit(OpCodes.Stfld, item.Field); // stack is now [target] } il.Emit(OpCodes.Br_S, finishLabel); il.MarkLabel(isNotString); } //if (memberType == typeof(System.Data.Linq.Binary)) //{ // il.Emit(OpCodes.Unbox_Any, typeof(byte[])); // stack is now [target][target][byte-array] // il.Emit(OpCodes.Newobj, typeof(System.Data.Linq.Binary).GetConstructor(new Type[] { typeof(byte[]) }));// stack is now [target][target][binary] //} //else //{ il.Emit(OpCodes.Unbox_Any, unboxType); // stack is now [target][target][typed-value] //} if (nullUnderlyingType != null && nullUnderlyingType.IsEnum) { il.Emit(OpCodes.Newobj, memberType.GetConstructor(new[] { nullUnderlyingType })); } } if (item.Property != null) { var setter = item.Property.DeclaringType == type ? item.Property.GetSetMethod(true) : item.Property.DeclaringType.GetProperty(item.Property.Name).GetSetMethod(true); il.Emit(OpCodes.Callvirt, setter); // stack is now [target] } else { il.Emit(OpCodes.Stfld, item.Field); // stack is now [target] } il.Emit(OpCodes.Br_S, finishLabel); // stack is now [target] il.MarkLabel(isDbNullLabel); // incoming stack: [target][target][value] il.Emit(OpCodes.Pop); // stack is now [target][target] il.Emit(OpCodes.Pop); // stack is now [target] if (first && returnNullIfFirstMissing) { il.Emit(OpCodes.Pop); il.Emit(OpCodes.Ldnull); // stack is now [null] il.Emit(OpCodes.Stloc_1); il.Emit(OpCodes.Br, allDone); } il.MarkLabel(finishLabel); } first = false; index += 1; } il.Emit(OpCodes.Stloc_1); // stack is empty il.MarkLabel(allDone); il.BeginCatchBlock(typeof(Exception)); // stack is Exception il.Emit(OpCodes.Ldloc_0); // stack is Exception, index il.Emit(OpCodes.Ldarg_0); // stack is Exception, index, reader il.EmitCall(OpCodes.Call, typeof(SqlMapper).GetMethod("ThrowDataException"), null); il.Emit(OpCodes.Ldnull); il.Emit(OpCodes.Stloc_1); // to make it verifiable il.EndExceptionBlock(); il.Emit(OpCodes.Ldloc_1); // stack is empty il.Emit(OpCodes.Ret); return (Func<IDataReader, object>)dm.CreateDelegate(typeof(Func<IDataReader, object>)); }
呵呵，我也不多说，这个就是Dapper核心价值所在，使用Emit创建实体。
上面不是说到，我也扩展出参支持两种类型嘛，使用的时候就是这样
其一：IDictionary
sql = "select * from student";// where Id='916a84c6-85cb-4b41-b52a-96a0685d91b5'";
var sex = SqlMapper.Query<Dictionary<string, object>>(conn, sql, null).ToList();
很简单的将结果转成 Dictionary ，它的委托实现如下：
private static Func<IDataReader, object> GetDictionaryDeserializer(Type type, int index)
{
return delegate(IDataReader r)
{
IDictionary ht = Activator.CreateInstance(type) as IDictionary;
for (int i = 0; i < r.FieldCount; i++)
{
ht.Add(r.GetName(i), r[i]);
}
return ht;
};
}
其二：SimpleValue
何为SimpleValue呢，看下面
private static bool IsSimpleValue(Type type)
{
if (
type.IsEnum ||
isSame(type, typeof(byte)) || isSame(type, typeof(byte?)) ||
isSame(type, typeof(sbyte)) || isSame(type, typeof(sbyte?)) ||
isSame(type, typeof(long)) || isSame(type, typeof(long?)) || isSame(type, typeof(ulong)) || isSame(type, typeof(ulong?)) || isSame(type, typeof(short)) || isSame(type, typeof(short?)) || isSame(type, typeof(ushort)) || isSame(type, typeof(ushort?)) || isSame(type, typeof(int)) || isSame(type, typeof(int?)) || isSame(type, typeof(uint)) || isSame(type, typeof(uint?)) || isSame(type, typeof(float)) || isSame(type, typeof(float?)) || isSame(type, typeof(double)) || isSame(type, typeof(double?)) || isSame(type, typeof(decimal)) || isSame(type, typeof(decimal?)) || isSame(type, typeof(char)) || isSame(type, typeof(char?)) || isSame(type, typeof(bool)) || isSame(type, typeof(bool?)) || isSame(type, typeof(DateTime)) || isSame(type, typeof(DateTime?)) || isSame(type, typeof(string)) || isSame(type, typeof(object)) ) return true; else return false; }
如果是上面的类型，我就会用下面的委托来转换reader
private static Func<IDataReader, object> GetSimpleDeserializer(Type type, int index)
{
return delegate(IDataReader r)
{
object obj = r.GetValue(index);
if (obj == null || (obj is DBNull)) return type.IsValueType ? Activator.CreateInstance(type) : null;
else
{
if (type.IsEnum) obj = Convert.ChangeType(obj, typeof(int)); else obj = Convert.ChangeType(obj, type); return obj; } }; }
后续，上面只是讲到单个实体查询的情况，至于多个实体的查询，只需理解两个参数
public static IEnumerable<TReturn> Query<TFirst, TSecond, TReturn>(IDbConnection cnn, string sql, Func<TFirst, TSecond, TReturn> map, object param, bool buffered, IDbTransaction transaction, string splitOn, int? commandTimeout, CommandType? commandType)
这两个 splitOn 和 map 如果理解了这两个参数，其他跟单个实体是一样，至于这两个参数我先不讲解，后面我会提供源码，自己看，或者以后抽空我再讲讲。
总结：
出参就讲到这吧，后续我看讲不讲Dapper扩展的，会提供源码下载，源码可能和文章会有些出入，发布文章后我修改过源码。
源码下载：
转载于:https://www.cnblogs.com/deeround/p/6633611.html