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

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框架的目标的）。