缓存类的实现（C#）

以下是组件测试的情况
p4 2.4 1g
sqlserver sp3

运行的代码大概如下：
entitys.customers customer = new test.entitys.customers();
datetime dt = datetime.now;
using(hfsoft.data.idatasession session = mapcontainer.opensession())
{
 session.open();
 for(int i =0;i<2000;i++)
 {
  customer.customerid = guid.newguid().tostring();
  customer.companyname = "henry";
  session.save(customer);
 }
}
tp1 = new timespan(datetime.now.ticks - dt.ticks);

不开启缓存（5个线程运行时间）
00:00:05.7031250
00:00:06.8281250
00:00:05.0156250
00:00:06.6875000
00:00:06.4218750
--------------------------------------------------------
开启5个命令缓存（5个线程运行时间）
00:00:04.8906250
00:00:03.5625000
00:00:02.8750000
00:00:04.9375000
00:00:05.4843750
---------------------------------------------------------

以下是缓存类的源码
/// <summary>
/// 数据缓存保存信息异步处理委托
/// </summary>
delegate  void eventsavecache(object key,object value);
/// <summary>
/// 对象缓存类
/// </summary>
public class cache
{
private mappingcontainer mcontainer;
/// <summary>
/// 获取或设置当前缓存对象所在的关系映象容器
/// </summary>
public mappingcontainer container
{
 get
 {
  return mcontainer;
 }
 set
 {
  mcontainer = value;
 }
}
/// <summary>
/// 构造缓存对象
/// </summary>
public cache()
{
 //
 // todo: 在此处添加构造函数逻辑
 //
}
/// <summary>
/// 用于缓存数据的hashtable
/// </summary>
protected  system.collections.hashtable _cache = new system.collections.hashtable();
protected object _lockobj = new object();
/// <summary>
/// 获取指定键值的对象
/// </summary>
/// <param name="key">键值</param>
/// <returns>object</returns>
public virtual object getobject(object key)
{
 if(_cache.containskey(key))
  return _cache[key];
 return null;
}
/// <summary>
/// 把对象按指定的键值保存到缓存中
/// </summary>
/// <param name="key">键值</param>
/// <param name="value">保存的对象</param>
public void savecaech(object key,object value)
{
 eventsavecache save = new eventsavecache(setcache);
 iasyncresult ar = save.begininvoke(key,value,new system.asynccallback(results),null);
}
private  void results(iasyncresult ar)
{
 eventsavecache fd = (eventsavecache)((asyncresult)ar).asyncdelegate;
 fd.endinvoke(ar);
}
/// <summary>
/// 把对象按指定的键值保存到缓存中
/// </summary>
/// <param name="key">键值</param>
/// <param name="value">保存的对象</param>
protected virtual void setcache(object key ,object value)
{
 lock(_lockobj)
 {
  if(!_cache.containskey(key))
   _cache.add(key,value);
 }
}
public int count
{
 get
 {
  return _cache.count;
 }
}
/// <summary>
/// 在缓存中删除指定键值的对象
/// </summary>
/// <param name="key">键值</param>
public virtual void delobject(object key)
{
 lock(_cache.syncroot)
 {
  _cache.remove(key);
 }
}
/// <summary>
/// 清除缓存中所有对象
/// </summary>
public virtual void clear()
{
 lock(_cache.syncroot)
 {
  _cache.clear();
 }
}
}

/// <summary>
///针对一条记录操作命令的缓存类
/// </summary>
public class cachepersistentcommand:cache
{
 
/// <summary>
/// 把记录操作命令缓存到内存中
/// </summary>
/// <param name="key">标识</param>
/// <param name="value">值</param>
protected override void setcache(object key, object value)
{
 lock(_lockobj)
 {
  int count=0;
  if(container.config.commandscache.containskey(key))
   count=(int) container.config.commandscache[key];
  system.collections.ilist _list;
  //如果缓存中已经存在这种命令的列表
  if(_cache.containskey(key))
  {
   _list = (system.collections.ilist)_cache[key];
   
   if( count >0)//命令的缓存总数
   {
    if(_list.count < count)//缓存数据量少于缓存总数
     _list.add(value);
   }
   else
   {
    if(_list.count < container.config.commandbuffer)//缓存数小于组件的默认列表
     _list.add(value);
   }
  }
  else//如果不存在列表
  {
   if(count >0 || container.config.commandbuffer >0)//如果组件允许对象缓存
   {
    _list = new system.collections.arraylist();
    _list.add(value);
    _cache.add(key,_list);
   }
  }
 }
}
/// <summary>
/// 从缓存中获取相关命令对象
/// </summary>
/// <param name="key">标识</param>
/// <returns>ipersistentcommand</returns>
public override object getobject(object key)
{
 
 if(_cache.contains(key))//如果命令存在缓冲中
 {
  foreach(ipersistentcommand cmd in (system.collections.ilist)_cache[key])
  {
   if(!cmd.state)//命令是否可以过行锁定
    if(cmd.lock())//命令锁定
     return cmd;
  }
 }
 return null;
}

}