public void Intercept(IInvocation invocation)
        {
            var cacheKey = string.Format("{0}||{1}", invocation.Method.Name, invocation.Method.DeclaringType.Name);

            if (_cache.ContainsKey(cacheKey))
            {
                var entry = _cache[cacheKey];
                if (DateTime.Now < entry.Expiry)
                {
                    invocation.ReturnValue = entry.ReturnValue;
                    return;
                }
            }

            invocation.Proceed();
         
            // Can we cache this entry?
            if (invocation.MethodInvocationTarget.GetCustomAttributes(typeof (CacheAttribute), true).Length == 0) 
                return;
            
            var newEntry = new CacheEntry()
                               {
                                   Expiry = DateTime.Now.AddSeconds(5), 
                                   ReturnValue = invocation.ReturnValue
                               };
            _cache[cacheKey] = newEntry;
        }

        /// <summary>
        /// Returns a Matrix with the data for the TimeStep, Item
        /// TimeStep counts from 0, Item from 1.
        /// Lower left in Matrix is (0,0)
        /// </summary>
        /// <param name="TimeStep"></param>
        /// <param name="Item"></param>
        /// <param name="Layer"></param>
        /// <returns></returns>
        public Matrix GetData(int TimeStep, int Item)
        {
            CacheEntry cen;

              Dictionary<int, CacheEntry> _timeValues;

              if (!_bufferData.TryGetValue(Item, out _timeValues))
              {
            _timeValues = new Dictionary<int, CacheEntry>();
            _bufferData.Add(Item, _timeValues);
              }
              if (!_timeValues.TryGetValue(TimeStep, out cen))
              {
            ReadItemTimeStep(TimeStep, Item);
            Matrix _data = new Matrix(_numberOfRows, _numberOfColumns);
            int m = 0;
            for (int i = 0; i < _numberOfRows; i++)
              for (int j = 0; j < _numberOfColumns; j++)
              {
            _data[i, j] = dfsdata[m];
            m++;
              }
            cen = new CacheEntry(AbsoluteFileName, Item, TimeStep, _data);
            _timeValues.Add(TimeStep, cen);
            CheckBuffer();
              }
              else
            AccessList.Remove(cen);
              AccessList.AddLast(cen);
              return cen.Data;
        }

		public void Id_ShouldReturnCorrectValue(
			[Frozen]Guid id,
			CacheEntry<object> sut)
		{
			//assert
			sut.Id.Should().Be(id);
		}

        public static async Task<long?> GetPrimePlatSellOrders(string primeName)
        {
            CacheEntry<long?> cacheItem;
            if (_marketCache.TryGetValue(primeName, out cacheItem))
            {
                if (!cacheItem.IsExpired(_expirationTimespan))
                {
                    return cacheItem.Value;
                }
            }

            var textInfo = new CultureInfo("en-US", false).TextInfo;

            var partName = textInfo.ToTitleCase(primeName.ToLower());

            if (_removeBPSuffixPhrases.Any(suffix => partName.EndsWith(suffix + " Blueprint")))
            {
                partName = partName.Replace(" Blueprint", "");
            }

            // Since Warframe.Market is still using the term Helmet instead of the new one, TODO: this might change
            partName = partName.Replace("Neuroptics", "Helmet");

            if (_fixedQueryStrings.ContainsKey(partName))
            {
                //Some of Warframe.Market's query strings are mangled (extra spaces, misspellings, words missing) fix them manually...
                partName = _fixedQueryStrings[partName];
            }

            string jsonData;
            using (var client = new WebClient())
            {
                var uri = new Uri(_baseUrl + Uri.EscapeDataString(partName));

                try
                {
                    jsonData = await client.DownloadStringTaskAsync(uri);

                    dynamic result = JsonConvert.DeserializeObject(jsonData);

                    // when the server responds anything that is not 200 (HTTP OK) don't bother doing something else
                    if (result.code != 200)
                    {
                        Debug.WriteLine($"Error with {partName}, Status Code: {result.code.Value}");
                        _marketCache[primeName] = new CacheEntry<long?>(null);
                        return null;
                    }

                    IEnumerable<dynamic> sellOrders = result.response.sell;
                    long? smallestPrice = sellOrders.Where(order => order.online_status).Min(order => order.price);

                    _marketCache[primeName] = new CacheEntry<long?>(smallestPrice);
                    return smallestPrice;
                }
                catch
                {
                    return null;
                }
            }            
        }

		public bool Insert(Segment seg)
		{
			Debug.Assert(Exists(seg.SegmentID) == false);

			int pos = (int)(seg.SegmentID % m_size);

			CacheEntry head = m_data[pos];

			if (head == null)
				m_data[pos] = new CacheEntry(seg);
			else
			{
				while (head.Next != null &&head.Segment.SegmentID != seg.SegmentID)
				{
					head = head.Next;
				}
				if (head.Segment.SegmentID == seg.SegmentID)
					return false;
				else
				{
					head.Next = new CacheEntry(seg,null);
				}
			}

			m_count ++;
			return true;
		}

        public CacheEntry Lookup(string fullname)
        {
            string[] names = fullname.Split('\\');

            CacheEntry current = this;
            CacheEntry child = null;
            foreach (string entry in names)
            {
                if (current.Children == null)
                    current.Children = new Dictionary<string, CacheEntry>();

                if (current.Children.TryGetValue(entry, out child))
                {
                    current = child;
                }
                else
                {
                    CacheEntry cache = new CacheEntry(entry);
                    current.Children[entry] = cache;
                    cache.Parent = current;
                    current = cache;
                }
            }

            return current;
        }

        private CacheEntry CreateCacheEntry(Type type)
        {
            var encoderType = typeof(IFrameEncoder<>).MakeGenericType(type);

            // Func<object, Stream, object, Task> callback = (encoder, body, value) =>
            // { 
            //   return ((IStreamEncoder<T>)encoder).Encode(body, (T)value);
            // }

            var encoderParam = Expression.Parameter(typeof(object), "encoder");
            var bodyParam = Expression.Parameter(typeof(Stream), "body");
            var valueParam = Expression.Parameter(typeof(object), "value");

            var encoderCast = Expression.Convert(encoderParam, encoderType);
            var valueCast = Expression.Convert(valueParam, type);
            var encode = encoderType.GetMethod("Encode", BindingFlags.Public | BindingFlags.Instance);
            var encodeCall = Expression.Call(encoderCast, encode, bodyParam, valueCast);
            var lambda = Expression.Lambda<Func<object, Stream, object, Task>>(encodeCall, encoderParam, bodyParam, valueParam);

            var entry = new CacheEntry
            {
                Encode = lambda.Compile(),
                Encoder = _serviceProvider.GetRequiredService(encoderType)
            };

            return entry;
        }

 public IndexAddTask(QueryIndexManager indexManager, object key, CacheEntry value, OperationContext operationContext)
 {
     _key = key;
     _entry = value;
     _indexManager = indexManager;
     _operationContext = operationContext;
 }

            public static void Cache(DiagnosticAnalyzer analyzer, object key, CacheEntry entry)
            {
                AssertKey(key);

                // add new cache entry
                var analyzerMap = s_map.GetOrAdd(analyzer, _ => new ConcurrentDictionary<object, CacheEntry>(concurrencyLevel: 2, capacity: 10));
                analyzerMap[key] = entry;
            }

        public void Sanity()
        {
            var ceStr = new CacheEntry<string>(1, "3");

            Assert.AreEqual(DateTime.MinValue, ceStr.LastAccessed);
            Assert.AreEqual(1, ceStr.Key);
            Assert.AreEqual("3", ceStr.Val);
            Assert.IsTrue(ceStr.LastAccessed.AddMinutes(1) > DateTime.Now);
        }

 public async Task AddEntryAsync(CacheEntry entry, HttpResponseMessage response)
 {
     CacheEntryContainer cacheEntryContainer = GetOrCreateContainer(entry.Key);
     lock (syncRoot)
     {
         cacheEntryContainer.Entries.Add(entry);
         _responseCache[entry.VariantId] = response;
     }
 }

 public async Task<CacheContent> GetContentAsync(CacheEntry cacheEntry, string secondaryKey)
 {
     var inMemoryCacheEntry = _responseCache[cacheEntry.Key];
     if (inMemoryCacheEntry.Responses.ContainsKey(secondaryKey))
     {
         return await CloneAsync(inMemoryCacheEntry.Responses[secondaryKey]);
     }
     return null;
 }

 /// <summary>
 /// Constructor
 /// </summary>
 /// <param name="listener"></param>
 /// <param name="data"></param>
 public AsyncBroadcastCustomNotifyRemoval(ClusterCacheBase parent, object key, CacheEntry entry, ItemRemoveReason reason, OperationContext operationContext, EventContext eventContext)
 {
     _parent = parent;
     _key = key;
     _entry = entry;
     _reason = reason;
     _operationContext = operationContext;
     _eventContext = eventContext;
 }

 public static CacheEntry Create(object rawValue, DateTime createdAt, object options = null)
 {
     var opts = options.AsDictionary();
     var entry = new CacheEntry(null);
     entry.Value = rawValue;
     entry.CreatedAt = createdAt;
     entry.Compressed = opts["compressed"].AsBoolean();
     return entry;
 }

        public static object GetInstanceOf(Type providerType, object[] providerArgs)
        {
            CacheEntry entry = new CacheEntry(providerType, providerArgs);

            object instance = instances[entry];
            return instance == null
                ? instances[entry] = Reflect.Construct(providerType, providerArgs)
                : instance;
        }

 public static CacheQueryResult ReturnStored(CacheEntry cacheEntry, HttpResponseMessage response)
 {
     HttpCache.UpdateAgeHeader(response);
     return new CacheQueryResult()
     {
         Status = CacheStatus.ReturnStored,
         SelectedEntry = cacheEntry,
         SelectedResponse = response
     };
 }

        private void addToCache(string fileName, CacheEntry entry)
        {
            _cache[fileName] = entry;
            calculateTotalSize();

            while (_totalBytes > _maxBytes)
            {
                deleteOldest();
            }
        }

 private void PropagateCacheDependencies(CacheEntry entry)
 {
     // Bubble up volatile tokens to parent context
     if (_accessor.Current != null)
     {
         foreach (var dependency in entry.Dependencies)
         {
             _accessor.Current.Monitor(dependency);
         }
     }
 }

		public void Reload (CacheEntry entry, object data, int width, int height)
		{
			lock (items) {
				lock (entry) {
					entry.Reload = true;
					entry.Width = width;
					entry.Height = height;
					entry.Data = data;
				}
				Monitor.Pulse (items);
			}
		}

        public void TestHashCode()
        {
            var entry1 = new CacheEntry<int, int>(1, 2);
            var entry2 = new CacheEntry<int, int>(1, 2);
            var entry3 = new CacheEntry<int, int>(1, 3);

            var set = new HashSet<object> {entry1};

            Assert.IsTrue(set.Contains(entry1));
            Assert.IsTrue(set.Contains(entry2));
            Assert.IsFalse(set.Contains(entry3));
        }