本地缓存类（LRU Cache），喜欢的朋友拿去用

这是一个固定长度的双向链表，没有闭合，当然是起初没写成闭合的。

怎么缓存的呢？ 就是比如 长度是3000，你缓存一篇文章 就放进去一个， 如果你从里面获取一个A，则A被提到链表的头部，再放入一个B，则B在头部， 其他的就会靠后排。如果缓存的数量超过的3000，再缓存新的时候会踢掉尾部的那个。因为那个用的次数很少。

public class CacheList<T> where T : class
 {
     public class Item
     {
         public string Key { get; set; }
         public T Value { get; set; }
         public Item Left { get; set; }
         public Item Right { get; set; }

         public Item(string key, T value)
         {
             Key = key;
             Value = value;
         }
     }

     private readonly static object _locked = new object();

     private readonly IDictionary<string, Item> _dict;

     public int Length { get; private set; }

     public CacheList(int maxLength)
     {
         _dict = new Dictionary<string, Item>();
         Length = maxLength;
     }

     private Item _first;
     private Item _last;

     public bool HasKey(string key)
     {
         lock (_locked)
         {
             return _dict.ContainsKey(key);
         }
     }

     public void Add(string key, T value)
     {
         var item = new Item(key, value);
         lock (_locked)
         {
             if (_dict.Count == 0)
             {
                 _last = _first = item;
             }
             else if (_dict.Count == 1)
             {
                 _last = _first;
                 _first = item;

                 _last.Left = _first;
                 _first.Right = _last;
             }
             else
             {
                 item.Right = _first;
                 _first.Left = item;
                 _first = item;
             }

             if (_dict.Count >= Length)
             {
                 _last.Left.Right = null;
                 _dict.Remove(_last.Key);
                 _last = _last.Left;
             }

             _dict.AddValue(key, item);
         }
     }


     public T Get(string key)
     {
         Item item = null;
         lock (_locked)
         {
             _dict.TryGetValue(key, out item);
         }
         if (item == null) return null;
         lock (_locked)
         {
             if (_dict.Count == 1)
             {
                 return _first.Value;
             }

             if (item.Left != null)
             {
                 item.Left.Right = item.Right;
             }
             else
             {
                 return item.Value;
             }

             if (item.Right != null)
             {
                 item.Right.Left = item.Left;
             }
             else
             {
                 _last.Left.Right = null;
                 _last = _last.Left;
             }

             item.Left = null;
             item.Right = _first;
             _first.Left = item;
             _first = item;
         }
         return item.Value;
     }

     public void Remove(string key)
     {
         Item item = null;
         lock (_locked)
         {
             _dict.TryGetValue(key, out item);
         }
         if (item == null) return;

         lock (_locked)
         {
             if (item.Left != null)
             {
                 item.Left.Right = item.Right;
             }
             else
             {
                 _first = item.Right;
             }

             if (item.Right != null)
             {
                 item.Right.Left = item.Left;
             }
             else
             {
                 _last = item.Left;
             }

             _dict.Remove(key);
         }
     }

 }

用法如下：

public class ArticleCacheProvider
  {
      private static readonly CacheList<Article> CacheList;

      private static string GetCacheKey(string fileNameOrArticleId, int blogId)
      {
          return ("article_" + fileNameOrArticleId + "_" + blogId).ToLower();
      }

      static ArticleCacheProvider()
      {
          CacheList = new CacheList<Article>(3000);
      }

      public static Article Get(string fileNameOrArticleId, int blogId)
      {
          return CacheList.Get(GetCacheKey(fileNameOrArticleId, blogId));
      }

      public static void Set(Article entity)
      {
          //如果文章有别名，则存2份key，filename和articleId都可以获取缓存实体
          if (entity.FileName != entity.ArticleId.ToString())
          {
              CacheList.Add(GetCacheKey(entity.ArticleId.ToString(), entity.BlogId), entity);
          }
          CacheList.Add(GetCacheKey(entity.FileName, entity.BlogId), entity);
      }

      public static void Remove(string fileNameOrArticleId, int blogId)
      {
          CacheList.Remove(GetCacheKey(fileNameOrArticleId, blogId));
      }

      public static bool HasArticle(string fileNameOrArticleId, int blogId)
      {
          return CacheList.HasKey(GetCacheKey(fileNameOrArticleId, blogId));
      }
  } 

用处?有什么用处呢？，其实就是缓存起来呗，避免一条热门记录的反复查询。