解剖实体框架(4)--实体的管理

实体的管理主要包括如下功能：

  A） 实现实体的缓存；

  B) 实现实体的新增，修改，删除，查询等功能；

  C）刷新缓存与数据库同步

  D)  将缓存语句与数据库同步

上面是一些基本的功能，下面是一个基本示例：

//实体状态，对于实体采用缓存方式时有用。

public enum EntityState
    {
        NoChanging,
        Added,
        Modified,
        Deleted
    }

   //这个类是真正实体的容器，目的是为了附加一些信息，便于实体的管理。
    public class EntityItem<T>
    {
        public T StorageItem{get;set;}
        public T CurrentItem{get;set;}
        public T OrigialItem{get;set;}
        public EntityState State{get;set;}
        public EntityItem()
        {
        }
    }

   //利用委托，将选择等工作交给用户自己决定。
    public delegate bool Selector<T>(T M);

    //实体管理类，需要提供数据库连接管理，实体加载，查询，新增，删除，修改，与数据库同步等功能

    //另外也需要提供事务支持功能，支持事务时需要提供能传入连接和事务实例的构造功能。

    //或者本身实现事务，自我回滚，并抛出异常，这样可以实现多个管理类之间的任意组合式事务处理。
    public class EntityMgmt<T>
    {

      

       //实体集合
        private List<EntityItem<T>> _entities;
        private string _connString;
        public EntityMgmt():this("")
        {
           
        }
        public EntityMgmt(string Conn)
        {
            _entities = new List<EntityItem<T>>();
            _connString = Conn;
            if (_connString == "")
            {
                //LoadFromConfigurationFile
            }
        }
        private void LoadEntities()
        {
            //构造查询SQL，加载实体，可参见与数据库交互部分.
        }

        //提供查询功能
        public IEnumerable<T> GetEntities(Selector<T> Selector)
        {
            List<T> theRets = new List<T>();
            if (_entities.Count <= 0)
            {
                LoadEntities();
            }
            for (int i = 0; i < _entities.Count; i++)
            {
                if (_entities[i].State!= EntityState.Deleted && Selector(_entities[i].CurrentItem) == true)
                {
                    theRets.Add(_entities[i].CurrentItem);
                }
            }
            return theRets.AsEnumerable();
        }
        //新增一个实体
        public void Add(T Item)
        {
            EntityItem<T> theItem = new EntityItem<T>();
            theItem.CurrentItem = Item;
            theItem.OrigialItem = Item;
            theItem.State = EntityState.Added;
            _entities.Add(theItem);
        }

       //修改
        public void Update(T Item, Selector<T> SelectOldItem)
        {
            EntityItem<T> theEntityItem = null;
            for (int i = 0; i < _entities.Count; i++)
            {
                if (SelectOldItem(_entities[i].CurrentItem) == true)
                {
                    theEntityItem = _entities[i];
                    break;
                }
            }
            if (theEntityItem != null)
            {
                theEntityItem.CurrentItem = Item;
                theEntityItem.State = EntityState.Modified;
            }
        }
        //接受改变，并将变化同步到数据库.
        public void AcceptChanges()
        {
            foreach (var item in _entities)
            {
                switch (item.State)
                {
                    case EntityState.Added:
                        DbOperation.InsertModel<T>(item.CurrentItem);
                        break;
                    case EntityState.Deleted:
                        break;
                    case EntityState.Modified:
                        //这里可以利用item.StorageItem做并发检测
                        break;
                }
            }
        }
    }
   public enum CacheType
    {
        AppLevel,
        SessionLevel,
        None
    }
    //用工厂模式实现对实体管理类的创建，这样的好处是可以在这里实现对实体管理类本身的管理：
    //全局单例模式，Session级共享等.
    //这个类也可以实现对某个实体管理工厂的单例模式
    public static class EntityMgmtFactory
    {
        private static readonly Dictionary<Type, CacheType> _CacheTypes = new Dictionary<Type, CacheType>();
        static EntityMgmtFactory()
        {
            //可以根据文件配置加载缓存方式.
        }
        public EntityMgmt<T> CreateEntityMgmt<T>(string conn)
        {
            //根据缓存类型来创建或获取实体管理类的实例。
            //这里不再赘述。缓存级别可以利用Runtime的Session.
            return new EntityMgmt<T>(conn);
        }
    }

================================

上面的示例只是一些基本的功能，在实际应用中需要考虑的会更为复杂，比如可以设置失效期，自动同步等。另外也需要提供直接执行SQL的功能等。

AEF的方式比较复杂，但基本原理差不多，它的ESQL确实比较强大，这是其它一般框架所不具备的，但所谓成也萧何败也萧何，提供如关系数据库般得功能，

结果把简单问题复杂化了，反而在缓存，复杂查询，自由SQL支持方面显得不足（对自由SQL的支持实际上是违背AEF框架的目标的）。