目前Fireasy中的实体模型虽然用CodeBuilder生成，但是还是比较庞大，手工维护起来比较吃力，因此一直想使用比较简单的一种模型，比如属性只有 get 和 set，最多加个ColumnAttribute之类的来做映射。但这样做的话，属性修改这一特性就无法保持了，即更新实体时不知道哪些属性有改动过。
我们先看一下目前生成的实体类代码：
/// <summary>
/// 部门 实体类。
/// </summary>
[Serializable]
[EntityMapping("TB_DEPT", Description = "部门")]
public partial class Dept : EntityObject
{
#region Static Property Definition
/// <summary>
/// ID的依赖属性。
/// </summary>
public static readonly IProperty EpId = PropertyUnity.RegisterProperty<Dept>(s => s.Id, new PropertyMapInfo { IsPrimaryKey = true, IsNullable = false, Length = 36, Description = "ID", FieldName = "ID" });
/// <summary>
/// 编码的依赖属性。
/// </summary>
public static readonly IProperty EpNo = PropertyUnity.RegisterProperty<Dept>(s => s.No, new PropertyMapInfo { Length = 50, Description = "编码", FieldName = "NO" });
/// <summary>
/// 名称的依赖属性。
/// </summary>
public static readonly IProperty EpName = PropertyUnity.RegisterProperty<Dept>(s => s.Name, new PropertyMapInfo { Length = 50, Description = "名称", FieldName = "NAME" });
/// <summary>
/// 排序的依赖属性。
/// </summary>
public static readonly IProperty EpOrderNo = PropertyUnity.RegisterProperty<Dept>(s => s.OrderNo, new PropertyMapInfo { Description = "排序", FieldName = "ORDER_NO" });
#endregion
#region Properties
/// <summary>
/// 获取或设置ID。
/// </summary>
public string Id
{
get { return (string)GetValue(EpId); }
set { SetValue(EpId, value); }
}
/// <summary>
/// 获取或设置编码。
/// </summary>
public string No
{
get { return (string)GetValue(EpNo); }
set { SetValue(EpNo, value); }
}
/// <summary>
/// 获取或设置名称。
/// </summary>
public string Name
{
get { return (string)GetValue(EpName); }
set { SetValue(EpName, value); }
}
/// <summary>
/// 获取或设置排序。
/// </summary>
public int? OrderNo
{
get { return (int?)GetValue(EpOrderNo); }
set { SetValue(EpOrderNo, value); }
}
#endregion
}
以上的实体模型，主要借鉴WPF中的依赖属性原理，定义一个静态的Field实现关系映射，最主要的一点，就是在设置属性的时候，交由基类的SetValue方法来执行，它会把这个修改过的属性记下来，在更新实体的时候，达到只更新修改过的属性的目的。
而GetValue和SetValue看似有装箱和拆箱操作，实际上属性的值是以PropertyValue这个结构存储的，通过重载强制转换和显式转换操作符来交换数据，所以这里不用担心啦。
那么，实际上有了EntityObject基类就好办多了，可以再抽象出一个类，让它基于AOP来创建，在设置属性值之后和获取属性值之后分别调用SetValue和GetValue就好了。
Fireasy本来就提供了AOP，在Fireasy.Common.Aop命名空间中，关键是IInterceptor这个接口，它通过InterceptAttribute特性来绑定要拦截的方法、属性或是整个类。
还有一个接口IAopSupport，它只起到一个标识，在扩展方法New中，如果类型实现了IAopSupport，那么则使用AspectFactory来创建对象。
好，接下来我们定义一个 LighEntityObject 类：
[Intercept(typeof(LighEntityInterceptor))]
public abstract class LighEntityObject<TEntity> : EntityObject,
IAopSupport,
IEntityPropertyInitialize
where TEntity : IEntity
{
/// <summary>
/// 构造一个代理对象。
/// </summary>
/// <returns></returns>
public static TEntity New()
{
return typeof(TEntity).New<TEntity>();
}
void IEntityPropertyInitialize.Initialize()
{
var entityType = this.GetType();
foreach (var property in entityType.BaseType.GetProperties(BindingFlags.Public | BindingFlags.Instance))
{
if (property.DeclaringType == entityType.BaseType)
{
//定义为 virtual
var getMth = property.GetGetMethod();
if (getMth != null && getMth.IsVirtual && !getMth.IsFinal)
{
RegisterProperty(entityType.BaseType, property);
}
}
}
}
private void RegisterProperty(Type entityType, PropertyInfo property)
{
//关联属性，即关联实体或子实体集属性
if (typeof(IEntity).IsAssignableFrom(property.PropertyType) ||
typeof(IEntitySet).IsAssignableFrom(property.PropertyType))
{
var mapping = property.GetCustomAttributes<PropertyMappingAttribute>().FirstOrDefault();
var options = mapping != null && mapping.GetFlag(PropertyMappingAttribute.SetMark.LoadBehavior) ?
new RelationOptions(mapping.LoadBehavior) : null;
PropertyUnity.RegisterSupposedProperty(property.Name, property.PropertyType, entityType, options: options);
}
else
{
var gp = new GeneralProperty()
{
Name = property.Name,
Type = property.PropertyType,
EntityType = entityType,
Info = new PropertyMapInfo { ReflectionInfo = property, FieldName = property.Name }
};
var mapping = property.GetCustomAttributes<PropertyMappingAttribute>().FirstOrDefault();
if (mapping != null)
{
InitMapInfo(mapping, gp.Info);
}
PropertyUnity.RegisterProperty(entityType, gp);
}
}
/// <summary>
/// 根据映射特性设置属性的映射信息。
/// </summary>
/// <param name="mapping"></param>
/// <param name="mapInfo"></param>
private void InitMapInfo(PropertyMappingAttribute mapping, PropertyMapInfo mapInfo)
{
mapInfo.FieldName = mapping.ColumnName;
mapInfo.Description = mapping.Description;
mapInfo.GenerateType = mapping.GenerateType;
if (mapping.GetFlag(PropertyMappingAttribute.SetMark.DataType))
{
mapInfo.DataType = mapping.DataType;
}
if (mapping.GetFlag(PropertyMappingAttribute.SetMark.IsPrimaryKey))
{
mapInfo.IsPrimaryKey = mapping.IsPrimaryKey;
}
if (mapping.GetFlag(PropertyMappingAttribute.SetMark.IsDeletedKey))
{
mapInfo.IsDeletedKey = mapping.IsDeletedKey;
}
if (mapping.DefaultValue != null)
{
mapInfo.DefaultValue = PropertyValue.New(mapping.DefaultValue, mapInfo.ReflectionInfo.PropertyType);
}
if (mapping.GetFlag(PropertyMappingAttribute.SetMark.Length))
{
mapInfo.Length = mapping.Length;
}
if (mapping.GetFlag(PropertyMappingAttribute.SetMark.Precision))
{
mapInfo.Precision = mapping.Precision;
}
if (mapping.GetFlag(PropertyMappingAttribute.SetMark.Scale))
{
mapInfo.Scale = mapping.Scale;
}
}
}
关键还是拦截器了，看下面代码：
public sealed class LighEntityInterceptor : IInterceptor
{
void IInterceptor.Initialize(InterceptContext context)
{
}
void IInterceptor.Intercept(InterceptCallInfo info)
{
if (info.InterceptType == InterceptType.AfterGetValue ||
info.InterceptType == InterceptType.AfterSetValue)
{
var entity = info.Target as EntityObject;
var entityType = entity.EntityType;
var property = PropertyUnity.GetProperty(entityType, info.Member.Name);
if (property == null)
{
return;
}
switch (info.InterceptType)
{
case InterceptType.AfterGetValue:
var value = entity.GetValue(property);
if (value != null && !value.IsEmpty)
{
info.ReturnValue = value.GetStorageValue();
}
break;
case InterceptType.AfterSetValue:
entity.SetValue(property, info.Arguments[0]);
break;
}
}
}
}
其实很简单，在读取属性值和设置属性值的时候，调用GetValue和SetValue就可以了，是不是超简单哈。
LighEntityObject定义好了，但是在何时使用AOP生成代理类呢。
在QueryBinder中找到VisitConstant方法，加入下面这一段：
protected override Expression VisitConstant(ConstantExpression c)
{
if (IsQueryable(c))
{
var rowType = c.Type.GetEnumerableElementType();
if (typeof(IEntity).IsAssignableFrom(rowType))
{
if (typeof(IAopSupport).IsAssignableFrom(rowType))
{
rowType = Fireasy.Common.Aop.InterceptBuilder.BuildType(rowType);
}
return VisitSequence(QueryUtility.GetTableQuery(EntityMetadataUnity.GetEntityMetadata(rowType)));
}
else
{
var q = (IQueryable)c.Value;
return base.Visit(q.Expression);
}
}
return c;
}
好了，改造完成，现在的实体模型比较清爽多了：
/// <summary>
/// 部门 实体类。
/// </summary>
[Serializable]
[EntityMapping("TB_DEPT", Description = "部门")]
public partial class Dept : LighEntityObject<Dept>
{
/// <summary>
/// 获取或设置ID。
/// </summary>
[PropertyMapping(ColumnName = "ID", Description = "ID", IsPrimaryKey = true, IsNullable = false, Length = 36)]
public virtual string Id { get; set; }
/// <summary>
/// 获取或设置编码。
/// </summary>
[PropertyMapping(ColumnName = "NO", Description = "编码", Length = 50)]
public virtual string No { get; set; }
/// <summary>
/// 获取或设置名称。
/// </summary>
[PropertyMapping(ColumnName = "NAME", Description = "名称", Length = 50)]
public virtual string Name { get; set; }
/// <summary>
/// 获取或设置排序。
/// </summary>
[PropertyMapping(ColumnName = "ORDER_NO", Description = "排序")]
public virtual int? OrderNo { get; set; }
/// <summary>
/// 获取或设置 <see cref="Employee"/> 的子实体集。
/// </summary>
public virtual EntitySet<Employee> Employees { get; set; }
}
注意啰，属性都要定义成virtual，不然AOP是不会识别的。
时间： 2024-11-05 12:24:35