private void AddUsageEntryToFreeList(UsageEntryRef entryRef)
{
Debug.Assert(entryRef.IsRef1, "entryRef.IsRef1");
UsageEntry[] entries = (_pages[(entryRef.PageIndex)]._entries);
int entryIndex = entryRef.Ref1Index;
Debug.Assert(entries[entryIndex]._cacheEntry == null, "entries[entryIndex]._cacheEntry == null");
entries[entryIndex]._utcDate = DateTime.MinValue;
entries[entryIndex]._ref1._prev = UsageEntryRef.INVALID;
entries[entryIndex]._ref2._next = UsageEntryRef.INVALID;
entries[entryIndex]._ref2._prev = UsageEntryRef.INVALID;
entries[entryIndex]._ref1._next = ((entries)[0]._ref1._next);
((entries)[0]._ref1._next) = entryRef;
_cEntriesInUse--;
int pageIndex = entryRef.PageIndex;
((entries)[0]._cFree)++;
if (((entries)[0]._cFree) == 1)
{
AddToListHead(pageIndex, ref _freeEntryList);
}
else if (((entries)[0]._cFree) == NUM_ENTRIES)
{
RemovePage(pageIndex);
}
}
internal void RemoveCacheEntry(MemoryCacheEntry cacheEntry)
{
lock (this)
{
UsageEntryRef entryRef = cacheEntry.UsageEntryRef;
if (entryRef.IsInvalid)
{
return;
}
UsageEntry[] entries = (_pages[(entryRef.PageIndex)]._entries);
int entryIndex = entryRef.Ref1Index;
cacheEntry.UsageEntryRef = UsageEntryRef.INVALID;
entries[entryIndex]._cacheEntry = null;
RemoveEntryFromLastRefList(entryRef);
AddUsageEntryToFreeList(entryRef);
Reduce();
Dbg.Trace("CacheUsageRemove",
"Removed item=" + cacheEntry.Key +
",_bucket=" + _bucket +
",ref=" + entryRef);
}
}
internal MemoryCacheEntry(string key,
object value,
DateTimeOffset absExp,
TimeSpan slidingExp,
CacheItemPriority priority,
Collection <ChangeMonitor> dependencies,
CacheEntryRemovedCallback removedCallback,
MemoryCache cache) : base(key)
{
if (value is null)
{
throw new ArgumentNullException(nameof(value));
}
_utcCreated = DateTime.UtcNow;
_value = value;
_slidingExp = slidingExp;
if (_slidingExp > TimeSpan.Zero)
{
_utcAbsExp = _utcCreated + _slidingExp;
}
else
{
_utcAbsExp = absExp.UtcDateTime;
}
_expiresEntryRef = ExpiresEntryRef.INVALID;
_expiresBucket = 0xff;
_usageEntryRef = UsageEntryRef.INVALID;
if (priority == CacheItemPriority.NotRemovable)
{
_usageBucket = 0xff;
}
else
{
_usageBucket = 0;
}
_callback = removedCallback;
// CacheItemPolicy.ChangeMonitors is frequently the source for 'dependencies', and that property
// is never null. So check that the collection of dependencies is not empty before allocating
// the 'seldom' used fields.
if (dependencies != null && dependencies.Count > 0)
{
_fields = new SeldomUsedFields();
_fields._dependencies = dependencies;
_fields._cache = cache;
}
}
internal MemoryCacheEntry(String key,
Object value,
DateTimeOffset absExp,
TimeSpan slidingExp,
CacheItemPriority priority,
Collection <ChangeMonitor> dependencies,
CacheEntryRemovedCallback removedCallback,
MemoryCache cache) : base(key)
{
if (value == null)
{
throw new ArgumentNullException("value");
}
_utcCreated = DateTime.UtcNow;
_value = value;
_slidingExp = slidingExp;
if (_slidingExp > TimeSpan.Zero)
{
_utcAbsExp = _utcCreated + _slidingExp;
}
else
{
_utcAbsExp = absExp.UtcDateTime;
}
_expiresEntryRef = ExpiresEntryRef.INVALID;
_expiresBucket = 0xff;
_usageEntryRef = UsageEntryRef.INVALID;
if (priority == CacheItemPriority.NotRemovable)
{
_usageBucket = 0xff;
}
else
{
_usageBucket = 0;
}
_callback = removedCallback;
if (dependencies != null)
{
_fields = new SeldomUsedFields();
_fields._dependencies = dependencies;
_fields._cache = cache;
}
}
internal void RemoveCacheEntry(MemoryCacheEntry cacheEntry)
{
lock (this)
{
UsageEntryRef usageEntryRef = cacheEntry.UsageEntryRef;
if (!usageEntryRef.IsInvalid)
{
UsageEntry[] entryArray = this._pages[usageEntryRef.PageIndex]._entries;
int index = usageEntryRef.Ref1Index;
cacheEntry.UsageEntryRef = UsageEntryRef.INVALID;
entryArray[index]._cacheEntry = null;
this.RemoveEntryFromLastRefList(usageEntryRef);
this.AddUsageEntryToFreeList(usageEntryRef);
this.Reduce();
}
}
}
private void AddUsageEntryToFreeList(UsageEntryRef entryRef)
{
UsageEntry[] entryArray = this._pages[entryRef.PageIndex]._entries;
int index = entryRef.Ref1Index;
entryArray[index]._utcDate = DateTime.MinValue;
entryArray[index]._ref1._prev = UsageEntryRef.INVALID;
entryArray[index]._ref2._next = UsageEntryRef.INVALID;
entryArray[index]._ref2._prev = UsageEntryRef.INVALID;
entryArray[index]._ref1._next = entryArray[0]._ref1._next;
entryArray[0]._ref1._next = entryRef;
this._cEntriesInUse--;
int pageIndex = entryRef.PageIndex;
entryArray[0]._cFree++;
if (entryArray[0]._cFree == 1)
{
this.AddToListHead(pageIndex, ref this._freeEntryList);
}
else if (entryArray[0]._cFree == 0x7f)
{
this.RemovePage(pageIndex);
}
}
internal int FlushUnderUsedItems(int maxFlush, bool force)
{
UsageEntry[] entryArray;
int num;
UsageEntryRef ref6;
UsageEntryRef ref7;
if (this._cEntriesInUse == 0)
{
return 0;
}
UsageEntryRef iNVALID = UsageEntryRef.INVALID;
int num2 = 0;
try
{
this._cacheUsage.MemoryCacheStore.BlockInsert();
lock (this)
{
UsageEntryRef ref4;
if (this._cEntriesInUse == 0)
{
return 0;
}
DateTime utcNow = DateTime.UtcNow;
for (UsageEntryRef ref3 = this._lastRefTail; (this._cEntriesInFlush < maxFlush) && !ref3.IsInvalid; ref3 = ref4)
{
for (ref4 = this._pages[ref3.PageIndex]._entries[ref3.Ref2Index]._ref2._prev; ref4.IsRef1; ref4 = this._pages[ref4.PageIndex]._entries[ref4.Ref1Index]._ref1._prev)
{
}
entryArray = this._pages[ref3.PageIndex]._entries;
num = ref3.Ref2Index;
if (!force)
{
DateTime time = entryArray[num]._utcDate;
if (((utcNow - time) <= CacheUsage.NEWADD_INTERVAL) && (utcNow >= time))
{
continue;
}
}
UsageEntryRef entryRef = new UsageEntryRef(ref3.PageIndex, ref3.Ref2Index);
entryArray[num]._cacheEntry.UsageEntryRef = UsageEntryRef.INVALID;
this.RemoveEntryFromLastRefList(entryRef);
entryArray[num]._ref1._next = iNVALID;
iNVALID = entryRef;
num2++;
this._cEntriesInFlush++;
}
if (num2 == 0)
{
return 0;
}
this._blockReduce = true;
}
}
finally
{
this._cacheUsage.MemoryCacheStore.UnblockInsert();
}
MemoryCacheStore memoryCacheStore = this._cacheUsage.MemoryCacheStore;
for (ref6 = iNVALID; !ref6.IsInvalid; ref6 = ref7)
{
entryArray = this._pages[ref6.PageIndex]._entries;
num = ref6.Ref1Index;
ref7 = entryArray[num]._ref1._next;
MemoryCacheEntry key = entryArray[num]._cacheEntry;
entryArray[num]._cacheEntry = null;
memoryCacheStore.Remove(key, key, CacheEntryRemovedReason.Evicted);
}
try
{
this._cacheUsage.MemoryCacheStore.BlockInsert();
lock (this)
{
for (ref6 = iNVALID; !ref6.IsInvalid; ref6 = ref7)
{
entryArray = this._pages[ref6.PageIndex]._entries;
num = ref6.Ref1Index;
ref7 = entryArray[num]._ref1._next;
this._cEntriesInFlush--;
this.AddUsageEntryToFreeList(ref6);
}
this._blockReduce = false;
this.Reduce();
}
}
finally
{
this._cacheUsage.MemoryCacheStore.UnblockInsert();
}
return num2;
}
internal void AddCacheEntry(MemoryCacheEntry cacheEntry)
{
lock (this)
{
if (this._freeEntryList._head == -1)
{
this.Expand();
}
UsageEntryRef freeUsageEntry = this.GetFreeUsageEntry();
UsageEntryRef ref3 = new UsageEntryRef(freeUsageEntry.PageIndex, -freeUsageEntry.Ref1Index);
cacheEntry.UsageEntryRef = freeUsageEntry;
UsageEntry[] entryArray = this._pages[freeUsageEntry.PageIndex]._entries;
int index = freeUsageEntry.Ref1Index;
entryArray[index]._cacheEntry = cacheEntry;
entryArray[index]._utcDate = DateTime.UtcNow;
entryArray[index]._ref1._prev = UsageEntryRef.INVALID;
entryArray[index]._ref2._next = this._addRef2Head;
if (this._lastRefHead.IsInvalid)
{
entryArray[index]._ref1._next = ref3;
entryArray[index]._ref2._prev = freeUsageEntry;
this._lastRefTail = ref3;
}
else
{
UsageEntryRef iNVALID;
UsageEntryRef ref5;
entryArray[index]._ref1._next = this._lastRefHead;
if (this._lastRefHead.IsRef1)
{
this._pages[this._lastRefHead.PageIndex]._entries[this._lastRefHead.Ref1Index]._ref1._prev = freeUsageEntry;
}
else if (this._lastRefHead.IsRef2)
{
this._pages[this._lastRefHead.PageIndex]._entries[this._lastRefHead.Ref2Index]._ref2._prev = freeUsageEntry;
}
else
{
this._lastRefTail = freeUsageEntry;
}
if (this._addRef2Head.IsInvalid)
{
ref5 = this._lastRefTail;
iNVALID = UsageEntryRef.INVALID;
}
else
{
ref5 = this._pages[this._addRef2Head.PageIndex]._entries[this._addRef2Head.Ref2Index]._ref2._prev;
iNVALID = this._addRef2Head;
}
entryArray[index]._ref2._prev = ref5;
if (ref5.IsRef1)
{
this._pages[ref5.PageIndex]._entries[ref5.Ref1Index]._ref1._next = ref3;
}
else if (ref5.IsRef2)
{
this._pages[ref5.PageIndex]._entries[ref5.Ref2Index]._ref2._next = ref3;
}
else
{
this._lastRefHead = ref3;
}
if (iNVALID.IsRef1)
{
this._pages[iNVALID.PageIndex]._entries[iNVALID.Ref1Index]._ref1._prev = ref3;
}
else if (iNVALID.IsRef2)
{
this._pages[iNVALID.PageIndex]._entries[iNVALID.Ref2Index]._ref2._prev = ref3;
}
else
{
this._lastRefTail = ref3;
}
}
this._lastRefHead = freeUsageEntry;
this._addRef2Head = ref3;
this._cEntriesInUse++;
}
}
internal void UpdateCacheEntry(MemoryCacheEntry cacheEntry)
{
lock (this)
{
UsageEntryRef usageEntryRef = cacheEntry.UsageEntryRef;
if (!usageEntryRef.IsInvalid)
{
UsageEntry[] entryArray = this._pages[usageEntryRef.PageIndex]._entries;
int index = usageEntryRef.Ref1Index;
UsageEntryRef ref3 = new UsageEntryRef(usageEntryRef.PageIndex, -usageEntryRef.Ref1Index);
UsageEntryRef ref4 = entryArray[index]._ref2._prev;
UsageEntryRef ref5 = entryArray[index]._ref2._next;
if (ref4.IsRef1)
{
this._pages[ref4.PageIndex]._entries[ref4.Ref1Index]._ref1._next = ref5;
}
else if (ref4.IsRef2)
{
this._pages[ref4.PageIndex]._entries[ref4.Ref2Index]._ref2._next = ref5;
}
else
{
this._lastRefHead = ref5;
}
if (ref5.IsRef1)
{
this._pages[ref5.PageIndex]._entries[ref5.Ref1Index]._ref1._prev = ref4;
}
else if (ref5.IsRef2)
{
this._pages[ref5.PageIndex]._entries[ref5.Ref2Index]._ref2._prev = ref4;
}
else
{
this._lastRefTail = ref4;
}
if (this._addRef2Head == ref3)
{
this._addRef2Head = ref5;
}
entryArray[index]._ref2 = entryArray[index]._ref1;
ref4 = entryArray[index]._ref2._prev;
ref5 = entryArray[index]._ref2._next;
if (ref4.IsRef1)
{
this._pages[ref4.PageIndex]._entries[ref4.Ref1Index]._ref1._next = ref3;
}
else if (ref4.IsRef2)
{
this._pages[ref4.PageIndex]._entries[ref4.Ref2Index]._ref2._next = ref3;
}
else
{
this._lastRefHead = ref3;
}
if (ref5.IsRef1)
{
this._pages[ref5.PageIndex]._entries[ref5.Ref1Index]._ref1._prev = ref3;
}
else if (ref5.IsRef2)
{
this._pages[ref5.PageIndex]._entries[ref5.Ref2Index]._ref2._prev = ref3;
}
else
{
this._lastRefTail = ref3;
}
entryArray[index]._ref1._prev = UsageEntryRef.INVALID;
entryArray[index]._ref1._next = this._lastRefHead;
if (this._lastRefHead.IsRef1)
{
this._pages[this._lastRefHead.PageIndex]._entries[this._lastRefHead.Ref1Index]._ref1._prev = usageEntryRef;
}
else if (this._lastRefHead.IsRef2)
{
this._pages[this._lastRefHead.PageIndex]._entries[this._lastRefHead.Ref2Index]._ref2._prev = usageEntryRef;
}
else
{
this._lastRefTail = usageEntryRef;
}
this._lastRefHead = usageEntryRef;
}
}
}
private void AddUsageEntryToFreeList(UsageEntryRef entryRef)
{
UsageEntry[] entryArray = this._pages[entryRef.PageIndex]._entries;
int index = entryRef.Ref1Index;
entryArray[index]._utcDate = DateTime.MinValue;
entryArray[index]._ref1._prev = UsageEntryRef.INVALID;
entryArray[index]._ref2._next = UsageEntryRef.INVALID;
entryArray[index]._ref2._prev = UsageEntryRef.INVALID;
entryArray[index]._ref1._next = entryArray[0]._ref1._next;
entryArray[0]._ref1._next = entryRef;
this._cEntriesInUse--;
int pageIndex = entryRef.PageIndex;
entryArray[0]._cFree++;
if (entryArray[0]._cFree == 1)
{
this.AddToListHead(pageIndex, ref this._freeEntryList);
}
else if (entryArray[0]._cFree == 0x7f)
{
this.RemovePage(pageIndex);
}
}
private void Reduce()
{
if (_cEntriesInUse >= _minEntriesInUse || _blockReduce)
{
return;
}
Debug.Assert(_freeEntryList._head != -1, "_freeEntryList._head != -1");
Debug.Assert(_freeEntryList._tail != -1, "_freeEntryList._tail != -1");
Debug.Assert(_freeEntryList._head != _freeEntryList._tail, "_freeEntryList._head != _freeEntryList._tail");
int meanFree = (int)(NUM_ENTRIES - (NUM_ENTRIES * MIN_LOAD_FACTOR));
int pageIndexLast = _freeEntryList._tail;
int pageIndexCurrent = _freeEntryList._head;
int pageIndexNext;
UsageEntry[] entries;
for (; ;)
{
pageIndexNext = (_pages[(pageIndexCurrent)]._pageNext);
if ((((_pages[(pageIndexCurrent)]._entries))[0]._cFree) > meanFree)
{
MoveToListTail(pageIndexCurrent, ref _freeEntryList);
}
else
{
MoveToListHead(pageIndexCurrent, ref _freeEntryList);
}
if (pageIndexCurrent == pageIndexLast)
{
break;
}
pageIndexCurrent = pageIndexNext;
}
for (; ;)
{
if (_freeEntryList._tail == -1)
{
break;
}
entries = (_pages[(_freeEntryList._tail)]._entries);
Debug.Assert(((entries)[0]._cFree) > 0, "FreeEntryCount(entries) > 0");
int availableFreeEntries = (_cPagesInUse * NUM_ENTRIES) - ((entries)[0]._cFree) - _cEntriesInUse;
if (availableFreeEntries < (NUM_ENTRIES - ((entries)[0]._cFree)))
{
break;
}
for (int i = 1; i < entries.Length; i++)
{
if (entries[i]._cacheEntry == null)
{
continue;
}
Debug.Assert(_freeEntryList._head != _freeEntryList._tail, "_freeEntryList._head != _freeEntryList._tail");
UsageEntryRef newRef1 = GetFreeUsageEntry();
UsageEntryRef newRef2 = (new UsageEntryRef((newRef1).PageIndex, -(newRef1).Ref1Index));
Debug.Assert(newRef1.PageIndex != _freeEntryList._tail, "newRef1.PageIndex != _freeEntryList._tail");
UsageEntryRef oldRef1 = new UsageEntryRef(_freeEntryList._tail, i);
UsageEntryRef oldRef2 = (new UsageEntryRef((oldRef1).PageIndex, -(oldRef1).Ref1Index));
MemoryCacheEntry cacheEntry = entries[i]._cacheEntry;
Debug.Assert(cacheEntry.UsageEntryRef == oldRef1, "cacheEntry.UsageEntryRef == oldRef1");
cacheEntry.UsageEntryRef = newRef1;
UsageEntry[] newEntries = (_pages[(newRef1.PageIndex)]._entries);
newEntries[newRef1.Ref1Index] = entries[i];
((entries)[0]._cFree)++;
UsageEntryRef prev = newEntries[newRef1.Ref1Index]._ref1._prev;
Debug.Assert(prev != oldRef2, "prev != oldRef2");
UsageEntryRef next = newEntries[newRef1.Ref1Index]._ref1._next;
if (next == oldRef2)
{
next = newRef2;
}
{ if ((prev).IsRef1)
{
(_pages[((prev).PageIndex)]._entries)[(prev).Ref1Index]._ref1._next = (newRef1);
}
else if ((prev).IsRef2)
{
(_pages[((prev).PageIndex)]._entries)[(prev).Ref2Index]._ref2._next = (newRef1);
}
else
{
_lastRefHead = (newRef1);
} };
{ if ((next).IsRef1)
{
(_pages[((next).PageIndex)]._entries)[(next).Ref1Index]._ref1._prev = (newRef1);
}
else if ((next).IsRef2)
{
(_pages[((next).PageIndex)]._entries)[(next).Ref2Index]._ref2._prev = (newRef1);
}
else
{
_lastRefTail = (newRef1);
} };
prev = newEntries[newRef1.Ref1Index]._ref2._prev;
if (prev == oldRef1)
{
prev = newRef1;
}
next = newEntries[newRef1.Ref1Index]._ref2._next;
Debug.Assert(next != oldRef1, "next != oldRef1");
{ if ((prev).IsRef1)
{
(_pages[((prev).PageIndex)]._entries)[(prev).Ref1Index]._ref1._next = (newRef2);
}
else if ((prev).IsRef2)
{
(_pages[((prev).PageIndex)]._entries)[(prev).Ref2Index]._ref2._next = (newRef2);
}
else
{
_lastRefHead = (newRef2);
} };
{ if ((next).IsRef1)
{
(_pages[((next).PageIndex)]._entries)[(next).Ref1Index]._ref1._prev = (newRef2);
}
else if ((next).IsRef2)
{
(_pages[((next).PageIndex)]._entries)[(next).Ref2Index]._ref2._prev = (newRef2);
}
else
{
_lastRefTail = (newRef2);
} };
if (_addRef2Head == oldRef2)
{
_addRef2Head = newRef2;
}
}
RemovePage(_freeEntryList._tail);
}
}
private void RemoveEntryFromLastRefList(UsageEntryRef entryRef)
{
UsageEntry[] entryArray = this._pages[entryRef.PageIndex]._entries;
int index = entryRef.Ref1Index;
UsageEntryRef ref2 = entryArray[index]._ref1._prev;
UsageEntryRef ref3 = entryArray[index]._ref1._next;
if (ref2.IsRef1)
{
this._pages[ref2.PageIndex]._entries[ref2.Ref1Index]._ref1._next = ref3;
}
else if (ref2.IsRef2)
{
this._pages[ref2.PageIndex]._entries[ref2.Ref2Index]._ref2._next = ref3;
}
else
{
this._lastRefHead = ref3;
}
if (ref3.IsRef1)
{
this._pages[ref3.PageIndex]._entries[ref3.Ref1Index]._ref1._prev = ref2;
}
else if (ref3.IsRef2)
{
this._pages[ref3.PageIndex]._entries[ref3.Ref2Index]._ref2._prev = ref2;
}
else
{
this._lastRefTail = ref2;
}
ref2 = entryArray[index]._ref2._prev;
ref3 = entryArray[index]._ref2._next;
UsageEntryRef ref4 = new UsageEntryRef(entryRef.PageIndex, -entryRef.Ref1Index);
if (ref2.IsRef1)
{
this._pages[ref2.PageIndex]._entries[ref2.Ref1Index]._ref1._next = ref3;
}
else if (ref2.IsRef2)
{
this._pages[ref2.PageIndex]._entries[ref2.Ref2Index]._ref2._next = ref3;
}
else
{
this._lastRefHead = ref3;
}
if (ref3.IsRef1)
{
this._pages[ref3.PageIndex]._entries[ref3.Ref1Index]._ref1._prev = ref2;
}
else if (ref3.IsRef2)
{
this._pages[ref3.PageIndex]._entries[ref3.Ref2Index]._ref2._prev = ref2;
}
else
{
this._lastRefTail = ref2;
}
if (this._addRef2Head == ref4)
{
this._addRef2Head = ref3;
}
}
internal void AddCacheEntry(MemoryCacheEntry cacheEntry)
{
lock (this)
{
if (this._freeEntryList._head == -1)
{
this.Expand();
}
UsageEntryRef freeUsageEntry = this.GetFreeUsageEntry();
UsageEntryRef ref3 = new UsageEntryRef(freeUsageEntry.PageIndex, -freeUsageEntry.Ref1Index);
cacheEntry.UsageEntryRef = freeUsageEntry;
UsageEntry[] entryArray = this._pages[freeUsageEntry.PageIndex]._entries;
int index = freeUsageEntry.Ref1Index;
entryArray[index]._cacheEntry = cacheEntry;
entryArray[index]._utcDate = DateTime.UtcNow;
entryArray[index]._ref1._prev = UsageEntryRef.INVALID;
entryArray[index]._ref2._next = this._addRef2Head;
if (this._lastRefHead.IsInvalid)
{
entryArray[index]._ref1._next = ref3;
entryArray[index]._ref2._prev = freeUsageEntry;
this._lastRefTail = ref3;
}
else
{
UsageEntryRef iNVALID;
UsageEntryRef ref5;
entryArray[index]._ref1._next = this._lastRefHead;
if (this._lastRefHead.IsRef1)
{
this._pages[this._lastRefHead.PageIndex]._entries[this._lastRefHead.Ref1Index]._ref1._prev = freeUsageEntry;
}
else if (this._lastRefHead.IsRef2)
{
this._pages[this._lastRefHead.PageIndex]._entries[this._lastRefHead.Ref2Index]._ref2._prev = freeUsageEntry;
}
else
{
this._lastRefTail = freeUsageEntry;
}
if (this._addRef2Head.IsInvalid)
{
ref5 = this._lastRefTail;
iNVALID = UsageEntryRef.INVALID;
}
else
{
ref5 = this._pages[this._addRef2Head.PageIndex]._entries[this._addRef2Head.Ref2Index]._ref2._prev;
iNVALID = this._addRef2Head;
}
entryArray[index]._ref2._prev = ref5;
if (ref5.IsRef1)
{
this._pages[ref5.PageIndex]._entries[ref5.Ref1Index]._ref1._next = ref3;
}
else if (ref5.IsRef2)
{
this._pages[ref5.PageIndex]._entries[ref5.Ref2Index]._ref2._next = ref3;
}
else
{
this._lastRefHead = ref3;
}
if (iNVALID.IsRef1)
{
this._pages[iNVALID.PageIndex]._entries[iNVALID.Ref1Index]._ref1._prev = ref3;
}
else if (iNVALID.IsRef2)
{
this._pages[iNVALID.PageIndex]._entries[iNVALID.Ref2Index]._ref2._prev = ref3;
}
else
{
this._lastRefTail = ref3;
}
}
this._lastRefHead = freeUsageEntry;
this._addRef2Head = ref3;
this._cEntriesInUse++;
}
}
private void Reduce()
{
int num4;
if ((this._cEntriesInUse >= this._minEntriesInUse) || this._blockReduce)
{
return;
}
int num = 0x3f;
int num2 = this._freeEntryList._tail;
int index = this._freeEntryList._head;
Label_0032:
num4 = this._pages[index]._pageNext;
if (this._pages[index]._entries[0]._cFree > num)
{
this.MoveToListTail(index, ref this._freeEntryList);
}
else
{
this.MoveToListHead(index, ref this._freeEntryList);
}
if (index != num2)
{
index = num4;
goto Label_0032;
}
while (this._freeEntryList._tail != -1)
{
UsageEntry[] entryArray = this._pages[this._freeEntryList._tail]._entries;
int num5 = ((this._cPagesInUse * 0x7f) - entryArray[0]._cFree) - this._cEntriesInUse;
if (num5 < (0x7f - entryArray[0]._cFree))
{
return;
}
for (int i = 1; i < entryArray.Length; i++)
{
if (entryArray[i]._cacheEntry != null)
{
UsageEntryRef freeUsageEntry = this.GetFreeUsageEntry();
UsageEntryRef ref3 = new UsageEntryRef(freeUsageEntry.PageIndex, -freeUsageEntry.Ref1Index);
UsageEntryRef ref4 = new UsageEntryRef(this._freeEntryList._tail, i);
UsageEntryRef ref5 = new UsageEntryRef(ref4.PageIndex, -ref4.Ref1Index);
entryArray[i]._cacheEntry.UsageEntryRef = freeUsageEntry;
UsageEntry[] entryArray2 = this._pages[freeUsageEntry.PageIndex]._entries;
entryArray2[freeUsageEntry.Ref1Index] = entryArray[i];
entryArray[0]._cFree++;
UsageEntryRef ref6 = entryArray2[freeUsageEntry.Ref1Index]._ref1._prev;
UsageEntryRef ref7 = entryArray2[freeUsageEntry.Ref1Index]._ref1._next;
if (ref7 == ref5)
{
ref7 = ref3;
}
if (ref6.IsRef1)
{
this._pages[ref6.PageIndex]._entries[ref6.Ref1Index]._ref1._next = freeUsageEntry;
}
else if (ref6.IsRef2)
{
this._pages[ref6.PageIndex]._entries[ref6.Ref2Index]._ref2._next = freeUsageEntry;
}
else
{
this._lastRefHead = freeUsageEntry;
}
if (ref7.IsRef1)
{
this._pages[ref7.PageIndex]._entries[ref7.Ref1Index]._ref1._prev = freeUsageEntry;
}
else if (ref7.IsRef2)
{
this._pages[ref7.PageIndex]._entries[ref7.Ref2Index]._ref2._prev = freeUsageEntry;
}
else
{
this._lastRefTail = freeUsageEntry;
}
ref6 = entryArray2[freeUsageEntry.Ref1Index]._ref2._prev;
if (ref6 == ref4)
{
ref6 = freeUsageEntry;
}
ref7 = entryArray2[freeUsageEntry.Ref1Index]._ref2._next;
if (ref6.IsRef1)
{
this._pages[ref6.PageIndex]._entries[ref6.Ref1Index]._ref1._next = ref3;
}
else if (ref6.IsRef2)
{
this._pages[ref6.PageIndex]._entries[ref6.Ref2Index]._ref2._next = ref3;
}
else
{
this._lastRefHead = ref3;
}
if (ref7.IsRef1)
{
this._pages[ref7.PageIndex]._entries[ref7.Ref1Index]._ref1._prev = ref3;
}
else if (ref7.IsRef2)
{
this._pages[ref7.PageIndex]._entries[ref7.Ref2Index]._ref2._prev = ref3;
}
else
{
this._lastRefTail = ref3;
}
if (this._addRef2Head == ref5)
{
this._addRef2Head = ref3;
}
}
}
this.RemovePage(this._freeEntryList._tail);
}
return;
}
internal void UpdateCacheEntry(MemoryCacheEntry cacheEntry)
{
lock (this)
{
UsageEntryRef usageEntryRef = cacheEntry.UsageEntryRef;
if (!usageEntryRef.IsInvalid)
{
UsageEntry[] entryArray = this._pages[usageEntryRef.PageIndex]._entries;
int index = usageEntryRef.Ref1Index;
UsageEntryRef ref3 = new UsageEntryRef(usageEntryRef.PageIndex, -usageEntryRef.Ref1Index);
UsageEntryRef ref4 = entryArray[index]._ref2._prev;
UsageEntryRef ref5 = entryArray[index]._ref2._next;
if (ref4.IsRef1)
{
this._pages[ref4.PageIndex]._entries[ref4.Ref1Index]._ref1._next = ref5;
}
else if (ref4.IsRef2)
{
this._pages[ref4.PageIndex]._entries[ref4.Ref2Index]._ref2._next = ref5;
}
else
{
this._lastRefHead = ref5;
}
if (ref5.IsRef1)
{
this._pages[ref5.PageIndex]._entries[ref5.Ref1Index]._ref1._prev = ref4;
}
else if (ref5.IsRef2)
{
this._pages[ref5.PageIndex]._entries[ref5.Ref2Index]._ref2._prev = ref4;
}
else
{
this._lastRefTail = ref4;
}
if (this._addRef2Head == ref3)
{
this._addRef2Head = ref5;
}
entryArray[index]._ref2 = entryArray[index]._ref1;
ref4 = entryArray[index]._ref2._prev;
ref5 = entryArray[index]._ref2._next;
if (ref4.IsRef1)
{
this._pages[ref4.PageIndex]._entries[ref4.Ref1Index]._ref1._next = ref3;
}
else if (ref4.IsRef2)
{
this._pages[ref4.PageIndex]._entries[ref4.Ref2Index]._ref2._next = ref3;
}
else
{
this._lastRefHead = ref3;
}
if (ref5.IsRef1)
{
this._pages[ref5.PageIndex]._entries[ref5.Ref1Index]._ref1._prev = ref3;
}
else if (ref5.IsRef2)
{
this._pages[ref5.PageIndex]._entries[ref5.Ref2Index]._ref2._prev = ref3;
}
else
{
this._lastRefTail = ref3;
}
entryArray[index]._ref1._prev = UsageEntryRef.INVALID;
entryArray[index]._ref1._next = this._lastRefHead;
if (this._lastRefHead.IsRef1)
{
this._pages[this._lastRefHead.PageIndex]._entries[this._lastRefHead.Ref1Index]._ref1._prev = usageEntryRef;
}
else if (this._lastRefHead.IsRef2)
{
this._pages[this._lastRefHead.PageIndex]._entries[this._lastRefHead.Ref2Index]._ref2._prev = usageEntryRef;
}
else
{
this._lastRefTail = usageEntryRef;
}
this._lastRefHead = usageEntryRef;
}
}
}
static UsageEntryRef()
{
INVALID = new UsageEntryRef(0, 0);
}
private void Reduce()
{
int num4;
if ((this._cEntriesInUse >= this._minEntriesInUse) || this._blockReduce)
{
return;
}
int num = 0x3f;
int num2 = this._freeEntryList._tail;
int index = this._freeEntryList._head;
Label_0032:
num4 = this._pages[index]._pageNext;
if (this._pages[index]._entries[0]._cFree > num)
{
this.MoveToListTail(index, ref this._freeEntryList);
}
else
{
this.MoveToListHead(index, ref this._freeEntryList);
}
if (index != num2)
{
index = num4;
goto Label_0032;
}
while (this._freeEntryList._tail != -1)
{
UsageEntry[] entryArray = this._pages[this._freeEntryList._tail]._entries;
int num5 = ((this._cPagesInUse * 0x7f) - entryArray[0]._cFree) - this._cEntriesInUse;
if (num5 < (0x7f - entryArray[0]._cFree))
{
return;
}
for (int i = 1; i < entryArray.Length; i++)
{
if (entryArray[i]._cacheEntry != null)
{
UsageEntryRef freeUsageEntry = this.GetFreeUsageEntry();
UsageEntryRef ref3 = new UsageEntryRef(freeUsageEntry.PageIndex, -freeUsageEntry.Ref1Index);
UsageEntryRef ref4 = new UsageEntryRef(this._freeEntryList._tail, i);
UsageEntryRef ref5 = new UsageEntryRef(ref4.PageIndex, -ref4.Ref1Index);
entryArray[i]._cacheEntry.UsageEntryRef = freeUsageEntry;
UsageEntry[] entryArray2 = this._pages[freeUsageEntry.PageIndex]._entries;
entryArray2[freeUsageEntry.Ref1Index] = entryArray[i];
entryArray[0]._cFree++;
UsageEntryRef ref6 = entryArray2[freeUsageEntry.Ref1Index]._ref1._prev;
UsageEntryRef ref7 = entryArray2[freeUsageEntry.Ref1Index]._ref1._next;
if (ref7 == ref5)
{
ref7 = ref3;
}
if (ref6.IsRef1)
{
this._pages[ref6.PageIndex]._entries[ref6.Ref1Index]._ref1._next = freeUsageEntry;
}
else if (ref6.IsRef2)
{
this._pages[ref6.PageIndex]._entries[ref6.Ref2Index]._ref2._next = freeUsageEntry;
}
else
{
this._lastRefHead = freeUsageEntry;
}
if (ref7.IsRef1)
{
this._pages[ref7.PageIndex]._entries[ref7.Ref1Index]._ref1._prev = freeUsageEntry;
}
else if (ref7.IsRef2)
{
this._pages[ref7.PageIndex]._entries[ref7.Ref2Index]._ref2._prev = freeUsageEntry;
}
else
{
this._lastRefTail = freeUsageEntry;
}
ref6 = entryArray2[freeUsageEntry.Ref1Index]._ref2._prev;
if (ref6 == ref4)
{
ref6 = freeUsageEntry;
}
ref7 = entryArray2[freeUsageEntry.Ref1Index]._ref2._next;
if (ref6.IsRef1)
{
this._pages[ref6.PageIndex]._entries[ref6.Ref1Index]._ref1._next = ref3;
}
else if (ref6.IsRef2)
{
this._pages[ref6.PageIndex]._entries[ref6.Ref2Index]._ref2._next = ref3;
}
else
{
this._lastRefHead = ref3;
}
if (ref7.IsRef1)
{
this._pages[ref7.PageIndex]._entries[ref7.Ref1Index]._ref1._prev = ref3;
}
else if (ref7.IsRef2)
{
this._pages[ref7.PageIndex]._entries[ref7.Ref2Index]._ref2._prev = ref3;
}
else
{
this._lastRefTail = ref3;
}
if (this._addRef2Head == ref5)
{
this._addRef2Head = ref3;
}
}
}
this.RemovePage(this._freeEntryList._tail);
}
return;
}
internal int FlushUnderUsedItems(int maxFlush, bool force)
{
if (_cEntriesInUse == 0)
{
return(0);
}
Debug.Assert(maxFlush > 0, "maxFlush is not greater than 0, instead is " + maxFlush);
Debug.Assert(_cEntriesInFlush == 0, "_cEntriesInFlush == 0");
UsageEntryRef inFlushHead = UsageEntryRef.INVALID;
UsageEntryRef prev, prevNext;
DateTime utcDate;
UsageEntry[] entries;
int entryIndex;
MemoryCacheEntry cacheEntry;
int flushed = 0;
try
{
_cacheUsage.MemoryCacheStore.BlockInsert();
lock (this)
{
Debug.Assert(_blockReduce == false, "_blockReduce == false");
if (_cEntriesInUse == 0)
{
return(0);
}
DateTime utcNow = DateTime.UtcNow;
for (prev = _lastRefTail; _cEntriesInFlush < maxFlush && !prev.IsInvalid; prev = prevNext)
{
Debug.Assert(_cEntriesInUse > 0, "_cEntriesInUse > 0");
prevNext = (_pages[(prev.PageIndex)]._entries)[prev.Ref2Index]._ref2._prev;
while (prevNext.IsRef1)
{
prevNext = (_pages[(prevNext.PageIndex)]._entries)[prevNext.Ref1Index]._ref1._prev;
}
entries = (_pages[(prev.PageIndex)]._entries);
entryIndex = prev.Ref2Index;
if (!force)
{
utcDate = entries[entryIndex]._utcDate;
Debug.Assert(utcDate != DateTime.MinValue, "utcDate != DateTime.MinValue");
if (utcNow - utcDate <= CacheUsage.NEWADD_INTERVAL && utcNow >= utcDate)
{
continue;
}
}
UsageEntryRef prev1 = (new UsageEntryRef((prev).PageIndex, (prev).Ref2Index));
cacheEntry = entries[entryIndex]._cacheEntry;
Debug.Assert(cacheEntry.UsageEntryRef == prev1, "cacheEntry.UsageEntryRef == prev1");
Dbg.Trace("CacheUsageFlushUnderUsedItem", "Flushing underused items, item=" + cacheEntry.Key + ", bucket=" + _bucket);
cacheEntry.UsageEntryRef = UsageEntryRef.INVALID;
RemoveEntryFromLastRefList(prev1);
entries[entryIndex]._ref1._next = inFlushHead;
inFlushHead = prev1;
flushed++;
_cEntriesInFlush++;
}
if (flushed == 0)
{
Dbg.Trace("CacheUsageFlushTotal", "Flush(" + maxFlush + "," + force + ") removed " + flushed +
" underused items; Time=" + DateTime.Now.ToString("o", CultureInfo.InvariantCulture));
return(0);
}
_blockReduce = true;
}
}
finally
{
_cacheUsage.MemoryCacheStore.UnblockInsert();
}
Debug.Assert(!inFlushHead.IsInvalid, "!inFlushHead.IsInvalid");
MemoryCacheStore cacheStore = _cacheUsage.MemoryCacheStore;
UsageEntryRef current = inFlushHead;
UsageEntryRef next;
while (!current.IsInvalid)
{
entries = (_pages[(current.PageIndex)]._entries);
entryIndex = current.Ref1Index;
next = entries[entryIndex]._ref1._next;
cacheEntry = entries[entryIndex]._cacheEntry;
entries[entryIndex]._cacheEntry = null;
Debug.Assert(cacheEntry.UsageEntryRef.IsInvalid, "cacheEntry.UsageEntryRef.IsInvalid");
cacheStore.Remove(cacheEntry, cacheEntry, CacheEntryRemovedReason.Evicted);
current = next;
}
try
{
_cacheUsage.MemoryCacheStore.BlockInsert();
lock (this)
{
current = inFlushHead;
while (!current.IsInvalid)
{
entries = (_pages[(current.PageIndex)]._entries);
entryIndex = current.Ref1Index;
next = entries[entryIndex]._ref1._next;
_cEntriesInFlush--;
AddUsageEntryToFreeList(current);
current = next;
}
Debug.Assert(_cEntriesInFlush == 0, "_cEntriesInFlush == 0");
_blockReduce = false;
Reduce();
Dbg.Trace("CacheUsageFlushTotal", "Flush(" + maxFlush + "," + force + ") removed " + flushed +
" underused items; Time=" + DateTime.Now.ToString("o", CultureInfo.InvariantCulture));
}
}
finally
{
_cacheUsage.MemoryCacheStore.UnblockInsert();
}
return(flushed);
}
internal void UpdateCacheEntry(MemoryCacheEntry cacheEntry)
{
lock (this)
{
UsageEntryRef entryRef = cacheEntry.UsageEntryRef;
if (entryRef.IsInvalid)
{
return;
}
UsageEntry[] entries = (_pages[(entryRef.PageIndex)]._entries);
int entryIndex = entryRef.Ref1Index;
UsageEntryRef entryRef2 = (new UsageEntryRef((entryRef).PageIndex, -(entryRef).Ref1Index));
UsageEntryRef prev = entries[entryIndex]._ref2._prev;
UsageEntryRef next = entries[entryIndex]._ref2._next;
{ if ((prev).IsRef1)
{
(_pages[((prev).PageIndex)]._entries)[(prev).Ref1Index]._ref1._next = (next);
}
else if ((prev).IsRef2)
{
(_pages[((prev).PageIndex)]._entries)[(prev).Ref2Index]._ref2._next = (next);
}
else
{
_lastRefHead = (next);
} };
{ if ((next).IsRef1)
{
(_pages[((next).PageIndex)]._entries)[(next).Ref1Index]._ref1._prev = (prev);
}
else if ((next).IsRef2)
{
(_pages[((next).PageIndex)]._entries)[(next).Ref2Index]._ref2._prev = (prev);
}
else
{
_lastRefTail = (prev);
} };
if (_addRef2Head == entryRef2)
{
_addRef2Head = next;
}
entries[entryIndex]._ref2 = entries[entryIndex]._ref1;
prev = entries[entryIndex]._ref2._prev;
next = entries[entryIndex]._ref2._next;
{ if ((prev).IsRef1)
{
(_pages[((prev).PageIndex)]._entries)[(prev).Ref1Index]._ref1._next = (entryRef2);
}
else if ((prev).IsRef2)
{
(_pages[((prev).PageIndex)]._entries)[(prev).Ref2Index]._ref2._next = (entryRef2);
}
else
{
_lastRefHead = (entryRef2);
} };
{ if ((next).IsRef1)
{
(_pages[((next).PageIndex)]._entries)[(next).Ref1Index]._ref1._prev = (entryRef2);
}
else if ((next).IsRef2)
{
(_pages[((next).PageIndex)]._entries)[(next).Ref2Index]._ref2._prev = (entryRef2);
}
else
{
_lastRefTail = (entryRef2);
} };
entries[entryIndex]._ref1._prev = UsageEntryRef.INVALID;
entries[entryIndex]._ref1._next = _lastRefHead;
{ if ((_lastRefHead).IsRef1)
{
(_pages[((_lastRefHead).PageIndex)]._entries)[(_lastRefHead).Ref1Index]._ref1._prev = (entryRef);
}
else if ((_lastRefHead).IsRef2)
{
(_pages[((_lastRefHead).PageIndex)]._entries)[(_lastRefHead).Ref2Index]._ref2._prev = (entryRef);
}
else
{
_lastRefTail = (entryRef);
} };
_lastRefHead = entryRef;
Dbg.Trace("CacheUsageUpdate",
"Updated item=" + cacheEntry.Key +
",_bucket=" + _bucket +
",ref=" + entryRef);
}
}
internal void AddCacheEntry(MemoryCacheEntry cacheEntry)
{
lock (this)
{
if (_freeEntryList._head == -1)
{
Expand();
}
UsageEntryRef freeRef1 = GetFreeUsageEntry();
UsageEntryRef freeRef2 = (new UsageEntryRef((freeRef1).PageIndex, -(freeRef1).Ref1Index));
Debug.Assert(cacheEntry.UsageEntryRef.IsInvalid, "cacheEntry.UsageEntryRef.IsInvalid");
cacheEntry.UsageEntryRef = freeRef1;
UsageEntry[] entries = (_pages[(freeRef1.PageIndex)]._entries);
int entryIndex = freeRef1.Ref1Index;
entries[entryIndex]._cacheEntry = cacheEntry;
entries[entryIndex]._utcDate = DateTime.UtcNow;
entries[entryIndex]._ref1._prev = UsageEntryRef.INVALID;
entries[entryIndex]._ref2._next = _addRef2Head;
if (_lastRefHead.IsInvalid)
{
entries[entryIndex]._ref1._next = freeRef2;
entries[entryIndex]._ref2._prev = freeRef1;
_lastRefTail = freeRef2;
}
else
{
entries[entryIndex]._ref1._next = _lastRefHead;
{ if ((_lastRefHead).IsRef1)
{
(_pages[((_lastRefHead).PageIndex)]._entries)[(_lastRefHead).Ref1Index]._ref1._prev = (freeRef1);
}
else if ((_lastRefHead).IsRef2)
{
(_pages[((_lastRefHead).PageIndex)]._entries)[(_lastRefHead).Ref2Index]._ref2._prev = (freeRef1);
}
else
{
_lastRefTail = (freeRef1);
} };
UsageEntryRef next, prev;
if (_addRef2Head.IsInvalid)
{
prev = _lastRefTail;
next = UsageEntryRef.INVALID;
}
else
{
prev = (_pages[(_addRef2Head.PageIndex)]._entries)[_addRef2Head.Ref2Index]._ref2._prev;
next = _addRef2Head;
}
entries[entryIndex]._ref2._prev = prev;
{ if ((prev).IsRef1)
{
(_pages[((prev).PageIndex)]._entries)[(prev).Ref1Index]._ref1._next = (freeRef2);
}
else if ((prev).IsRef2)
{
(_pages[((prev).PageIndex)]._entries)[(prev).Ref2Index]._ref2._next = (freeRef2);
}
else
{
_lastRefHead = (freeRef2);
} };
{ if ((next).IsRef1)
{
(_pages[((next).PageIndex)]._entries)[(next).Ref1Index]._ref1._prev = (freeRef2);
}
else if ((next).IsRef2)
{
(_pages[((next).PageIndex)]._entries)[(next).Ref2Index]._ref2._prev = (freeRef2);
}
else
{
_lastRefTail = (freeRef2);
} };
}
_lastRefHead = freeRef1;
_addRef2Head = freeRef2;
_cEntriesInUse++;
Dbg.Trace("CacheUsageAdd",
"Added item=" + cacheEntry.Key +
",_bucket=" + _bucket +
",ref=" + freeRef1);
}
}
private void RemoveEntryFromLastRefList(UsageEntryRef entryRef)
{
Debug.Assert(entryRef.IsRef1, "entryRef.IsRef1");
UsageEntry[] entries = (_pages[(entryRef.PageIndex)]._entries);
int entryIndex = entryRef.Ref1Index;
UsageEntryRef prev = entries[entryIndex]._ref1._prev;
UsageEntryRef next = entries[entryIndex]._ref1._next;
{ if ((prev).IsRef1)
{
(_pages[((prev).PageIndex)]._entries)[(prev).Ref1Index]._ref1._next = (next);
}
else if ((prev).IsRef2)
{
(_pages[((prev).PageIndex)]._entries)[(prev).Ref2Index]._ref2._next = (next);
}
else
{
_lastRefHead = (next);
} };
{ if ((next).IsRef1)
{
(_pages[((next).PageIndex)]._entries)[(next).Ref1Index]._ref1._prev = (prev);
}
else if ((next).IsRef2)
{
(_pages[((next).PageIndex)]._entries)[(next).Ref2Index]._ref2._prev = (prev);
}
else
{
_lastRefTail = (prev);
} };
prev = entries[entryIndex]._ref2._prev;
next = entries[entryIndex]._ref2._next;
UsageEntryRef entryRef2 = (new UsageEntryRef((entryRef).PageIndex, -(entryRef).Ref1Index));
{ if ((prev).IsRef1)
{
(_pages[((prev).PageIndex)]._entries)[(prev).Ref1Index]._ref1._next = (next);
}
else if ((prev).IsRef2)
{
(_pages[((prev).PageIndex)]._entries)[(prev).Ref2Index]._ref2._next = (next);
}
else
{
_lastRefHead = (next);
} };
{ if ((next).IsRef1)
{
(_pages[((next).PageIndex)]._entries)[(next).Ref1Index]._ref1._prev = (prev);
}
else if ((next).IsRef2)
{
(_pages[((next).PageIndex)]._entries)[(next).Ref2Index]._ref2._prev = (prev);
}
else
{
_lastRefTail = (prev);
} };
if (_addRef2Head == entryRef2)
{
_addRef2Head = next;
}
}
private void RemoveEntryFromLastRefList(UsageEntryRef entryRef)
{
UsageEntry[] entryArray = this._pages[entryRef.PageIndex]._entries;
int index = entryRef.Ref1Index;
UsageEntryRef ref2 = entryArray[index]._ref1._prev;
UsageEntryRef ref3 = entryArray[index]._ref1._next;
if (ref2.IsRef1)
{
this._pages[ref2.PageIndex]._entries[ref2.Ref1Index]._ref1._next = ref3;
}
else if (ref2.IsRef2)
{
this._pages[ref2.PageIndex]._entries[ref2.Ref2Index]._ref2._next = ref3;
}
else
{
this._lastRefHead = ref3;
}
if (ref3.IsRef1)
{
this._pages[ref3.PageIndex]._entries[ref3.Ref1Index]._ref1._prev = ref2;
}
else if (ref3.IsRef2)
{
this._pages[ref3.PageIndex]._entries[ref3.Ref2Index]._ref2._prev = ref2;
}
else
{
this._lastRefTail = ref2;
}
ref2 = entryArray[index]._ref2._prev;
ref3 = entryArray[index]._ref2._next;
UsageEntryRef ref4 = new UsageEntryRef(entryRef.PageIndex, -entryRef.Ref1Index);
if (ref2.IsRef1)
{
this._pages[ref2.PageIndex]._entries[ref2.Ref1Index]._ref1._next = ref3;
}
else if (ref2.IsRef2)
{
this._pages[ref2.PageIndex]._entries[ref2.Ref2Index]._ref2._next = ref3;
}
else
{
this._lastRefHead = ref3;
}
if (ref3.IsRef1)
{
this._pages[ref3.PageIndex]._entries[ref3.Ref1Index]._ref1._prev = ref2;
}
else if (ref3.IsRef2)
{
this._pages[ref3.PageIndex]._entries[ref3.Ref2Index]._ref2._prev = ref2;
}
else
{
this._lastRefTail = ref2;
}
if (this._addRef2Head == ref4)
{
this._addRef2Head = ref3;
}
}
internal int FlushUnderUsedItems(int maxFlush, bool force)
{
UsageEntry[] entryArray;
int num;
UsageEntryRef ref6;
UsageEntryRef ref7;
if (this._cEntriesInUse == 0)
{
return(0);
}
UsageEntryRef iNVALID = UsageEntryRef.INVALID;
int num2 = 0;
try
{
this._cacheUsage.MemoryCacheStore.BlockInsert();
lock (this)
{
UsageEntryRef ref4;
if (this._cEntriesInUse == 0)
{
return(0);
}
DateTime utcNow = DateTime.UtcNow;
for (UsageEntryRef ref3 = this._lastRefTail; (this._cEntriesInFlush < maxFlush) && !ref3.IsInvalid; ref3 = ref4)
{
for (ref4 = this._pages[ref3.PageIndex]._entries[ref3.Ref2Index]._ref2._prev; ref4.IsRef1; ref4 = this._pages[ref4.PageIndex]._entries[ref4.Ref1Index]._ref1._prev)
{
}
entryArray = this._pages[ref3.PageIndex]._entries;
num = ref3.Ref2Index;
if (!force)
{
DateTime time = entryArray[num]._utcDate;
if (((utcNow - time) <= CacheUsage.NEWADD_INTERVAL) && (utcNow >= time))
{
continue;
}
}
UsageEntryRef entryRef = new UsageEntryRef(ref3.PageIndex, ref3.Ref2Index);
entryArray[num]._cacheEntry.UsageEntryRef = UsageEntryRef.INVALID;
this.RemoveEntryFromLastRefList(entryRef);
entryArray[num]._ref1._next = iNVALID;
iNVALID = entryRef;
num2++;
this._cEntriesInFlush++;
}
if (num2 == 0)
{
return(0);
}
this._blockReduce = true;
}
}
finally
{
this._cacheUsage.MemoryCacheStore.UnblockInsert();
}
MemoryCacheStore memoryCacheStore = this._cacheUsage.MemoryCacheStore;
for (ref6 = iNVALID; !ref6.IsInvalid; ref6 = ref7)
{
entryArray = this._pages[ref6.PageIndex]._entries;
num = ref6.Ref1Index;
ref7 = entryArray[num]._ref1._next;
MemoryCacheEntry key = entryArray[num]._cacheEntry;
entryArray[num]._cacheEntry = null;
memoryCacheStore.Remove(key, key, CacheEntryRemovedReason.Evicted);
}
try
{
this._cacheUsage.MemoryCacheStore.BlockInsert();
lock (this)
{
for (ref6 = iNVALID; !ref6.IsInvalid; ref6 = ref7)
{
entryArray = this._pages[ref6.PageIndex]._entries;
num = ref6.Ref1Index;
ref7 = entryArray[num]._ref1._next;
this._cEntriesInFlush--;
this.AddUsageEntryToFreeList(ref6);
}
this._blockReduce = false;
this.Reduce();
}
}
finally
{
this._cacheUsage.MemoryCacheStore.UnblockInsert();
}
return(num2);
}
internal MemoryCacheEntry(String key,
Object value,
DateTimeOffset absExp,
TimeSpan slidingExp,
CacheItemPriority priority,
Collection<ChangeMonitor> dependencies,
CacheEntryRemovedCallback removedCallback,
MemoryCache cache) : base(key) {
if (value == null) {
throw new ArgumentNullException("value");
}
_utcCreated = DateTime.UtcNow;
_value = value;
_slidingExp = slidingExp;
if (_slidingExp > TimeSpan.Zero) {
_utcAbsExp = _utcCreated + _slidingExp;
}
else {
_utcAbsExp = absExp.UtcDateTime;
}
_expiresEntryRef = ExpiresEntryRef.INVALID;
_expiresBucket = 0xff;
_usageEntryRef = UsageEntryRef.INVALID;
if (priority == CacheItemPriority.NotRemovable) {
_usageBucket = 0xff;
}
else {
_usageBucket = 0;
}
_callback = removedCallback;
if (dependencies != null) {
_fields = new SeldomUsedFields();
_fields._dependencies = dependencies;
_fields._cache = cache;
}
}
static UsageEntryRef()
{
INVALID = new UsageEntryRef(0, 0);
}