1: public class LruCache<TKey, TValue>

   2: {

   3:     private readonly int _capacity;

   4:     private readonly Stopwatch _stopwatch = Stopwatch.StartNew();

   5:  

   6:     private class Node

   7:     {

   8:         public TValue Value;

   9:         public volatile Reference<long> Ticks;

  10:     }

  11:  

  12:     private readonly ConcurrentDictionary<TKey, Node> _nodes = new ConcurrentDictionary<TKey, Node>();

  13:  

  14:     public LruCache(int capacity)

  15:     {

  16:         Debug.Assert(capacity > 10);

  17:         _capacity = capacity;

  18:     }

  19:  

  20:     public void Set(TKey key, TValue value)

  21:     {

  22:         var node = new Node

  23:         {

  24:             Value = value,

  25:             Ticks = new Reference<long> { Value = _stopwatch.ElapsedTicks }

  26:         };

  27:  

  28:         _nodes.AddOrUpdate(key, node, (_, __) => node);

  29:         if (_nodes.Count > _capacity)

  30:         {

  31:             foreach (var source in _nodes.OrderBy(x => x.Value.Ticks).Take(_nodes.Count / 10))

  32:             {

  33:                 Node _;

  34:                 _nodes.TryRemove(source.Key, out _);

  35:             }

  36:         }

  37:     }

  38:  

  39:     public bool TryGet(TKey key, out TValue value)

  40:     {

  41:         Node node;

  42:         if (_nodes.TryGetValue(key, out node))

  43:         {

  44:             node.Ticks = new Reference<long> {Value = _stopwatch.ElapsedTicks};

  45:             value = node.Value;

  46:             return true;

  47:         }

  48:         value = default(TValue);

  49:         return false;

  50:     }

  51: }