设计一个高效的缓存管理服务

namespace　DataCache　{

　　　　 //可缓存的实体类
　　　　 public　class　Canbecached{public　int　Version;}
　　　　 public　class　Article　:　Canbecached　{　}
　　　　 public　class　CacheItem　:　Canbecached
　　　　 {
　　　　　　　　 public　Article　Article;
　　　　 }

　　　　 //每个文章都在版本数据库里保存版本号，该接口提供查询版本方法
　　　　 //如果某个文章修改了，要调用这个接口的UpdateXXVersion方法
　　　　 //来更新数据版本，以便让缓存服务器可以得到真实数据的最新的版本
　　　　 public　interface　VersionManager
　　　　 {
　　　　　　　　 int　GetArticleVersion(int　articleId);
　　　　　　　　 void　UpdateArticleVserion(int　articleId);
　　　　 }

　　　　 //该类用于管理缓存，以及提供缓存使用接口
　　　　 //缓存和使用缓存的服务不一定是一个进程，甚至不是一台机器，通过socket
　　　　 //或者Remoting来使用及更新缓存你
　　　　 internal　static　class　ArticleCacheManager
　　　　 {
　　　　　　　　 private　static　volatile　bool　_cacheAvailable　=　false;
　　　　　　　　 static　Dictionary<int,　CacheItem>　_cache　=　new　Dictionary<int,　CacheItem>();
　　　　　　　　 public　static　bool　CacheAvailable　{
　　　　　　　　　　　　 get　{　return　_cacheAvailable;　}
　　　　　　　　 }
　　　　　　　　 public　static　void　InitCache()
　　　　　　　　 {
　　　　　　　　　　　　 _cache　=　new　Dictionary<int,　CacheItem>();
　　　　　　　　　　　　 _cacheAvailable　=　true;
　　　　　　　　 }

　　　　　　　　 public　static　void　LoadCache()
　　　　　　　　 {
　　　　　　　　　　　　 Dictionary<int,　CacheItem>　cache　=　readCacheFromDisk();
　　　　　　　　　　　　 _cache　=　cache;　//该操作是线程安全的，不需要lock(_cahce)，因为使用_cache的时候都先放到临时变量里再使用的。
　　　　　　　　 }

　　　　　　　　 private　static　Dictionary<int,　CacheItem>　readCacheFromDisk()　{
　　　　　　　　　　　　 throw　new　NotImplementedException();
　　　　　　　　 }
　　　　　　　　 private　static　void　checkCacheAndArticleId(int　articleId)　{
　　　　　　　　　　　　 if　(!_cacheAvailable)　throw　new　InvalidOperationException("Cache　not　Init.");
　　　　　　　　　　　　 if　(articleId　<　1)　throw　new　ArgumentException("articleId");
　　　　　　　　 }

　　　　　　　　 internal　static　VersionManager　GetVersionManager()
　　　　　　　　 {
　　　　　　　　　　　　 throw　　new　NotImplementedException();
　　　　　　　　 }

　　　　　　　　 internal　static　Article　GetArticle(int　articleId)　{
　　　　　　　　　　　　 checkCacheAndArticleId(articleId);
　　　　　　　　　　　　 Dictionary<int,　CacheItem>　cache　=　_cache;
　　　　　　　　　　　　 CacheItem　item;
　　　　　　　　　　　　 if　(cache.TryGetValue(articleId,　out　item))
　　　　　　　　　　　　　　　　 return　item.Article;
　　　　　　　　　　　　 else
　　　　　　　　　　　　　　　　 return　null;
　　　　　　　　 }

　　　　　　　　 internal　static　void　UpdateArticle(int　articleId,　Article　article)　{
　　　　　　　　　　　　 checkCacheAndArticleId(articleId);
　　　　　　　　　　　　 Dictionary<int,　CacheItem>　cache　=　_cache;
　　　　　　　　　　　　 CacheItem　item;
　　　　　　　　　　　　 if　(cache.TryGetValue(articleId,　out　item))
　　　　　　　　　　　　　　　　 item.Article　=　article;　//这个赋值操作是线程安全的，不需要lock这个Item。
　　　　　　　　 }
　　　　 }

　　　　 //从数据库里读取文章信息
　　　　 internal　static　class　DBAdapter
　　　　 {
　　　　　　　　 internal　static　Article　GetArticle(int　articleId,　bool　IsUpdateCache)　{
　　　　　　　　　　　　 Article　article　=　new　Article();
　　　　　　　　　　　　 if(IsUpdateCache)ArticleCacheManager.UpdateArticle(articleId,　article);
　　　　　　　　　　　　 throw　new　NotImplementedException();
　　　　　　　　 }
　　　　 }

　　　　 //用来保存一个文章
　　　　 public　class　ArticleItem
　　　　 {
　　　　　　　　 public　int　ArticleId;
　　　　　　　　 public　ArticleItem(int　articleId)
　　　　　　　　 {
　　　　　　　　　　　　 ArticleId　=　articleId;
　　　　　　　　 }

　　　　　　　　 public　Article　Article;

　　　　　　　　 public　void　Load()
　　　　　　　　 {
　　　　　　　　　　　　 //1、缓存正在切换到时候直接从DB取数据
　　　　　　　　　　　　 if(!ArticleCacheManager.CacheAvailable)
　　　　　　　　　　　　 {
　　　　　　　　　　　　　　　　 Article　=　DBAdapter.GetArticle(ArticleId,false);
　　　　　　　　　　　　　　　　 return;
　　　　　　　　　　　　 }

　　　　　　　　　　　　 VersionManager　versionManager　=　ArticleCacheManager.GetVersionManager();

　　　　　　　　　　　　 //2、比较缓存版本和真实数据版本确定是否使用缓存信息
　　　　　　　　　　　　 DataCache.Article　article　=　ArticleCacheManager.GetArticle(ArticleId);
　　　　　　　　　　　　 if(article　!=　null　&&　article.Version　==　versionManager.GetArticleVersion(ArticleId))
　　　　　　　　　　　　　　　　　 Article　=　ArticleCacheManager.GetArticle(ArticleId);　//尽管这里判断了版本，但也有可能取到旧数据,因为当你获取数据版本并决定使用缓存数据的时候，可能恰好用户修改了文章数据，这种情况只要等用户下次刷新一下页面了，用户体验并不是太差。
　　　　　　　　　　　　 else
　　　　　　　　　　　　　　　　 Article　=　DBAdapter.GetArticle(ArticleId,　article　!=　null);//如果article不是null，说明只是缓存数据版本太旧，这时候要把从数据库取出的数据更新到缓存里

　　　　　　　　 }
　　　　 }
　　　　 class　Program　{
　　　　　　　　 static　Dictionary<int,　ArticleItem>　_articles　=　new　Dictionary<int,　ArticleItem>();
　　　　　　　　 static　void　Main(string[]　args)　
　　　　　　　　 {
　　　　　　　　　　　　 //初始化缓存
　　　　　　　　　　　　 ArticleCacheManager.InitCache();
　　　　　　　　　　　　 //检查是否有新的缓存可用
　　　　　　　　　　　　 new　Thread(checkCacheProc).Start();

　　　　　　　　　　　　 //用户请求一篇文章
　　　　　　　　　　　　 ArticleItem　article1　=　new　ArticleItem(1);
　　　　　　　　　　　　 article1.Load();
　　　　　　　　 }

　　　　　　　　 public　static　void　checkCacheProc(Object　state)
　　　　　　　　 {
　　　　　　　　　　　　 Thread.CurrentThread.Name　=　"Check　whether　there　is　a　new　cache　Thread";
　　　　　　　　　　　　 while　(true)
　　　　　　　　　　　　 {
　　　　　　　　　　　　　　　　 try　{
　　　　　　　　　　　　　　　　　　　　 if　(newCacheAvailable())
　　　　　　　　　　　　　　　　　　　　　　　　 ArticleCacheManager.LoadCache();
　　　　　　　　　　　　　　　　　　　　 Thread.Sleep(TimeSpan.FromMinutes(60));
　　　　　　　　　　　　　　　　 }
　　　　　　　　　　　　　　　　 catch　(Exception　ex)　{
　　　　　　　　　　　　　　　　　　　　 Trace.TraceError("check　cache　occur　an　error:"+　ex.Message);
　　　　　　　　　　　　　　　　 }
　　　　　　　　　　　　 }
　　　　　　　　 }