Files
mono/mcs/class/System.Web/System.Web.Caching/CacheEntry.cs
T
Gonzalo Paniagua Javier a6e0d6f12b 2005-06-25 Gonzalo Paniagua Javier <[email protected]>
* Cache.cs: 
	* CacheEntry.cs: style. Removed doc. comments.


svn path=/trunk/mcs/; revision=46502
2005-06-25 19:23:08 +00:00

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);
}
}
}