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); }