使用AOP改进Fireasy实体模型_.NET_编程开发_程序员俱乐部

      目前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这个结构存储的，通过重载强制转换和显式转换caozuofu.html" target="_blank">操作符来交换数据，所以这里不用担心啦。

      那么，实际上有了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是不会识别的。