/// <summary>
/// 赋值解析器
/// </summary>
/// <param name="entity">实体类</param>
public string Assign(TEntity entity)
{
Clear();
var map = CacheManger.GetTableMap(typeof(TEntity));
var sb = new StringBuilder();
// 迭代实体赋值情况
foreach (var kic in map.ModelList.Where(o => o.Value.Column.IsMap))
{
// 如果主键有值，则取消修改主键的SQL
if (kic.Value.Column.IsPrimaryKey)
{
continue;
}
var obj = kic.Key.GetValue(entity, null);
if (obj == null || obj is TableSet <TEntity> )
{
continue;
}
// 查找组中是否存在已有的参数，有则直接取出
var newParam = QueueManger.DbProvider.CreateDbParam(QueueSql.Index + "_" + kic.Value.Column.Name, obj, QueueManger.Param, QueueSql.Param);
// 添加参数到列表
sb.AppendFormat("{0} = {1} ,", QueueManger.DbProvider.KeywordAegis(kic.Key.Name), newParam.ParameterName);
}
return(sb.Length > 0 ? sb.Remove(sb.Length - 1, 1).ToString() : sb.ToString());
}
/// <summary>
/// 插入字段解析器
/// </summary>
/// <param name="entity">实体类</param>
public string Insert(TEntity entity)
{
Clear();
var map = CacheManger.GetTableMap(typeof(TEntity));
// 字段
var strFields = new StringBuilder();
// 值
var strValues = new StringBuilder();
//var lstParam = QueryQueue.Param;
// 迭代实体赋值情况
foreach (var kic in map.ModelList.Where(o => o.Value.Column.IsMap))
{
var obj = kic.Key.GetValue(entity, null);
if (obj == null || obj is TableSet <TEntity> )
{
continue;
}
// 查找组中是否存在已有的参数，有则直接取出
var newParam = QueueManger.DbProvider.CreateDbParam(QueueSql.Index + "_" + kic.Value.Column.Name, obj, QueueManger.Param, QueueSql.Param);
// 添加参数到列表
strFields.AppendFormat("{0},", QueueManger.DbProvider.KeywordAegis(kic.Key.Name));
strValues.AppendFormat("{0},", newParam.ParameterName);
}
//QueryQueue.Param = lstParam;
return("(" + strFields.Remove(strFields.Length - 1, 1) + ") VALUES (" + strValues.Remove(strValues.Length - 1, 1) + ")");
}
/// <summary>
/// 数据填充
/// </summary>
/// <param name="reader">源IDataReader</param>
/// <typeparam name="TEntity">实体类</typeparam>
public static TEntity ToInfo <TEntity>(IDataReader reader) where TEntity : class, new()
{
var map = CacheManger.GetFieldMap(typeof(TEntity));
var t = (TEntity)Activator.CreateInstance(typeof(TEntity));
var isHaveValue = false;
if (reader.Read())
{
//赋值字段
foreach (var kic in map.MapList)
{
if (HaveName(reader, kic.Value.FieldAtt.Name))
{
if (!kic.Key.CanWrite)
{
continue;
}
kic.Key.SetValue(t, reader[kic.Value.FieldAtt.Name].ConvertType(kic.Key.PropertyType), null);
isHaveValue = true;
}
}
}
reader.Close();
return(isHaveValue ? t : null);
}
/// <summary>
/// Insert将实体类的赋值，转成表达式树
/// </summary>
/// <typeparam name="TEntity">实体类型</typeparam>
/// <param name="entity">被赋值的实体</param>
internal void AssignInsert <TEntity>(TEntity entity) where TEntity : class, new()
{
if (entity == null)
{
return;
}
ExpAssign = null;
var oParameter = Expression.Parameter(entity.GetType(), "o");
// 迭代实体赋值情况
foreach (var kic in Map.FieldMap.MapList.Where(o => o.Value.FieldAtt.IsMap))
{
// 当前字段不可写
if (kic.Value.FieldAtt.InsertStatusType != StatusType.CanWrite)
{
continue;
}
var obj = CacheManger.GetValue(kic.Key, entity);
if (obj == null)
{
continue;
}
var member = Expression.MakeMemberAccess(oParameter, kic.Key);
var ass = Expression.Assign(member, Expression.Convert(Expression.Constant(obj), kic.Key.PropertyType));
ExpAssign = ExpressionHelper.MergeBlockExpression(ExpAssign, ass);
}
}
public virtual void Update(TEntity entity)
{
var map = CacheManger.GetTableMap(typeof(TEntity));
QueueSql.Sql = new StringBuilder();
var strWhereSql = Visit.Where(QueueSql.ExpWhere);
var strAssemble = Visit.Assign(entity);
// 主键如果有值，则需要 去掉主键的赋值、并且加上主键的条件
if (map.GetModelInfo().Key != null)
{
var value = map.GetModelInfo().Key.GetValue(entity, null);
if (value != null)
{
if (!string.IsNullOrWhiteSpace(strWhereSql))
{
strWhereSql += " AND ";
}
strWhereSql += string.Format("{0} = {1}", map.IndexName, value);
}
}
if (!string.IsNullOrWhiteSpace(strWhereSql))
{
strWhereSql = "WHERE " + strWhereSql;
}
QueueSql.Sql.AppendFormat("UPDATE {0} SET {1} {2}", QueueManger.DbProvider.KeywordAegis(QueueSql.Name), strAssemble, strWhereSql);
}
/// <summary>
/// DataTable转换为实体类
/// </summary>
/// <param name="dt">源DataTable</param>
/// <typeparam name="TEntity">实体类</typeparam>
public static List <TEntity> ToList <TEntity>(this DataTable dt) where TEntity : class, new()
{
var list = new List <TEntity>();
var map = CacheManger.GetFieldMap(typeof(TEntity));
foreach (DataRow dr in dt.Rows)
{
// 赋值字段
var t = new TEntity();
foreach (var kic in map.MapList)
{
if (!kic.Key.CanWrite)
{
continue;
}
var filedName = kic.Value.FieldAtt.IsFun ? kic.Key.Name : kic.Value.FieldAtt.Name;
if (dr.Table.Columns.Contains(filedName))
{
var oVal = ConvertHelper.ConvertType(dr[filedName], kic.Key.PropertyType);
CacheManger.SetValue(kic.Key, t, oVal);
}
}
list.Add(t);
}
return(list);
}
/// <summary>
/// 赋值解析器
/// </summary>
/// <param name="entity">实体类</param>
public string Assign <TEntity>(TEntity entity) where TEntity : class, new()
{
Clear();
var map = CacheManger.GetFieldMap(typeof(TEntity));
var sb = new StringBuilder();
// 迭代实体赋值情况
foreach (var kic in map.MapList.Where(o => o.Value.FieldAtt.IsMap && o.Value.FieldAtt.UpdateStatusType == StatusType.CanWrite))
{
// 如果主键有值，则取消修改主键的SQL
if (kic.Value.FieldAtt.IsPrimaryKey)
{
continue;
}
var obj = kic.Key.GetValue(entity, null);
if (obj == null || obj is TableSet <TEntity> )
{
continue;
}
// 查找组中是否存在已有的参数，有则直接取出
var newParam = QueueManger.DbProvider.CreateDbParam(Queue.Index + "_" + kic.Value.FieldAtt.Name, obj);
Queue.Param.Add(newParam);
// 添加参数到列表
sb.AppendFormat("{0} = {1} ,", QueueManger.DbProvider.KeywordAegis(kic.Key.Name), newParam.ParameterName);
}
return(sb.Length > 0 ? sb.Remove(sb.Length - 1, 1).ToString() : sb.ToString());
}
public override void ToList(int pageSize, int pageIndex, bool isDistinct = false)
{
// 不分页
if (pageIndex == 1)
{
ToList(pageSize, isDistinct); return;
}
var map = CacheManger.GetTableMap(typeof(TEntity));
var strSelectSql = Visit.Select(QueueSql.ExpSelect);
var strWhereSql = Visit.Where(QueueSql.ExpWhere);
var strOrderBySql = Visit.OrderBy(QueueSql.ExpOrderBy);
var strDistinctSql = isDistinct ? "Distinct" : string.Empty;
QueueSql.Sql = new StringBuilder();
strOrderBySql = "ORDER BY " + (string.IsNullOrWhiteSpace(strOrderBySql) ? string.Format("{0} ASC", map.IndexName) : strOrderBySql);
var strOrderBySqlReverse = strOrderBySql.Replace(" DESC", " [倒序]").Replace("ASC", "DESC").Replace("[倒序]", "ASC");
if (!string.IsNullOrWhiteSpace(strWhereSql))
{
strWhereSql = "WHERE " + strWhereSql;
}
if (string.IsNullOrWhiteSpace(strSelectSql))
{
strSelectSql = "*";
}
QueueSql.Sql.AppendFormat("SELECT {0} TOP {2} {1} FROM (SELECT TOP {3} {1} FROM {4} {5} {6}) a {7};", strDistinctSql, strSelectSql, pageSize, pageSize * pageIndex, QueueSql.Name, strWhereSql, strOrderBySql, strOrderBySqlReverse);
}
/// <summary> 写入~/App_Data/SqlLog.xml </summary>
/// <param name="elapsedMilliseconds">执行耗时</param>
public void Write(long elapsedMilliseconds)
{
CreateAt = DateTime.Now;
UserTime = elapsedMilliseconds;
var lstFrames = new StackTrace(true).GetFrames();
if (lstFrames == null)
{
return;
}
var stack = lstFrames.LastOrDefault(o => o.GetFileLineNumber() != 0 && !o.GetMethod().Module.Name.IsEquals("Farseer.Net.dll") && !o.GetMethod().Name.IsEquals("Callback"));
if (stack == null)
{
return;
}
LineNo = stack.GetFileLineNumber();
MethodName = stack.GetMethod().Name;
FileName = stack.GetFileName();
// 序列化
CacheManger.AddSqlRecord(this);
}
/// <summary>
/// IDataReader转换为实体类
/// </summary>
/// <param name="reader">源IDataReader</param>
/// <typeparam name="TEntity">实体类</typeparam>
public static List <TEntity> ToList <TEntity>(IDataReader reader) where TEntity : class, new()
{
var list = new List <TEntity>();
var map = CacheManger.GetFieldMap(typeof(TEntity));
while (reader.Read())
{
var t = (TEntity)Activator.CreateInstance(typeof(TEntity));
//赋值字段
foreach (var kic in map.MapList)
{
if (HaveName(reader, kic.Value.FieldAtt.Name))
{
if (!kic.Key.CanWrite)
{
continue;
}
kic.Key.SetValue(t, reader[kic.Value.FieldAtt.Name].ConvertType(kic.Key.PropertyType), null);
}
}
list.Add(t);
}
reader.Close();
return(list);
}
public override void ToList(int pageSize, int pageIndex, bool isDistinct = false)
{
// 不分页
if (pageIndex == 1)
{
ToList(pageSize, isDistinct); return;
}
var map = CacheManger.GetTableMap(typeof(TEntity));
var strSelectSql = Visit.Select(QueueSql.ExpSelect);
var strWhereSql = Visit.Where(QueueSql.ExpWhere);
var strOrderBySql = Visit.OrderBy(QueueSql.ExpOrderBy);
var strDistinctSql = isDistinct ? "Distinct" : string.Empty;
QueueSql.Sql = new StringBuilder();
if (string.IsNullOrWhiteSpace(strSelectSql))
{
strSelectSql = "*";
}
if (!string.IsNullOrWhiteSpace(strWhereSql))
{
strWhereSql = "WHERE " + strWhereSql;
}
if (string.IsNullOrWhiteSpace(strOrderBySql) && string.IsNullOrWhiteSpace(map.IndexName))
{
throw new Exception("当未指定排序方式时，必须要指定 主键字段");
}
strOrderBySql = "ORDER BY " + (string.IsNullOrWhiteSpace(strOrderBySql) ? string.Format("{0} ASC", map.IndexName) : strOrderBySql);
QueueSql.Sql.AppendFormat("SELECT {1} FROM (SELECT {0} {1},ROW_NUMBER() OVER({2}) as Row FROM {3} {4}) a WHERE Row BETWEEN {5} AND {6};", strDistinctSql, strSelectSql, strOrderBySql, QueueSql.Name, strWhereSql, (pageIndex - 1) * pageSize + 1, pageIndex * pageSize);
}
/// <summary>
/// IDataReader转换为实体类
/// </summary>
/// <param name="reader">源IDataReader</param>
/// <typeparam name="TEntity">实体类</typeparam>
public static List <TEntity> ToList <TEntity>(this IDataReader reader) where TEntity : class, new()
{
var list = new List <TEntity>();
var Map = CacheManger.GetTableMap(typeof(TEntity));
TEntity t;
while (reader.Read())
{
t = (TEntity)Activator.CreateInstance(typeof(TEntity));
//赋值字段
foreach (var kic in Map.ModelList)
{
if (reader.HaveName(kic.Value.Column.Name))
{
if (!kic.Key.CanWrite)
{
continue;
}
kic.Key.SetValue(t, reader[kic.Value.Column.Name].ConvertType(kic.Key.PropertyType), null);
}
}
list.Add(t);
}
reader.Close();
reader.Dispose();
return(list);
}
/// <summary>
/// 将集合类转换成DataTable
/// </summary>
/// <param name="list">集合</param>
/// <returns></returns>
public static DataTable ToTable(this IList list)
{
var result = new DataTable();
if (list.Count <= 0)
{
return(result);
}
var propertys = list[0].GetType().GetProperties();
foreach (var pi in propertys)
{
result.Columns.Add(pi.Name, pi.PropertyType);
}
foreach (var entity in list)
{
var tempList = new ArrayList();
//foreach (var obj in propertys.Select(pi => pi.GetValue(info, null))) { tempList.Add(obj); }
foreach (var obj in propertys.Select(pi => CacheManger.GetValue(pi, entity)))
{
tempList.Add(obj);
}
var array = tempList.ToArray();
result.LoadDataRow(array, true);
}
return(result);
}
/// <summary>
/// DataTable转换为实体类
/// </summary>
/// <param name="dt">源DataTable</param>
/// <typeparam name="T">实体类</typeparam>
public static List <TResult> ToList <TResult>(this DataTable dt) where TResult : class, new()
{
var list = new List <TResult>();
var map = CacheManger.GetTableMap(typeof(TResult));
TResult t;
foreach (DataRow dr in dt.Rows)
{
t = new TResult();
//赋值字段
foreach (var kic in map.ModelList)
{
if (!kic.Key.CanWrite)
{
continue;
}
string filedName;
if (!DbFactory.CreateDbProvider <TResult>().IsField(kic.Value.Column.Name))
{
filedName = kic.Key.Name;
}
else
{
filedName = kic.Value.Column.Name;
}
if (dr.Table.Columns.Contains(filedName))
{
kic.Key.SetValue(t, dr[filedName].ConvertType(kic.Key.PropertyType), null);
}
}
list.Add(t);
}
return(list);
}
public override void ToList(int pageSize, int pageIndex, bool isDistinct = false)
{
// 不分页
if (pageIndex == 1)
{
ToList(pageSize, isDistinct); return;
}
var map = CacheManger.GetTableMap(typeof(TEntity));
var strSelectSql = Visit.Select(QueueSql.ExpSelect);
var strWhereSql = Visit.Where(QueueSql.ExpWhere);
var strOrderBySql = Visit.OrderBy(QueueSql.ExpOrderBy);
var strDistinctSql = isDistinct ? "Distinct" : string.Empty;
QueueSql.Sql = new StringBuilder();
if (string.IsNullOrWhiteSpace(strSelectSql))
{
strSelectSql = "*";
}
if (!string.IsNullOrWhiteSpace(strWhereSql))
{
strWhereSql = "WHERE " + strWhereSql;
}
if (!string.IsNullOrWhiteSpace(strOrderBySql))
{
strOrderBySql = "ORDER BY " + strOrderBySql;
}
QueueSql.Sql.AppendFormat("SELECT {0} {1} FROM {2} {3} {4} LIMIT {5},{6}", strDistinctSql, strSelectSql, QueueManger.DbProvider.KeywordAegis(QueueSql.Name), strWhereSql, strOrderBySql, pageSize * (pageIndex - 1), pageSize);
}
/// <summary>
/// Request.QueryString
/// </summary>
public static T QS <T>(string parmsName, T defValue, Encoding encoding)
{
if (encoding == null)
{
encoding = Encoding.UTF8;
}
if (HttpContext.Current == null)
{
return(defValue);
}
var requestType = HttpContext.Current.Request.GetType();
var property = requestType.GetProperty("QueryStringBytes",
BindingFlags.Instance | BindingFlags.IgnoreCase |
BindingFlags.NonPublic);
//var queryBytes = (byte[])property.GetValue(HttpContext.Current.Request, null);
var queryBytes = (byte[])CacheManger.GetValue(property, HttpContext.Current.Request);
var parms = HttpUtility.UrlDecode(queryBytes, encoding);
if (string.IsNullOrWhiteSpace(parms))
{
return(defValue);
}
parmsName += "=";
foreach (var str in parms.Split('&'))
{
if (str.ToLower().StartsWith(parmsName))
{
return(ConvertHelper.ConvertType(str.Substring(parmsName.Length), defValue));
}
}
return(defValue);
}
/// <summary>
/// 插入字段解析器
/// </summary>
/// <param name="entity">实体类</param>
public string Insert <TEntity>(TEntity entity) where TEntity : class, new()
{
Clear();
var map = CacheManger.GetFieldMap(typeof(TEntity));
// 字段
var strFields = new StringBuilder();
// 值
var strValues = new StringBuilder();
// 迭代实体赋值情况
foreach (var kic in map.MapList.Where(o => o.Value.FieldAtt.IsMap && o.Value.FieldAtt.InsertStatusType == StatusType.CanWrite))
{
var obj = kic.Key.GetValue(entity, null);
if (obj == null || obj is TableSet <TEntity> )
{
continue;
}
// 查找组中是否存在已有的参数，有则直接取出
var newParam = QueueManger.DbProvider.CreateDbParam(Queue.Index + "_" + kic.Value.FieldAtt.Name, obj);
Queue.Param.Add(newParam);
// 添加参数到列表
strFields.AppendFormat("{0},", QueueManger.DbProvider.KeywordAegis(kic.Key.Name));
strValues.AppendFormat("{0},", newParam.ParameterName);
}
//QueryQueue.Param = lstParam;
return("(" + strFields.Remove(strFields.Length - 1, 1) + ") VALUES (" + strValues.Remove(strValues.Length - 1, 1) + ")");
}
/// <summary>
/// 将泛型集合类转换成DataTable
/// </summary>
/// <param name="list">集合</param>
/// <param name="propertyName">需要返回的列的列名</param>
/// <returns>数据集(表)</returns>
public static DataTable ToTable(this IList list, params string[] propertyName)
{
var propertyNameList = new List <string>();
if (propertyName != null)
{
propertyNameList.AddRange(propertyName);
}
var result = new DataTable();
if (list.Count <= 0)
{
return(result);
}
var propertys = list[0].GetType().GetProperties();
foreach (var pi in propertys)
{
if (propertyNameList.Count == 0)
{
result.Columns.Add(pi.Name, pi.PropertyType);
}
else
{
if (propertyNameList.Contains(pi.Name))
{
result.Columns.Add(pi.Name, pi.PropertyType);
}
}
}
foreach (var entity in list)
{
var tempList = new ArrayList();
foreach (var pi in propertys)
{
if (propertyNameList.Count == 0)
{
//var obj = pi.GetValue(info, null);
var obj = CacheManger.GetValue(pi, entity);
tempList.Add(obj);
}
else
{
if (!propertyNameList.Contains(pi.Name))
{
continue;
}
//var obj = pi.GetValue(entity, null);
var obj = CacheManger.GetValue(pi, entity);
tempList.Add(obj);
}
}
var array = tempList.ToArray();
result.LoadDataRow(array, true);
}
return(result);
}
/// <summary>
/// 设置缓存
/// </summary>
/// <param name="key">键</param>
/// <param name="value">值</param>
/// <param name="minutes">分钟</param>
/// <param name="isAbsoluteExpiration">是否绝对时间</param>
/// <param name="onRemoveFacotry">委托</param>
public virtual void Set(string key, object value, int minutes, bool isAbsoluteExpiration, Action <string, object, string> onRemoveFacotry)
{
CacheManger.Set(key, value, minutes, isAbsoluteExpiration, (k, v, reason) =>
{
if (onRemoveFacotry != null)
{
onRemoveFacotry(k, v, reason.ToString());
}
});
}
public override IDbSqlQuery <TEntity> CreateSqlQuery <TEntity>(IQueueManger queueManger, IQueueSql queueSql)
{
var map = CacheManger.GetTableMap(typeof(TEntity));
switch (map.ClassInfo.DataVer)
{
case "2000": return(new SqlQuery2000 <TEntity>(queueManger, queueSql));
}
return(new SqlQuery <TEntity>(queueManger, queueSql));
}
/// <summary>
/// 关系映射
/// </summary>
/// <param name="type">实体类Type</param>
public ContextMap(Type type)
{
Type = type;
MapList = new Dictionary <PropertyInfo, SetState>();
#region 类属性
var attContext = Type.GetCustomAttributes(typeof(ContextAttribute), false);
foreach (var attr in attContext.OfType <ContextAttribute>())
{
ContextProperty = attr;
}
if (ContextProperty == null)
{
ContextProperty = new ContextAttribute();
}
#endregion
#region 变量属性
// 遍历所有Set属性(表、视图、存储过程的名称),取得对应使用标记名称
foreach (var setProperty in Type.GetProperties())
{
if (!new List <string> {
"ViewSet`1", "ViewSetCache`1", "TableSet`1", "TableSetCache`1", "ProcSet`1"
}.Contains(setProperty.PropertyType.Name))
{
continue;
}
var setState = new SetState();
#region Set属性
var setAtt = setProperty.GetCustomAttributes(typeof(SetAttribute), false);
foreach (var attr in setAtt.OfType <SetAttribute>())
{
setState.SetAtt = attr;
}
if (setState.SetAtt == null)
{
setState.SetAtt = new SetAttribute();
}
if (string.IsNullOrWhiteSpace(setState.SetAtt.Name))
{
setState.SetAtt.Name = setProperty.Name;
}
#endregion
// 映射Set属性
setState.FieldMap = CacheManger.GetFieldMap(setProperty.PropertyType.GetGenericArguments()[0]);
//添加属变量标记名称
MapList.Add(setProperty, setState);
}
#endregion
}
/// <summary>
/// 插入（支持延迟加载）会自动赋值主键ID
/// </summary>
/// <param name="entity"></param>
public void Insert(TEntity entity)
{
Check.NotNull(entity, "插入操作时，参数不能为空！");
// 主键是否有值
var indexHaveValue = _set.SetState.FieldMap.PrimaryState.Key != null && CacheManger.GetValue(_set.SetState.FieldMap.PrimaryState.Key, entity) != null;
_set.Insert(entity, !indexHaveValue);
// 更新本地缓存
_set.QueueManger.AppendLazy(_set.Name, _set.SetState, (queue) => ((List <TEntity>)Cache).Add(entity), !_set.Context.IsMergeCommand, false);
}
/// <summary>
/// 将OutPut参数赋值到实体
/// </summary>
/// <typeparam name="TEntity">实体类</typeparam>
/// <param name="queue">每一次的数据库查询，将生成一个新的实例</param>
/// <param name="entity">实体类</param>
private void SetParamToEntity <TEntity>(IQueue queue, TEntity entity) where TEntity : class, new()
{
if (entity == null)
{
return;
}
var map = CacheManger.GetTableMap(typeof(TEntity));
foreach (var kic in map.ModelList.Where(o => o.Value.IsOutParam))
{
kic.Key.SetValue(entity, queue.Param.Find(o => o.ParameterName == DbProvider.ParamsPrefix + kic.Value.Column.Name).Value.ConvertType(kic.Key.PropertyType), null);
}
}
/// <summary>
/// 将OutPut参数赋值到实体
/// </summary>
/// <typeparam name="TEntity">实体类</typeparam>
/// <param name="entity">实体类</param>
private void SetParamToEntity <TEntity>(TEntity entity) where TEntity : class, new()
{
if (entity == null)
{
return;
}
var map = CacheManger.GetFieldMap(typeof(TEntity));
foreach (var kic in map.MapList.Where(o => o.Value.FieldAtt.IsOutParam))
{
kic.Key.SetValue(entity, ConvertHelper.ConvertType(Queue.Param.Find(o => o.ParameterName == Queue.QueueManger.DbProvider.ParamsPrefix + kic.Value.FieldAtt.Name).Value, kic.Key.PropertyType), null);
}
}
/// <summary>
/// 生成测试数据
/// </summary>
/// <typeparam name="TEntity">实体</typeparam>
/// <param name="info">任意对象</param>
/// <param name="subCount">如果成员包含List类型时，要填充的数量</param>
/// <param name="level">防止无限层</param>
private static TEntity FillRandData <TEntity>(this TEntity info, int level, int subCount)
{
var type = info.GetType();
foreach (var item in type.GetProperties())
{
if (!item.CanWrite)
{
continue;
}
var argumType = item.PropertyType;
// 去掉Nullable的类型
if (argumType.IsGenericType && argumType.GetGenericTypeDefinition() == typeof(Nullable <>))
{
argumType = argumType.GetGenericArguments()[0];
}
try
{
// 对 List 类型处理
if (item.PropertyType.IsGenericType)
{
// 动态构造List
var objLst = Activator.CreateInstance(item.PropertyType);
// List元素
var objItem = Activator.CreateInstance(argumType.GetGenericArguments()[0]);
// 防止无限层递归
if (level < 3)
{
for (var i = 0; i < subCount; i++)
{
item.PropertyType.GetMethod("Add").Invoke(objLst, new[] { FillRandData(objItem, level + 1, subCount) });
}
}
//item.SetValue(info, objLst, null);
CacheManger.SetValue(item, info, objLst);
continue;
}
// 普通成员
//item.SetValue(info, DynamicOperate.FillRandData(argumType), null);
CacheManger.SetValue(item, info, DynamicOperate.FillRandData(argumType));
}
catch
{
}
}
return(info);
}
public override void Insert(TEntity entity)
{
base.Insert(entity);
var map = CacheManger.GetTableMap(typeof(TEntity));
// 主键如果有值，则需要 SET IDENTITY_INSERT ON
var indexHaveValue = map.GetModelInfo().Key != null && map.GetModelInfo().Key.GetValue(entity, null) != null;
if (!string.IsNullOrWhiteSpace(map.IndexName) && indexHaveValue)
{
QueueSql.Sql = new StringBuilder(string.Format("SET IDENTITY_INSERT {0} ON ; {1} ; SET IDENTITY_INSERT {0} OFF;", QueueSql.Name, QueueSql.Sql));
}
}
protected void Button1_Click(object sender, EventArgs e)
{
Debug.WriteLine("Set Cache By AbsoluteExpiration:" + DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss"));
CacheManger.Set("time", DateTime.Now, null, DateTime.Now.AddSeconds(10), Cache.NoSlidingExpiration, CacheItemPriority.High, (key, value, reason) =>
{
Debug.WriteLine("Set Cache By AbsoluteExpiration Expired:" + DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss"));
if (CacheItemRemovedReason.Expired == reason)
{
}
Debug.WriteLine("Contain Cache:" + CacheManger.Contain("time"));
});
}
/// <summary>
/// 将OutPut参数赋值到实体
/// </summary>
/// <typeparam name="TEntity">实体类</typeparam>
/// <param name="sqlParam">SQL语句与参数</param>
/// <param name="entity">实体类</param>
private void SetParamToEntity <TEntity>(List <DbParameter> sqlParam, TEntity entity) where TEntity : class, new()
{
if (entity == null)
{
return;
}
var map = CacheManger.GetFieldMap(typeof(TEntity));
foreach (var kic in map.MapList.Where(o => o.Value.FieldAtt.IsOutParam))
{
var oVal = ConvertHelper.ConvertType(sqlParam.Find(o => o.ParameterName == ContextProvider.DbProvider.ParamsPrefix + kic.Value.FieldAtt.Name).Value, kic.Key.PropertyType);
CacheManger.SetValue(kic.Key, entity, oVal);
}
}
/// <summary>
/// 实例化子类中，所有Set属性
/// </summary>
private void InstanceProperty(object context, string propertyName)
{
var lstPropertyInfo = this.GetType().GetProperties();
foreach (var propertyInfo in lstPropertyInfo)
{
if (!propertyInfo.CanWrite || propertyInfo.PropertyType.Name != propertyName)
{
continue;
}
// 动态实例化属性
var set = CacheManger.CreateInstance(propertyInfo.PropertyType, context, propertyInfo);
CacheManger.SetValue(propertyInfo, context, set);
}
}
/// <summary>
/// 返回数据库类型名称
/// </summary>
public static AbsDbProvider CreateInstance <TEntity>() where TEntity : DbContext, new()
{
var dbType = CacheManger.GetContextMap(typeof(TEntity)).ContextProperty.DataType;
switch (dbType)
{
case DataBaseType.OleDb: return(new OleDbProvider());
case DataBaseType.MySql: return(new MySqlProvider());
case DataBaseType.SQLite: return(new SqLiteProvider());
case DataBaseType.Oracle: return(new OracleProvider());
}
return(new SqlServerProvider());
}
