protected virtual T ExecuteScalar <T>(DbCommand cmd)
{
QueryTimes++;
WriteSQL(cmd);
try
{
BeginTrace();
Object rs = cmd.ExecuteScalar();
if (rs == null || rs == DBNull.Value)
{
return(default(T));
}
if (rs is T)
{
return((T)rs);
}
return((T)Reflect.ChangeType(rs, typeof(T)));
}
catch (DbException ex)
{
throw OnException(ex, cmd.CommandText);
}
finally
{
EndTrace(cmd.CommandText);
AutoClose();
cmd.Parameters.Clear();
}
}
public virtual async Task <T> ExecuteScalarAsync <T>(DbCommand cmd)
{
QueryTimes++;
WriteSQL(cmd);
try
{
BeginTrace();
var rs = await cmd.ExecuteScalarAsync();
if (rs == null || rs == DBNull.Value)
{
return(default(T));
}
if (rs is T)
{
return((T)rs);
}
return((T)Reflect.ChangeType(rs, typeof(T)));
}
catch (DbException ex)
{
throw OnException(ex, cmd);
}
finally
{
EndTrace(cmd);
}
}
/// <summary>取得指定键的强类型值</summary>
/// <typeparam name="T"></typeparam>
/// <param name="key"></param>
/// <returns></returns>
public T GetItem<T>(String key)
{
if (!Contain(key)) return default(T);
var value = this[key];
if (String.IsNullOrEmpty(value)) return default(T);
var t = typeof(T);
if (t.IsValueType || Type.GetTypeCode(t) == TypeCode.String || t == typeof(Object))
{
return (T)Reflect.ChangeType(value, t);
}
else if (t.IsArray || value is IEnumerable)
{
var data = FromXml(value);
if (data == null) throw new XException("ExtendData无法分析数据" + value);
var list = new List<String>();
for (var i = 1; i < Int32.MaxValue; i++)
{
if (!data.Contain("Item" + i.ToString())) break;
list.Add(data["Item" + i.ToString()]);
}
return (T)Reflect.ChangeType(list.ToArray(), t);
}
throw new XException("不支持的类型{0}，键{1}", typeof(T), key);
}
/// <summary>尝试从指定数据行中读取指定名称列的数据</summary>
/// <typeparam name="T"></typeparam>
/// <param name="dr"></param>
/// <param name="name">名称</param>
/// <param name="value">数值</param>
/// <returns></returns>
protected static Boolean TryGetDataRowValue <T>(DataRow dr, String name, out T value)
{
value = default(T);
if (dr == null || !dr.Table.Columns.Contains(name) || dr.IsNull(name))
{
return(false);
}
Object obj = dr[name];
// 特殊处理布尔类型
if (Type.GetTypeCode(typeof(T)) == TypeCode.Boolean && obj != null)
{
if (obj is Boolean)
{
value = (T)obj;
return(true);
}
if ("YES".EqualIgnoreCase(obj.ToString()))
{
value = (T)(Object)true;
return(true);
}
if ("NO".EqualIgnoreCase(obj.ToString()))
{
value = (T)(Object)false;
return(true);
}
}
try
{
if (obj is T)
{
value = (T)obj;
}
else
{
if (obj != null)
{
var tx = TypeX.Create(obj.GetType());
if (tx.IsInt)
{
var n = Convert.ToUInt64(obj);
if (n == UInt32.MaxValue && Type.GetTypeCode(typeof(T)) == TypeCode.Int32)
{
obj = -1;
}
}
}
value = (T)Reflect.ChangeType(obj, typeof(T));
}
}
catch { return(false); }
return(true);
}
/// <summary>执行插入语句并返回新增行的自动编号</summary>
/// <param name="sql">SQL语句</param>
/// <param name="type">命令类型，默认SQL文本</param>
/// <param name="ps">命令参数</param>
/// <returns>新增行的自动编号</returns>
public virtual Int64 InsertAndGetIdentity(String sql, CommandType type = CommandType.Text, params IDataParameter[] ps)
{
//return Execute(sql, type, ps);
using var cmd = OnCreateCommand(sql, type, ps);
//Transaction?.Check(cmd, true);
//return ExecuteScalar<Int64>(cmd);
return(Execute(cmd, false, cmd2 =>
{
var rs = cmd.ExecuteScalar();
if (rs == null || rs == DBNull.Value)
{
return 0;
}
return Reflect.ChangeType <Int64>(rs);
}));
}
/// <summary>执行SQL语句，返回结果中的第一行第一列</summary>
/// <typeparam name="T">返回类型</typeparam>
/// <param name="sql">SQL语句</param>
/// <param name="type">命令类型，默认SQL文本</param>
/// <param name="ps">命令参数</param>
/// <returns></returns>
public virtual T ExecuteScalar <T>(String sql, CommandType type = CommandType.Text, params IDataParameter[] ps)
{
using var cmd = OnCreateCommand(sql, type, ps);
//return ExecuteScalar<T>(cmd);
return(Execute(cmd, true, cmd2 =>
{
var rs = cmd.ExecuteScalar();
if (rs == null || rs == DBNull.Value)
{
return default(T);
}
if (rs is T)
{
return (T)rs;
}
return (T)Reflect.ChangeType(rs, typeof(T));
}));
}
protected virtual T ExecuteScalar <T>(DbCommand cmd)
{
Transaction?.Check(cmd, false);
QueryTimes++;
WriteSQL(cmd);
var conn = Database.Pool.Get();
try
{
if (cmd.Connection == null)
{
cmd.Connection = conn;
}
BeginTrace();
var rs = cmd.ExecuteScalar();
if (rs == null || rs == DBNull.Value)
{
return(default(T));
}
if (rs is T)
{
return((T)rs);
}
return((T)Reflect.ChangeType(rs, typeof(T)));
}
catch (DbException ex)
{
throw OnException(ex, cmd);
}
finally
{
Database.Pool.Put(conn);
EndTrace(cmd);
//AutoClose();
cmd.Parameters.Clear();
}
}
/// <summary>XML反序列化为实体</summary>
/// <param name="xml"></param>
/// <returns></returns>
public static TEntity FromXml(String xml)
{
var doc = new XmlDocument();
doc.LoadXml(xml);
var entity = new TEntity();
//TypeX tx = TypeX.Create(typeof(TEntity));
foreach (var item in typeof(TEntity).GetProperties(true))
{
//if (AttributeX.GetCustomAttribute<XmlIgnoreAttribute>(item, true) != null) continue;
var elmName = item.Name;
var att = item.GetCustomAttribute <XmlElementAttribute>(true);
if (att != null && !String.IsNullOrEmpty(att.ElementName))
{
elmName = att.ElementName;
}
var node = doc.SelectSingleNode("//" + elmName);
if (node == null)
{
continue;
}
//item.SetValue(entity, Convert.ChangeType(node.InnerText, item.PropertyType));
entity.SetValue(item, Reflect.ChangeType(node.InnerText, item.PropertyType));
}
return(entity);
//XmlSerializer serial = new XmlSerializer(typeof(TEntity));
//using (StringReader reader = new StringReader(xml))
//{
// return serial.Deserialize(reader) as TEntity;
//}
}
