public void Resolver(IResolverContext context, IDependencyResolver resolver)
{
var properties = PropertyCacheManager.GetOrSetCache(context.Dependency,
() =>
context.Resolved.GetType().
GetProperties(BindingFlags.Public | BindingFlags.Instance).
Where(property => DependencyCacheManager.GetCache((IScopedResolver)resolver).
Any(dependency => property.PropertyType == dependency.ServiceType) &&
!property.IsDefined(typeof(IgnoreDependencyAttribute), false)));
foreach (var property in properties)
{
try
{
PropertySetCacheManger.Cache(property, context.Resolved, resolver.Resolve(property.PropertyType));
}
catch (Exception ex)
{
throw new InvalidOperationException(
$"类型\"{context.Dependency.GetImplementationType()}\"未能注入属性\"{property.PropertyType}\"的实例。",
ex);
}
}
context.Handled = true;
}
/// <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 = SetMapCacheManger.Cache(typeof(TEntity));
while (reader.Read())
{
var t = (TEntity)Activator.CreateInstance(typeof(TEntity));
//赋值字段
foreach (var kic in map.MapList)
{
if (HaveName(reader, kic.Value.Field.Name))
{
if (!kic.Key.CanWrite)
{
continue;
}
var oVal = ConvertHelper.ConvertType(reader[kic.Value.Field.Name], kic.Key.PropertyType);
PropertySetCacheManger.Cache(kic.Key, t, oVal);
}
}
list.Add(t);
}
reader.Close();
return(list);
}
/// <summary>
/// 数据填充
/// </summary>
/// <param name="reader">源IDataReader</param>
/// <typeparam name="TEntity">实体类</typeparam>
public static TEntity ToEntity <TEntity>(this IDataReader reader) where TEntity : class, new()
{
var map = SetMapCacheManger.Cache(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.Field.Name))
{
if (!kic.Key.CanWrite)
{
continue;
}
var oVal = ConvertHelper.ConvertType(reader[kic.Value.Field.Name], kic.Key.PropertyType);
PropertySetCacheManger.Cache(kic.Key, t, oVal);
isHaveValue = true;
}
}
}
reader.Close();
return(isHaveValue ? t : null);
}
/// <summary>
/// 将DataRow转成实体类
/// </summary>
/// <typeparam name="TEntity">实体类</typeparam>
/// <param name="dr">源DataRow</param>
public static TEntity ToInfo <TEntity>(DataRow dr) where TEntity : class, new()
{
var map = SetMapCacheManger.Cache(typeof(TEntity));
var t = new TEntity();
//赋值字段
foreach (var kic in map.MapList)
{
if (!kic.Key.CanWrite)
{
continue;
}
var filedName = kic.Value.Field.IsFun ? kic.Key.Name : kic.Value.Field.Name;
if (dr.Table.Columns.Contains(filedName))
{
var oVal = dr[filedName].ConvertType(kic.Key.PropertyType);
if (oVal == null)
{
continue;
}
PropertySetCacheManger.Cache(kic.Key, t, oVal);
}
}
return(t);
}
/// <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 = SetMapCacheManger.Cache(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.Field.IsFun ? kic.Key.Name : kic.Value.Field.Name;
if (dr.Table.Columns.Contains(filedName))
{
var oVal = ConvertHelper.ConvertType(dr[filedName], kic.Key.PropertyType);
PropertySetCacheManger.Cache(kic.Key, t, oVal);
}
}
list.Add(t);
}
return(list);
}
/// <summary>
/// 将OutPut参数赋值到实体
/// </summary>
/// <typeparam name="TEntity">实体类</typeparam>
/// <param name="map">实体类结构</param>
/// <param name="lstParam">SQL参数列表</param>
/// <param name="entity">实体类</param>
public void SetParamToEntity<TEntity>(SetPhysicsMap map, List<DbParameter> lstParam, TEntity entity) where TEntity : class, new()
{
if (entity == null) { return; }
foreach (var kic in map.MapList.Where(o => o.Value.Field.IsOutParam))
{
var oVal = ConvertHelper.ConvertType(lstParam.Find(o => o.ParameterName == ParamsPrefix + kic.Value.Field.Name).Value, kic.Key.PropertyType);
PropertySetCacheManger.Cache(kic.Key, entity, oVal);
}
}
/// <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);
PropertySetCacheManger.Cache(item, info, objLst);
continue;
}
// 普通成员
//item.SetValue(info, DynamicOperate.FillRandData(argumType), null);
PropertySetCacheManger.Cache(item, info, DynamicOperate.FillRandData(argumType));
}
catch {
}
}
return(info);
}
/// <summary>
/// 动态添加List元素
/// </summary>
/// <param name="propertyInfo">字段类型</param>
/// <param name="entity">所属实体变量</param>
/// <param name="methodName">方法名称，默认是Add</param>
private static void AddItem(PropertyInfo propertyInfo, object entity, string methodName = "Add")
{
// 非泛型，退出执行
if (!propertyInfo.PropertyType.IsGenericType)
{
return;
}
var lstVal = PropertyGetCacheManger.Cache(propertyInfo, entity);
// 空时，反射创建
if (lstVal == null)
{
lstVal = InstanceCacheManger.Cache(propertyInfo.PropertyType);
PropertySetCacheManger.Cache(propertyInfo, entity, lstVal);
}
// 获取执行方法
var method = propertyInfo.PropertyType.GetMethod(methodName);
if (method == null)
{
return;
}
var lstParamInstance = new List <object>();
foreach (var parameterInfo in method.GetParameters())
{
// 反射创建子元素
object item;
if (parameterInfo.ParameterType == typeof(string))
{
item = string.Empty;
}
else
{
item = parameterInfo.ParameterType.IsClass ? InstanceCacheManger.Cache(parameterInfo.ParameterType) : 0;
}
lstParamInstance.Add(item);
}
method.Invoke(lstVal, lstParamInstance.ToArray());
foreach (var field in lstVal.GetType().GetFields())
{
AddItem(field, lstVal);
}
foreach (var property in lstVal.GetType().GetProperties())
{
AddItem(property, lstVal);
}
}
static void TestSetValueCache(int count = 10000000)
{
var user = new UserVO();
var propertyInfo = user.GetType().GetProperty("UserName");
SpeedTest.ConsoleTime("手动赋值", count, () =>
{
user.UserName = "******";
});
SpeedTest.ConsoleTime("表达式树赋值", count, () =>
{
PropertySetCacheManger.Cache(propertyInfo, user, "jj");
});
SpeedTest.ConsoleTime("反射赋值", count, () =>
{
propertyInfo.SetValue(user, "jj", null);
});
}
/// <summary>
/// 将DataRow转成实体类
/// </summary>
/// <typeparam name="TEntity">实体类</typeparam>
/// <param name="dr">源DataRow</param>
public static TEntity ToInfo <TEntity>(this DataRow dr) where TEntity : class, new()
{
var map = SetMapCacheManger.Cache(typeof(TEntity));
var t = (TEntity)Activator.CreateInstance(typeof(TEntity));
//赋值字段
foreach (var kic in map.MapList)
{
if (dr.Table.Columns.Contains(kic.Value.Field.Name))
{
if (!kic.Key.CanWrite)
{
continue;
}
PropertySetCacheManger.Cache(kic.Key, t, dr[kic.Value.Field.Name].ConvertType(kic.Key.PropertyType));
}
}
return(t ?? new TEntity());
}
/// <summary>
/// 设置对象属性值
/// </summary>
/// <typeparam name="TEntity">实体类</typeparam>
/// <typeparam name="T">返回值类型</typeparam>
/// <param name="info">当前实体类</param>
/// <param name="propertyName">属性名</param>
/// <param name="objValue">要填充的值</param>
public static void SetValue <TEntity>(this TEntity info, string propertyName, object objValue) where TEntity : class
{
if (info == null)
{
return;
}
foreach (var property in info.GetType().GetProperties())
{
if (property.Name != propertyName)
{
continue;
}
if (!property.CanWrite)
{
return;
}
//property.SetValue(info, objValue.ConvertType(property.PropertyType), null);
PropertySetCacheManger.Cache(property, info, objValue.ConvertType(property.PropertyType));
}
}
/// <summary>
/// 插入
/// </summary>
/// <param name="entity"></param>
/// <param name="isReturnLastID">是否需要返回标识字段（如果设置的话）</param>
public int Insert(TEntity entity, bool isReturnLastID = false)
{
Check.NotNull(entity, "插入操作时，参数不能为空！");
// 实体类的赋值，转成表达式树
Queue.ExpBuilder.AssignInsert(entity);
// 需要返回值时，则不允许延迟提交
if (isReturnLastID && SetMap.PhysicsMap.DbGeneratedFields.Key != null)
{
// 赋值标识字段
return(QueueManger.Commit(SetMap, (queue) =>
{
PropertySetCacheManger.Cache(SetMap.PhysicsMap.DbGeneratedFields.Key, entity, Context.Executeor.GetValue <int>(queue.SqlBuilder.InsertIdentity()));
return 1;
}, false));
}
// 不返回标识字段
return(QueueManger.CommitLazy(SetMap, (queue) => Context.Executeor.Execute(queue.SqlBuilder.Insert()), false));
}
/// <summary>
/// 将XML转成实体
/// </summary>
public static List <TEntity> ToList <TEntity>(this XElement element) where TEntity : class
{
var orm = SetMapCacheManger.Cache(typeof(TEntity));
var list = new List <TEntity>();
foreach (var el in element.Elements())
{
var t = (TEntity)Activator.CreateInstance(typeof(TEntity));
//赋值字段
foreach (var kic in orm.MapList)
{
var type = kic.Key.PropertyType;
if (!kic.Key.CanWrite)
{
continue;
}
//switch (kic.Value.PropertyExtend)
{
//case eumPropertyExtend.Attribute:
// if (el.Attribute(kic.Value.Name) == null) { continue; }
//kic.Key.SetValue(t, el.Attribute(kic.Value.Name).Value.ConvertType(type), null);
// PropertySetCacheManger.Cache(kic.Key, t, el.Attribute(kic.Value.Name).Value.ConvertType(type));
// break;
// case eumPropertyExtend.Element:
if (el.Element(kic.Value.Field.Name) == null)
{
continue;
}
//kic.Key.SetValue(t, el.Element(kic.Value.Name).Value.ConvertType(type), null);
PropertySetCacheManger.Cache(kic.Key, t, el.Element(kic.Value.Field.Name).Value.ConvertType(type));
break;
}
}
list.Add(t);
}
return(list);
}
/// <summary>
/// 插入
/// </summary>
/// <param name="entity"></param>
/// <param name="isReturnLastID">是否需要返回标识字段（如果设置的话）</param>
public Task <int> InsertAsync(TEntity entity, bool isReturnLastID = false)
{
Check.NotNull(entity, "插入操作时，参数不能为空！");
// 实体类的赋值，转成表达式树
Queue.ExpBuilder.AssignInsert(entity);
// 需要返回值时，则不允许延迟提交
if (isReturnLastID && SetMap.PhysicsMap.DbGeneratedFields.Key != null)
{
// 赋值标识字段
return(QueueManger.CommitAsync(SetMap, async(queue) =>
{
var sourceValue = await Context.Executeor.GetValueAsync <object>(queue.SqlBuilder.InsertIdentity());
PropertySetCacheManger.Cache(SetMap.PhysicsMap.DbGeneratedFields.Key, entity, ConvertHelper.ConvertType(sourceValue, SetMap.PhysicsMap.DbGeneratedFields.Key.PropertyType));
return 1;
}, false));
}
// 不返回标识字段
return(QueueManger.CommitAsync(SetMap, (queue) => Context.Executeor.ExecuteAsync(queue.SqlBuilder.Insert()), false));
}
public void Resolver(IResolverContext context, IDependencyResolver resolver)
{
var properties = context.CompleteValue.GetType().GetProperties(BindingFlags.Public | BindingFlags.Instance).
Where(property => _dependencyTable.PropertyEntryTable.ContainsKey(property.PropertyType));
foreach (var property in properties)
{
try
{
if (!property.IsDefined(typeof(IgnoreDependencyAttribute), false))
{
PropertySetCacheManger.Cache(property, context.CompleteValue, resolver.Resolve(property.PropertyType));
}
}
catch (Exception ex)
{
throw new InvalidOperationException(String.Format("类型\"{0}\"未能注入属性\"{1}\"的实例。",
context.DependencyEntry.GetImplementationType(), property.PropertyType), ex);
}
}
context.Complete = true;
}
/// <summary>
/// 把提交过来的内容转化成为实体类(注意CheckBox 未选中时，是NULL，需要手动判断)
/// </summary>
/// <param name="request">NameValueCollection</param>
/// <param name="prefix">控件前缀</param>
/// <param name="dicError">返回错误消息,key：属性名称；value：错误消息</param>
public static TEntity Fill <TEntity>(NameValueCollection request, out Dictionary <string, List <string> > dicError, string prefix = "hl") where TEntity : class, new()
{
dicError = new Dictionary <string, List <string> >();
var t = new TEntity();
foreach (var kic in EntityPhysicsMapCacheManger.Cache(typeof(TEntity)).MapList)
{
var lstError = new List <string>();
var reqName = prefix + kic.Key.Name;
if (request[reqName] == null || !kic.Key.CanWrite)
{
continue;
}
var obj = request[reqName].Trim().ConvertType(kic.Key.PropertyType);
// 证明类型转换失败
if (request[reqName].Trim().Length > 0 && obj == null)
{
var type = kic.Key.PropertyType;
if (type.IsGenericType && type.GetGenericTypeDefinition() == typeof(Nullable <>))
{
type = Nullable.GetUnderlyingType(type);
}
var displayAtt = kic.Value.FirstOrDefault(o => o is DisplayAttribute);
var err = displayAtt == null ? "" : $"[{((DisplayAttribute) displayAtt).Name}]";
switch (type.Name)
{
case "DateTime":
lstError.Add(err + "必须为时间格式。如：2011-09-01");
break;
case "Boolean":
lstError.Add(err + "必须为布尔格式。如：false、true");
break;
case "UInt64":
lstError.Add(err + "必须为整形格式。");
break;
case "Int64":
lstError.Add(err + "必须为整形格式。");
break;
case "Int32":
lstError.Add(err + "必须为整形格式2。");
break;
case "Int16":
lstError.Add(err + "必须为整形格式。");
break;
case "Decimal":
lstError.Add(err + "必须为数字格式。");
break;
case "Byte":
lstError.Add(err + "必须为字节格式。");
break;
case "Long":
lstError.Add(err + "必须为整形格式。");
break;
case "Float":
lstError.Add(err + "必须为数字格式。");
break;
case "Double":
lstError.Add(err + "必须为数字格式。");
break;
}
}
if (lstError.Count > 0)
{
dicError.Add(kic.Key.Name, lstError);
}
else
{
PropertySetCacheManger.Cache(kic.Key, t, obj);
}
}
return(dicError.Count > 0 ? null : t);
}
