Ejemplo n.º 1
0
        private void RemoveCacheEntryNoLock(MemoryCacheEntry cacheEntry)
        {
            ExpiresEntryRef entryRef = cacheEntry.ExpiresEntryRef;

            if (cacheEntry.ExpiresBucket != _bucket || entryRef.IsInvalid)
            {
                return;
            }

            ExpiresEntry[] entries    = (_pages[(entryRef.PageIndex)]._entries);
            int            entryIndex = entryRef.Index;

            RemoveCount(entries[entryIndex]._utcExpires);

            cacheEntry.ExpiresBucket        = 0xff;
            cacheEntry.ExpiresEntryRef      = ExpiresEntryRef.INVALID;
            entries[entryIndex]._cacheEntry = null;

            AddExpiresEntryToFreeList(entryRef);

            if (_cEntriesInUse == 0)
            {
                ResetCounts(DateTime.UtcNow);
            }

            Reduce();

            Debug.WriteLine("CacheExpiresRemove",
                            "Removed item=" + cacheEntry.Key +
                            ",_bucket=" + _bucket +
                            ",ref=" + entryRef +
                            ",now=" + DateTime.Now.ToString("o", CultureInfo.InvariantCulture) +
                            ",expires=" + cacheEntry.UtcAbsExp.ToLocalTime());
        }
 internal void AddCacheEntry(MemoryCacheEntry cacheEntry)
 {
     lock (this)
     {
         if (((byte)(cacheEntry.State & (EntryState.AddedToCache | EntryState.AddingToCache))) != 0)
         {
             ExpiresEntryRef expiresEntryRef = cacheEntry.ExpiresEntryRef;
             if ((cacheEntry.ExpiresBucket == 0xff) && expiresEntryRef.IsInvalid)
             {
                 if (this._freeEntryList._head == -1)
                 {
                     this.Expand();
                 }
                 ExpiresEntryRef freeExpiresEntry = this.GetFreeExpiresEntry();
                 cacheEntry.ExpiresBucket   = this._bucket;
                 cacheEntry.ExpiresEntryRef = freeExpiresEntry;
                 ExpiresEntry[] entryArray = this._pages[freeExpiresEntry.PageIndex]._entries;
                 int            index      = freeExpiresEntry.Index;
                 entryArray[index]._cacheEntry = cacheEntry;
                 entryArray[index]._utcExpires = cacheEntry.UtcAbsExp;
                 this.AddCount(cacheEntry.UtcAbsExp);
                 this._cEntriesInUse++;
                 if (((byte)(cacheEntry.State & (EntryState.AddedToCache | EntryState.AddingToCache))) == 0)
                 {
                     this.RemoveCacheEntryNoLock(cacheEntry);
                 }
             }
         }
     }
 }
Ejemplo n.º 3
0
        internal void UtcUpdateCacheEntry(MemoryCacheEntry cacheEntry, DateTime utcExpires)
        {
            lock (this)
            {
                ExpiresEntryRef entryRef = cacheEntry.ExpiresEntryRef;
                if (cacheEntry.ExpiresBucket != _bucket || entryRef.IsInvalid)
                {
                    return;
                }

                ExpiresEntry[] entries    = (_pages[(entryRef.PageIndex)]._entries);
                int            entryIndex = entryRef.Index;

                Dbg.Assert(cacheEntry == entries[entryIndex]._cacheEntry);

                RemoveCount(entries[entryIndex]._utcExpires);
                AddCount(utcExpires);

                entries[entryIndex]._utcExpires = utcExpires;

                cacheEntry.UtcAbsExp = utcExpires;

                Dbg.Validate("CacheValidateExpires", this);
                Dbg.Trace("CacheExpiresUpdate", "Updated item " + cacheEntry.Key + " in bucket " + _bucket);
            }
        }
Ejemplo n.º 4
0
        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;
            }
        }
        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)
            {
                ExpiresEntry[] 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)
                    {
                        ExpiresEntryRef freeExpiresEntry = this.GetFreeExpiresEntry();
                        entryArray[i]._cacheEntry.ExpiresEntryRef = freeExpiresEntry;
                        this._pages[freeExpiresEntry.PageIndex]._entries[freeExpiresEntry.Index] = entryArray[i];
                        entryArray[0]._cFree++;
                    }
                }
                this.RemovePage(this._freeEntryList._tail);
            }
            return;
        }
Ejemplo n.º 6
0
        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 UtcUpdateCacheEntry(MemoryCacheEntry cacheEntry, DateTime utcExpires)
 {
     lock (this)
     {
         ExpiresEntryRef expiresEntryRef = cacheEntry.ExpiresEntryRef;
         if ((cacheEntry.ExpiresBucket == this._bucket) && !expiresEntryRef.IsInvalid)
         {
             ExpiresEntry[] entryArray = this._pages[expiresEntryRef.PageIndex]._entries;
             int            index      = expiresEntryRef.Index;
             this.RemoveCount(entryArray[index]._utcExpires);
             this.AddCount(utcExpires);
             entryArray[index]._utcExpires = utcExpires;
             cacheEntry.UtcAbsExp          = utcExpires;
         }
     }
 }
Ejemplo n.º 8
0
        internal void AddCacheEntry(MemoryCacheEntry cacheEntry)
        {
            lock (this)
            {
                if ((cacheEntry.State & (EntryState.AddedToCache | EntryState.AddingToCache)) == 0)
                {
                    return;
                }

                ExpiresEntryRef entryRef = cacheEntry.ExpiresEntryRef;
                Debug.Assert((cacheEntry.ExpiresBucket == 0xff) == entryRef.IsInvalid, "(cacheEntry.ExpiresBucket == 0xff) == entryRef.IsInvalid");
                if (cacheEntry.ExpiresBucket != 0xff || !entryRef.IsInvalid)
                {
                    return;
                }

                if (_freeEntryList._head == -1)
                {
                    Expand();
                }

                ExpiresEntryRef freeRef = GetFreeExpiresEntry();
                Debug.Assert(cacheEntry.ExpiresBucket == 0xff, "cacheEntry.ExpiresBucket == 0xff");
                Debug.Assert(cacheEntry.ExpiresEntryRef.IsInvalid, "cacheEntry.ExpiresEntryRef.IsInvalid");
                cacheEntry.ExpiresBucket   = _bucket;
                cacheEntry.ExpiresEntryRef = freeRef;

                ExpiresEntry[] entries    = (_pages[(freeRef.PageIndex)]._entries);
                int            entryIndex = freeRef.Index;
                entries[entryIndex]._cacheEntry = cacheEntry;
                entries[entryIndex]._utcExpires = cacheEntry.UtcAbsExp;

                AddCount(cacheEntry.UtcAbsExp);

                _cEntriesInUse++;

                if ((cacheEntry.State & (EntryState.AddedToCache | EntryState.AddingToCache)) == 0)
                {
                    RemoveCacheEntryNoLock(cacheEntry);
                }
            }
        }
        private void RemoveCacheEntryNoLock(MemoryCacheEntry cacheEntry)
        {
            ExpiresEntryRef expiresEntryRef = cacheEntry.ExpiresEntryRef;

            if ((cacheEntry.ExpiresBucket == this._bucket) && !expiresEntryRef.IsInvalid)
            {
                ExpiresEntry[] entryArray = this._pages[expiresEntryRef.PageIndex]._entries;
                int            index      = expiresEntryRef.Index;
                this.RemoveCount(entryArray[index]._utcExpires);
                cacheEntry.ExpiresBucket      = 0xff;
                cacheEntry.ExpiresEntryRef    = ExpiresEntryRef.INVALID;
                entryArray[index]._cacheEntry = null;
                this.AddExpiresEntryToFreeList(expiresEntryRef);
                if (this._cEntriesInUse == 0)
                {
                    this.ResetCounts(DateTime.UtcNow);
                }
                this.Reduce();
            }
        }
        private void AddExpiresEntryToFreeList(ExpiresEntryRef entryRef)
        {
            ExpiresEntry[] entryArray = this._pages[entryRef.PageIndex]._entries;
            int            index      = entryRef.Index;

            entryArray[index]._cFree = 0;
            entryArray[index]._next  = entryArray[0]._next;
            entryArray[0]._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);
            }
        }
Ejemplo n.º 11
0
        internal void UtcUpdateCacheEntry(MemoryCacheEntry cacheEntry, DateTime utcExpires)
        {
            lock (this)
            {
                ExpiresEntryRef entryRef = cacheEntry.ExpiresEntryRef;
                if (cacheEntry.ExpiresBucket != _bucket || entryRef.IsInvalid)
                {
                    return;
                }

                ExpiresEntry[] entries    = (_pages[(entryRef.PageIndex)]._entries);
                int            entryIndex = entryRef.Index;

                Debug.Assert(cacheEntry == entries[entryIndex]._cacheEntry);

                RemoveCount(entries[entryIndex]._utcExpires);
                AddCount(utcExpires);

                entries[entryIndex]._utcExpires = utcExpires;

                cacheEntry.UtcAbsExp = utcExpires;
            }
        }
Ejemplo n.º 12
0
        private void RemoveCacheEntryNoLock(MemoryCacheEntry cacheEntry)
        {
            ExpiresEntryRef entryRef = cacheEntry.ExpiresEntryRef;

            if (cacheEntry.ExpiresBucket != _bucket || entryRef.IsInvalid)
            {
                return;
            }

            ExpiresEntry[] entries    = (_pages[(entryRef.PageIndex)]._entries);
            int            entryIndex = entryRef.Index;

            RemoveCount(entries[entryIndex]._utcExpires);

            cacheEntry.ExpiresBucket        = 0xff;
            cacheEntry.ExpiresEntryRef      = ExpiresEntryRef.INVALID;
            entries[entryIndex]._cacheEntry = null;

            AddExpiresEntryToFreeList(entryRef);

            if (_cEntriesInUse == 0)
            {
                ResetCounts(DateTime.UtcNow);
            }

            Reduce();

            Dbg.Trace("CacheExpiresRemove",
                      "Removed item=" + cacheEntry.Key +
                      ",_bucket=" + _bucket +
                      ",ref=" + entryRef +
                      ",now=" + Dbg.FormatLocalDate(DateTime.Now) +
                      ",expires=" + cacheEntry.UtcAbsExp.ToLocalTime());

            Dbg.Validate("CacheValidateExpires", this);
            Dbg.Dump("CacheExpiresRemove", this);
        }
Ejemplo n.º 13
0
        private void AddExpiresEntryToFreeList(ExpiresEntryRef entryRef)
        {
            ExpiresEntry[] entries    = (_pages[(entryRef.PageIndex)]._entries);
            int            entryIndex = entryRef.Index;

            Debug.Assert(entries[entryIndex]._cacheEntry == null, "entries[entryIndex]._cacheEntry == null");
            entries[entryIndex]._cFree = 0;

            entries[entryIndex]._next = ((entries)[0]._next);
            ((entries)[0]._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);
            }
        }
 static ExpiresEntryRef()
 {
     INVALID = new ExpiresEntryRef(0, 0);
 }
Ejemplo n.º 15
0
        internal int FlushExpiredItems(DateTime utcNow, bool useInsertBlock)
        {
            if (_cEntriesInUse == 0 || GetExpiresCount(utcNow) == 0)
            {
                return(0);
            }

            Debug.Assert(_cEntriesInFlush == 0, "_cEntriesInFlush == 0");

            ExpiresEntryRef inFlushHead = ExpiresEntryRef.INVALID;

            ExpiresEntry[]   entries;
            int              entryIndex;
            MemoryCacheEntry cacheEntry;
            int              flushed = 0;

            try
            {
                if (useInsertBlock)
                {
                    _cacheExpires.MemoryCacheStore.BlockInsert();
                }

                lock (this)
                {
                    Debug.Assert(_blockReduce == false, "_blockReduce == false");

                    if (_cEntriesInUse == 0 || GetExpiresCount(utcNow) == 0)
                    {
                        return(0);
                    }

                    ResetCounts(utcNow);
                    int cPages = _cPagesInUse;
                    for (int i = 0; i < _pages.Length; i++)
                    {
                        entries = _pages[i]._entries;
                        if (entries != null)
                        {
                            int cEntries = NUM_ENTRIES - ((entries)[0]._cFree);
                            for (int j = 1; j < entries.Length; j++)
                            {
                                cacheEntry = entries[j]._cacheEntry;
                                if (cacheEntry != null)
                                {
                                    if (entries[j]._utcExpires > utcNow)
                                    {
                                        AddCount(entries[j]._utcExpires);
                                    }
                                    else
                                    {
                                        cacheEntry.ExpiresBucket   = 0xff;
                                        cacheEntry.ExpiresEntryRef = ExpiresEntryRef.INVALID;

                                        entries[j]._cFree = 1;

                                        entries[j]._next = inFlushHead;
                                        inFlushHead      = new ExpiresEntryRef(i, j);

                                        flushed++;
                                        _cEntriesInFlush++;
                                    }

                                    cEntries--;
                                    if (cEntries == 0)
                                    {
                                        break;
                                    }
                                }
                            }

                            cPages--;
                            if (cPages == 0)
                            {
                                break;
                            }
                        }
                    }

                    if (flushed == 0)
                    {
                        Dbg.Trace("CacheExpiresFlushTotal", "FlushExpiredItems flushed " + flushed +
                                  " expired items, bucket=" + _bucket + "; Time=" + DateTime.Now.ToString("o", CultureInfo.InvariantCulture));

                        return(0);
                    }

                    _blockReduce = true;
                }
            }
            finally
            {
                if (useInsertBlock)
                {
                    _cacheExpires.MemoryCacheStore.UnblockInsert();
                }
            }

            Debug.Assert(!inFlushHead.IsInvalid, "!inFlushHead.IsInvalid");

            MemoryCacheStore cacheStore = _cacheExpires.MemoryCacheStore;
            ExpiresEntryRef  current    = inFlushHead;
            ExpiresEntryRef  next;

            while (!current.IsInvalid)
            {
                entries    = (_pages[(current.PageIndex)]._entries);
                entryIndex = current.Index;

                next = entries[entryIndex]._next;

                cacheEntry = entries[entryIndex]._cacheEntry;
                entries[entryIndex]._cacheEntry = null;
                Debug.Assert(cacheEntry.ExpiresEntryRef.IsInvalid, "cacheEntry.ExpiresEntryRef.IsInvalid");
                cacheStore.Remove(cacheEntry, cacheEntry, CacheEntryRemovedReason.Expired);

                current = next;
            }

            try
            {
                if (useInsertBlock)
                {
                    _cacheExpires.MemoryCacheStore.BlockInsert();
                }

                lock (this)
                {
                    current = inFlushHead;
                    while (!current.IsInvalid)
                    {
                        entries    = (_pages[(current.PageIndex)]._entries);
                        entryIndex = current.Index;

                        next = entries[entryIndex]._next;

                        _cEntriesInFlush--;
                        AddExpiresEntryToFreeList(current);

                        current = next;
                    }

                    Debug.Assert(_cEntriesInFlush == 0, "_cEntriesInFlush == 0");
                    _blockReduce = false;
                    Reduce();

                    Dbg.Trace("CacheExpiresFlushTotal", "FlushExpiredItems flushed " + flushed +
                              " expired items, bucket=" + _bucket + "; Time=" + DateTime.Now.ToString("o", CultureInfo.InvariantCulture));
                }
            }
            finally
            {
                if (useInsertBlock)
                {
                    _cacheExpires.MemoryCacheStore.UnblockInsert();
                }
            }

            return(flushed);
        }
Ejemplo n.º 16
0
        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;

            ExpiresEntry[] 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");
                    ExpiresEntryRef newRef = GetFreeExpiresEntry();
                    Debug.Assert(newRef.PageIndex != _freeEntryList._tail, "newRef.PageIndex != _freeEntryList._tail");

                    MemoryCacheEntry cacheEntry = entries[i]._cacheEntry;

                    cacheEntry.ExpiresEntryRef = newRef;

                    ExpiresEntry[] newEntries = (_pages[(newRef.PageIndex)]._entries);
                    newEntries[newRef.Index] = entries[i];

                    ((entries)[0]._cFree)++;
                }

                RemovePage(_freeEntryList._tail);
            }
        }
        internal int FlushExpiredItems(DateTime utcNow, bool useInsertBlock)
        {
            ExpiresEntry[]   entryArray;
            int              index;
            MemoryCacheEntry entry;
            ExpiresEntryRef  ref3;
            ExpiresEntryRef  ref4;

            if ((this._cEntriesInUse == 0) || (this.GetExpiresCount(utcNow) == 0))
            {
                return(0);
            }
            ExpiresEntryRef iNVALID = ExpiresEntryRef.INVALID;
            int             num2    = 0;

            try
            {
                if (useInsertBlock)
                {
                    this._cacheExpires.MemoryCacheStore.BlockInsert();
                }
                lock (this)
                {
                    if ((this._cEntriesInUse == 0) || (this.GetExpiresCount(utcNow) == 0))
                    {
                        return(0);
                    }
                    this.ResetCounts(utcNow);
                    int num3 = this._cPagesInUse;
                    for (int i = 0; i < this._pages.Length; i++)
                    {
                        entryArray = this._pages[i]._entries;
                        if (entryArray != null)
                        {
                            int num5 = 0x7f - entryArray[0]._cFree;
                            for (int j = 1; j < entryArray.Length; j++)
                            {
                                entry = entryArray[j]._cacheEntry;
                                if (entry != null)
                                {
                                    if (entryArray[j]._utcExpires > utcNow)
                                    {
                                        this.AddCount(entryArray[j]._utcExpires);
                                    }
                                    else
                                    {
                                        entry.ExpiresBucket   = 0xff;
                                        entry.ExpiresEntryRef = ExpiresEntryRef.INVALID;
                                        entryArray[j]._cFree  = 1;
                                        entryArray[j]._next   = iNVALID;
                                        iNVALID = new ExpiresEntryRef(i, j);
                                        num2++;
                                        this._cEntriesInFlush++;
                                    }
                                    num5--;
                                    if (num5 == 0)
                                    {
                                        break;
                                    }
                                }
                            }
                            num3--;
                            if (num3 == 0)
                            {
                                break;
                            }
                        }
                    }
                    if (num2 == 0)
                    {
                        return(0);
                    }
                    this._blockReduce = true;
                }
            }
            finally
            {
                if (useInsertBlock)
                {
                    this._cacheExpires.MemoryCacheStore.UnblockInsert();
                }
            }
            MemoryCacheStore memoryCacheStore = this._cacheExpires.MemoryCacheStore;

            for (ref3 = iNVALID; !ref3.IsInvalid; ref3 = ref4)
            {
                entryArray = this._pages[ref3.PageIndex]._entries;
                index      = ref3.Index;
                ref4       = entryArray[index]._next;
                entry      = entryArray[index]._cacheEntry;
                entryArray[index]._cacheEntry = null;
                memoryCacheStore.Remove(entry, entry, CacheEntryRemovedReason.Expired);
            }
            try
            {
                if (useInsertBlock)
                {
                    this._cacheExpires.MemoryCacheStore.BlockInsert();
                }
                lock (this)
                {
                    for (ref3 = iNVALID; !ref3.IsInvalid; ref3 = ref4)
                    {
                        entryArray = this._pages[ref3.PageIndex]._entries;
                        index      = ref3.Index;
                        ref4       = entryArray[index]._next;
                        this._cEntriesInFlush--;
                        this.AddExpiresEntryToFreeList(ref3);
                    }
                    this._blockReduce = false;
                    this.Reduce();
                }
            }
            finally
            {
                if (useInsertBlock)
                {
                    this._cacheExpires.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;
            }
        }
Ejemplo n.º 19
0
 static ExpiresEntryRef()
 {
     INVALID = new ExpiresEntryRef(0, 0);
 }