mirror of
https://github.com/BepInEx/mono.git
synced 2026-11-17 11:21:39 -10:00
* Cache.cs: * CacheEntry.cs: style. Removed doc. comments. svn path=/trunk/mcs/; revision=46502
213 lines
5.6 KiB
C#
213 lines
5.6 KiB
C#
//
|
|
// System.Web.Caching
|
|
//
|
|
// Author:
|
|
// Patrik Torstensson
|
|
// Daniel Cazzulino ([email protected])
|
|
//
|
|
|
|
//
|
|
// Permission is hereby granted, free of charge, to any person obtaining
|
|
// a copy of this software and associated documentation files (the
|
|
// "Software"), to deal in the Software without restriction, including
|
|
// without limitation the rights to use, copy, modify, merge, publish,
|
|
// distribute, sublicense, and/or sell copies of the Software, and to
|
|
// permit persons to whom the Software is furnished to do so, subject to
|
|
// the following conditions:
|
|
//
|
|
// The above copyright notice and this permission notice shall be
|
|
// included in all copies or substantial portions of the Software.
|
|
//
|
|
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
|
|
// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
|
|
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
|
|
// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
|
|
// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
|
|
// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
|
|
// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
|
//
|
|
|
|
using System;
|
|
using System.Threading;
|
|
|
|
namespace System.Web.Caching {
|
|
internal class CacheEntry {
|
|
enum Flags {
|
|
Removed = 1,
|
|
Public = 2
|
|
}
|
|
|
|
internal static readonly byte NoBucketHash = byte.MaxValue;
|
|
internal static readonly int NoIndexInBucket = int.MaxValue;
|
|
|
|
CacheItemPriority _enumPriority;
|
|
long _longHits;
|
|
byte _byteExpiresBucket;
|
|
int _intExpiresIndex;
|
|
long _ticksExpires;
|
|
long _ticksSlidingExpiration;
|
|
string _strKey;
|
|
object _objItem;
|
|
long _longMinHits;
|
|
Flags _enumFlags;
|
|
CacheDependency _objDependency;
|
|
Cache _objCache;
|
|
ReaderWriterLock _lock = new ReaderWriterLock();
|
|
|
|
internal event CacheItemRemovedCallback _onRemoved;
|
|
|
|
internal CacheEntry (Cache objManager, string strKey, object objItem,CacheDependency objDependency,
|
|
CacheItemRemovedCallback eventRemove, DateTime dtExpires, TimeSpan tsSpan,
|
|
long longMinHits, bool boolPublic, CacheItemPriority enumPriority )
|
|
{
|
|
if (boolPublic)
|
|
_enumFlags |= Flags.Public;
|
|
|
|
_strKey = strKey;
|
|
_objItem = objItem;
|
|
_objCache = objManager;
|
|
_onRemoved += eventRemove;
|
|
_enumPriority = enumPriority;
|
|
_ticksExpires = dtExpires.ToUniversalTime ().Ticks;
|
|
_ticksSlidingExpiration = tsSpan.Ticks;
|
|
|
|
// If we have a sliding expiration it overrides the absolute expiration (MS behavior)
|
|
// This is because sliding expiration causes the absolute expiration to be
|
|
// moved after each period, and the absolute expiration is the value used
|
|
// for all expiration calculations.
|
|
if (tsSpan.Ticks != Cache.NoSlidingExpiration.Ticks)
|
|
_ticksExpires = DateTime.UtcNow.AddTicks (_ticksSlidingExpiration).Ticks;
|
|
|
|
_objDependency = objDependency;
|
|
if (_objDependency != null)
|
|
// Add the entry to the cache dependency handler (we support multiple entries per handler)
|
|
_objDependency.Changed += new CacheDependencyChangedHandler (OnChanged);
|
|
|
|
_longMinHits = longMinHits;
|
|
}
|
|
|
|
|
|
internal void OnChanged (object sender, CacheDependencyChangedArgs objDependency)
|
|
{
|
|
_objCache.Remove (_strKey, CacheItemRemovedReason.DependencyChanged);
|
|
}
|
|
|
|
internal void Close (CacheItemRemovedReason enumReason)
|
|
{
|
|
Delegate [] removedEvents = null;
|
|
|
|
_lock.AcquireWriterLock(-1);
|
|
try {
|
|
// Check if the item already is removed
|
|
if ((_enumFlags & Flags.Removed) != 0)
|
|
return;
|
|
|
|
_enumFlags |= Flags.Removed;
|
|
|
|
if (_onRemoved != null)
|
|
removedEvents = _onRemoved.GetInvocationList ();
|
|
} finally {
|
|
_lock.ReleaseWriterLock();
|
|
}
|
|
|
|
if (removedEvents != null) {
|
|
// Call the delegate to tell that we are now removing the entry
|
|
foreach (Delegate del in removedEvents) {
|
|
CacheItemRemovedCallback removed = (CacheItemRemovedCallback) del;
|
|
try {
|
|
removed (_strKey, _objItem, enumReason);
|
|
} catch (Exception obj) {
|
|
if (IsPublic)
|
|
HttpApplicationFactory.SignalError (obj);
|
|
}
|
|
}
|
|
}
|
|
|
|
_lock.AcquireWriterLock(-1);
|
|
try {
|
|
// If we have a dependency, remove the entry
|
|
if (_objDependency != null)
|
|
_objDependency.Changed -= new CacheDependencyChangedHandler (OnChanged);
|
|
} finally {
|
|
_lock.ReleaseWriterLock();
|
|
}
|
|
}
|
|
|
|
internal bool HasUsage {
|
|
get {
|
|
if (_longMinHits == System.Int64.MaxValue)
|
|
return false;
|
|
|
|
return true;
|
|
}
|
|
}
|
|
|
|
internal bool HasAbsoluteExpiration {
|
|
get {
|
|
if (_ticksExpires == Cache.NoAbsoluteExpiration.Ticks)
|
|
return false;
|
|
|
|
return true;
|
|
}
|
|
}
|
|
|
|
internal bool HasSlidingExpiration {
|
|
get {
|
|
if (_ticksSlidingExpiration == Cache.NoSlidingExpiration.Ticks)
|
|
return false;
|
|
|
|
return true;
|
|
}
|
|
}
|
|
|
|
internal byte ExpiresBucket {
|
|
get { return _byteExpiresBucket; }
|
|
set { _byteExpiresBucket = value; }
|
|
}
|
|
|
|
internal int ExpiresIndex {
|
|
get { return _intExpiresIndex; }
|
|
set { _intExpiresIndex = value; }
|
|
}
|
|
|
|
internal long Expires {
|
|
get { return _ticksExpires; }
|
|
set { _ticksExpires = value; }
|
|
}
|
|
|
|
internal long SlidingExpiration {
|
|
get { return _ticksSlidingExpiration; }
|
|
}
|
|
|
|
internal object Item {
|
|
get { return _objItem; }
|
|
}
|
|
|
|
internal string Key {
|
|
get { return _strKey; }
|
|
}
|
|
|
|
internal long Hits {
|
|
get { return _longHits; }
|
|
}
|
|
|
|
internal long MinimumHits {
|
|
get { return _longMinHits; }
|
|
}
|
|
|
|
internal CacheItemPriority Priority {
|
|
get { return _enumPriority; }
|
|
}
|
|
|
|
internal bool IsPublic {
|
|
get { return (_enumFlags & Flags.Public) != 0; }
|
|
}
|
|
|
|
internal void Hit ()
|
|
{
|
|
Interlocked.Increment (ref _longHits);
|
|
}
|
|
}
|
|
}
|
|
|