protected override void FulfillInProgressFree()
{
m_storage.FreezeAllocations = true;
while (m_inProgressFreeBytes > 0 && m_cachePriority.Count > 0)
{
StorageItem storageItem = m_cachePriority.ExtractLRU();
storageItem.InQueue = InQueueState.None;
if (storageItem.Item != null && storageItem.PinCount == 0)
{
CacheRemoveValue(storageItem.Id);
int num = ItemSizes.SizeOf(storageItem);
storageItem.Flush(m_storage, m_offsetMap);
m_cacheSizeBytes -= num;
if (m_cacheSizeBytes < 0)
{
m_cacheSizeBytes = 0L;
}
m_inProgressFreeBytes -= num;
if (m_inProgressFreeBytes < 0)
{
m_inProgressFreeBytes = 0L;
}
}
}
m_storage.FreezeAllocations = false;
}
protected sealed override void FulfillInProgressFree()
{
int num = m_cachePriority.Count;
while (m_inProgressFreeBytes > 0 && num > 0)
{
num--;
ItemHolder itemHolder = m_cachePriority.Peek();
BaseReference reference = itemHolder.Reference;
if (reference.PinCount == 0)
{
m_cachePriority.ExtractLRU();
reference.InQueue = InQueueState.None;
if (itemHolder.Item != null)
{
UpdateStatsForRemovedItem(reference, ref m_inProgressFreeBytes);
CacheRemoveValue(reference.Id);
itemHolder.Item = null;
itemHolder.Reference = null;
reference.Item = null;
}
}
else
{
m_cachePriority.Bump(itemHolder);
}
}
if (m_inProgressFreeBytes <= 0)
{
return;
}
using (IDecumulator <BaseReference> decumulator = m_serializationQueue.GetDecumulator())
{
while (m_inProgressFreeBytes > 0 && decumulator.MoveNext())
{
BaseReference current = decumulator.Current;
decumulator.RemoveCurrent();
if (current.Item != null)
{
if (current.PinCount == 0)
{
UpdateStatsForRemovedItem(current, ref m_inProgressFreeBytes);
}
WriteItem(current);
if (current.PinCount > 0)
{
EnqueueItem(current);
CacheSetValue(current.Id, current);
}
}
}
}
}
