Dapper.net 在Parameterized时对于String的扩展(转)

虽然Dapper通过提供的DbString本身支持对于String的指定Parameterized，但这方法明显不够，当Insert时，我们更希望是把一个Poco直接传递过去，而不是来new一个匿名函数，对于string类型的属性，转化成DbString，然后一个一个的属性再写一遍，这多苦逼

通过代码，可以看到有这么一段方法

public static Action<IDbCommand, object> CreateParamInfoGenerator(Identity identity, bool checkForDuplicates, bool removeUnused)

这段代码就是用来构建Param参数的，内部通过Emit来实现，在里面可以找到遍历属性的代码，其内部有一些判断，这些就是可以直接增加代码来控制生成何种Param的地方，具体是两个地方

if (dbType != DbType.Time)
{
il.Emit(OpCodes.Dup);// stack is now [parameters] [[parameters]] [parameter] [parameter]
EmitInt32(il, (int)dbType);// stack is now [parameters] [[parameters]] [parameter] [parameter] [db-type]
il.EmitCall(OpCodes.Callvirt, typeof(IDataParameter).GetProperty("DbType").GetSetMethod(), null);// stack is now [parameters] [[parameters]] [parameter]
}

if (prop.PropertyType == typeof(string))
{
il.Emit(OpCodes.Dup); // [string] [string]
il.EmitCall(OpCodes.Callvirt, typeof(string).GetProperty("Length").GetGetMethod(), null); // [string] [length]
EmitInt32(il, 4000); // [string] [length] [4000]
il.Emit(OpCodes.Cgt); // [string] [0 or 1]
Label isLong = il.DefineLabel(), lenDone = il.DefineLabel();
il.Emit(OpCodes.Brtrue_S, isLong);
EmitInt32(il, 4000); // [string] [4000]
il.Emit(OpCodes.Br_S, lenDone);
il.MarkLabel(isLong);
EmitInt32(il, -1); // [string] [-1]
il.MarkLabel(lenDone);
il.Emit(OpCodes.Stloc_1); // [string]
}

我们只要修改第一段代码部分的

EmitInt32(il, (int)dbType);

通过修改(int)dbType来控制AnsiString、AnsiStringFixedLength、String、StringFixedLength

通过修改第二段代码部分的两个4000来控制字符串Param长度（其实修改第二个4000就能达到目标，但为啥还要第一个，整段Emit代码又是什么意思。。。完全没看懂！！）

具体怎么改呢

1、可以通过Attribute，这个方法比较简单，但坏处就是相当于破坏了Dapper不需要修改原代码的事实，如果Orm每次通过工具生成一次，就要修改一次Poco，当然你也可以修改Orm的生成工具，为属性加上相应的Length限制，好处就是可以直接应用Dapper自己提供的SqlMapperExtensions，而且相对一致，都是通过Attribute进行控制

2、通过Mapping，这个就是要额外增加控制的类，下面是一个简单的类

public class DapperStringParameterized
{
private Dictionary<string, KeyValuePair<DbType, int>> _dic = new Dictionary<string, KeyValuePair<DbType, int>>();
/// <summary>
/// 添加字符串参数化映射
/// </summary>
/// <param name="name">属性名</param>
/// <param name="type">必须为AnsiString、AnsiStringFixedLength、String、StringFixedLength</param>
/// <param name="len">必须为1~8000</param>
public virtual void Add(string name, DbType type = DbType.AnsiString, int len = 50)
{
if (len <= 0 || len > 8000)
{//长度范围1~8000,此处暂时对应sql，如果其它关系型数据库长度范围与此不一致，可继承修改
throw new ArgumentException("The param len's value must between 1 and 8000.");
}
if (type != DbType.AnsiString && type != DbType.AnsiStringFixedLength && type != DbType.String && type != DbType.StringFixedLength)
{
return;
}
if (!string.IsNullOrEmpty(name))
{
if (this._dic.ContainsKey(name))
{
throw new ArgumentException(string.Format("The param name '{0}' has aready existed!", name));
}
else
{
this._dic.Add(name, new KeyValuePair<DbType, int>(type, len));
}
}
}
public void Remove(string name)
{
if (!string.IsNullOrWhiteSpace(name))
{
if (this._dic.ContainsKey(name))
{
this._dic.Remove(name);
}
}
}
public KeyValuePair<DbType, int>? GetParameterizedData(string name)
{
if (!string.IsNullOrWhiteSpace(name) && this._dic.ContainsKey(name))
{
return this._dic[name];
}
return null;
}
}

public class DapperStringParameterizedManager
{
private static readonly DapperStringParameterizedManager manager = new DapperStringParameterizedManager();
private static Dictionary<Type, DapperStringParameterized> dic = new Dictionary<Type, DapperStringParameterized>();
private static object locObj = new object();
private DapperStringParameterizedManager() { }

public static DapperStringParameterizedManager Instance
{
get { return manager; }
}
/// <summary>
/// 添加映射关系
/// </summary>
/// <returns></returns>
public void AddMapping<T>(DapperStringParameterized mapping)
where T : class
{
if (mapping != null)
{
lock (locObj)
{
DapperStringParameterized tmpmapping = this.GetMapping(typeof(T));
if (tmpmapping == null)
{
dic.Add(typeof(T), mapping);
}
else
{
throw new ArgumentException(string.Format("The POCO Mapping {0} has aready existed!", typeof(T)));
}
}
}
}

public DapperStringParameterized GetMapping(Type type)
{
if (type != null && dic.ContainsKey(type))
{
return dic[type];
}
return null;
}
}

使用时就是在CreateParamInfoGenerator方法中，foreach (var prop in props)之前添加代码

DapperStringParameterized dsp = DapperStringParameterizedManager.Instance.GetMapping(identity.type);

在获取DbType的地方增加代码

DbType dbType = LookupDbType(prop.PropertyType, prop.Name);
KeyValuePair<DbType, int>? kvp = null;
if (dbType == DbType.String && dsp != null)//默认所有字符串在Dapper中被param成 DbType.String
{
kvp = dsp.GetParameterizedData(prop.Name);
}

第一段代码部分修改为

if (dbType != DbType.Time) // https://connect.microsoft.com/VisualStudio/feedback/details/381934/sqlparameter-dbtype-dbtype-time-sets-the-parameter-to-sqldbtype-datetime-instead-of-sqldbtype-time {
//string parameter extensions  对于字符串参数化的扩展
int dbTypeValue = (int)dbType;
if (kvp.HasValue)
{
dbTypeValue = (int)kvp.Value.Key;
}

il.Emit(OpCodes.Dup);// stack is now [parameters] [[parameters]] [parameter] [parameter]
EmitInt32(il, dbTypeValue);// stack is now [parameters] [[parameters]] [parameter] [parameter] [db-type]

il.EmitCall(OpCodes.Callvirt, typeof(IDataParameter).GetProperty("DbType").GetSetMethod(), null);// stack is now [parameters] [[parameters]] [parameter]
}

因为我们设定了字符串允许的最大长度，所以第二部分判断大小的代码直接注销，然后将下面另一段判断string的代码

if (prop.PropertyType == typeof(string))
{
var endOfSize = il.DefineLabel();
// don't set if 0
il.Emit(OpCodes.Ldloc_1); // [parameters] [[parameters]] [parameter] [size]
il.Emit(OpCodes.Brfalse_S, endOfSize); // [parameters] [[parameters]] [parameter]

il.Emit(OpCodes.Dup);// stack is now [parameters] [[parameters]] [parameter] [parameter]
il.Emit(OpCodes.Ldloc_1); // stack is now [parameters] [[parameters]] [parameter] [parameter] [size]
il.EmitCall(OpCodes.Callvirt, typeof(IDbDataParameter).GetProperty("Size").GetSetMethod(), null); // stack is now [parameters] [[parameters]] [parameter]

il.MarkLabel(endOfSize);
}

修改为

if (prop.PropertyType == typeof(string) && kvp.HasValue)
{
il.Emit(OpCodes.Dup);
EmitInt32(il, kvp.Value.Value);
il.EmitCall(OpCodes.Callvirt, typeof(IDbDataParameter).GetProperty("Size").GetSetMethod(), null); // stack is now [parameters] [[parameters]] [parameter]
}

这样如果有设定字符串长度，则此部分代码会进行size设定，否则不设定

实际用的地方只要在static构造函数中添加相应的初始化设定就可以了，建议将此部分代码写在相应的Repository部分，如果是三层则写在DAL部分，比如

static _Default()
{
DapperStringParameterized dsp = new DapperStringParameterized();

DapperStringParameterizedManager manager = DapperStringParameterizedManager.Instance;
manager.AddMapping<Customer>(dsp);

dsp.Add("UserName", DbType.String, 20);
dsp.Add("Contact", DbType.String, 25);
}

好吧。。这样子做了之后只针对Query<T>起了作用，对于Execute没起作用，因为这个方法没指定类型T，在创建Identity时它直接将Type设为了null，那就添加ExecuteQ<T>方法，因为指定了T，所以将Execute的代码复制一份，然后将new Identity的地方将cnn后面的第一个null改为typeof(T)就可以了