Files
dotnet-bot adf899c629 Adding System.Data..., System.ServiceModel..., and System.Web...
Adding reference source for
System.Data
System.Data.DataSetExtensions
System.Data.Entity
System.Data.Entity.Design
System.Data.Linq
System.Data.SqlXml
System.ServiceModel
System.ServiceModel.Activation
System.ServiceModel.Activities
System.ServiceModel.Channels
System.ServiceModel.Discovery
System.ServiceModel.Internals
System.ServiceModel.Routing
System.ServiceModel.WasHosting
System.ServiceModel.Web
System.Web
System.Web.ApplicationServices
System.Web.DynamicData
System.Web.Entity
System.Web.Entity.Design
System.Web.Extensions
System.Web.Mobile
System.Web.Routing
System.Web.Services
System.Xml
System.Xml.Linq
2016-05-03 00:07:37 +02:00

509 lines
16 KiB
C#

//------------------------------------------------------------
// Copyright (c) Microsoft Corporation. All rights reserved.
//------------------------------------------------------------
namespace System.Runtime.Collections
{
using System.Collections.Generic;
// free-threaded so that it can deal with items releasing references and timer interactions
// interaction pattern is:
// 1) item = cache.Take(key);
// 2) if (item == null) { Create and Open Item; cache.Add(key, value); }
// 2) use item, including performing any blocking operations like open/close/etc
// 3) item.ReleaseReference();
//
// for usability purposes, if a CacheItem is non-null you can always call Release on it
class ObjectCache<TKey, TValue>
where TValue : class
{
// for performance reasons we don't just blindly start a timer up to clean up
// idle cache items. However, if we're above a certain threshold of items, then we'll start the timer.
const int timerThreshold = 1;
ObjectCacheSettings settings;
Dictionary<TKey, Item> cacheItems;
bool idleTimeoutEnabled;
bool leaseTimeoutEnabled;
IOThreadTimer idleTimer;
static Action<object> onIdle;
bool disposed;
public ObjectCache(ObjectCacheSettings settings)
: this(settings, null)
{
}
public ObjectCache(ObjectCacheSettings settings, IEqualityComparer<TKey> comparer)
{
Fx.Assert(settings != null, "caller must use a valid settings object");
this.settings = settings.Clone();
this.cacheItems = new Dictionary<TKey, Item>(comparer);
// idle feature is disabled if settings.IdleTimeout == TimeSpan.MaxValue
this.idleTimeoutEnabled = (settings.IdleTimeout != TimeSpan.MaxValue);
// lease feature is disabled if settings.LeaseTimeout == TimeSpan.MaxValue
this.leaseTimeoutEnabled = (settings.LeaseTimeout != TimeSpan.MaxValue);
}
object ThisLock
{
get
{
return this;
}
}
// Users like ServiceModel can hook this for ICommunicationObject or to handle other non-IDisposable objects
public Action<TValue> DisposeItemCallback
{
get;
set;
}
public int Count
{
get
{
return this.cacheItems.Count;
}
}
public ObjectCacheItem<TValue> Add(TKey key, TValue value)
{
Fx.Assert(key != null, "caller must validate parameters");
Fx.Assert(value != null, "caller must validate parameters");
lock (ThisLock)
{
if (this.Count >= this.settings.CacheLimit || this.cacheItems.ContainsKey(key))
{
// cache is full or already has an entry - return a shell CacheItem
return new Item(key, value, this.DisposeItemCallback);
}
else
{
return InternalAdd(key, value);
}
}
}
public ObjectCacheItem<TValue> Take(TKey key)
{
return Take(key, null);
}
// this overload is used for cases where a usable object can be atomically created in a non-blocking fashion
public ObjectCacheItem<TValue> Take(TKey key, Func<TValue> initializerDelegate)
{
Fx.Assert(key != null, "caller must validate parameters");
Item cacheItem = null;
lock (ThisLock)
{
if (this.cacheItems.TryGetValue(key, out cacheItem))
{
// we have an item, add a reference
cacheItem.InternalAddReference();
}
else
{
if (initializerDelegate == null)
{
// not found in cache, no way to create.
return null;
}
TValue createdObject = initializerDelegate();
Fx.Assert(createdObject != null, "initializer delegate must always give us a valid object");
if (this.Count >= this.settings.CacheLimit)
{
// cache is full - return a shell CacheItem
return new Item(key, createdObject, this.DisposeItemCallback);
}
cacheItem = InternalAdd(key, createdObject);
}
}
return cacheItem;
}
// assumes caller takes lock
Item InternalAdd(TKey key, TValue value)
{
Item cacheItem = new Item(key, value, this);
if (this.leaseTimeoutEnabled)
{
cacheItem.CreationTime = DateTime.UtcNow;
}
this.cacheItems.Add(key, cacheItem);
StartTimerIfNecessary();
return cacheItem;
}
// assumes caller takes lock
bool Return(TKey key, Item cacheItem)
{
bool disposeItem = false;
if (this.disposed)
{
// we would have already disposed this item, do not attempt to return it
disposeItem = true;
}
else
{
cacheItem.InternalReleaseReference();
DateTime now = DateTime.UtcNow;
if (this.idleTimeoutEnabled)
{
cacheItem.LastUsage = now;
}
if (ShouldPurgeItem(cacheItem, now))
{
bool removedFromItems = this.cacheItems.Remove(key);
Fx.Assert(removedFromItems, "we should always find the key");
cacheItem.LockedDispose();
disposeItem = true;
}
}
return disposeItem;
}
void StartTimerIfNecessary()
{
if (this.idleTimeoutEnabled && this.Count > timerThreshold)
{
if (this.idleTimer == null)
{
if (onIdle == null)
{
onIdle = new Action<object>(OnIdle);
}
this.idleTimer = new IOThreadTimer(onIdle, this, false);
}
this.idleTimer.Set(this.settings.IdleTimeout);
}
}
// timer callback
static void OnIdle(object state)
{
ObjectCache<TKey, TValue> cache = (ObjectCache<TKey, TValue>)state;
cache.PurgeCache(true);
}
static void Add<T>(ref List<T> list, T item)
{
Fx.Assert(!item.Equals(default(T)), "item should never be null");
if (list == null)
{
list = new List<T>();
}
list.Add(item);
}
bool ShouldPurgeItem(Item cacheItem, DateTime now)
{
// only prune items who aren't in use
if (cacheItem.ReferenceCount > 0)
{
return false;
}
if (this.idleTimeoutEnabled &&
now >= (cacheItem.LastUsage + this.settings.IdleTimeout))
{
return true;
}
else if (this.leaseTimeoutEnabled &&
(now - cacheItem.CreationTime) >= this.settings.LeaseTimeout)
{
return true;
}
return false;
}
void GatherExpiredItems(ref List<KeyValuePair<TKey, Item>> expiredItems, bool calledFromTimer)
{
if (this.Count == 0)
{
return;
}
if (!this.leaseTimeoutEnabled && !this.idleTimeoutEnabled)
{
return;
}
DateTime now = DateTime.UtcNow;
bool setTimer = false;
lock (ThisLock)
{
foreach (KeyValuePair<TKey, Item> cacheItem in this.cacheItems)
{
if (ShouldPurgeItem(cacheItem.Value, now))
{
cacheItem.Value.LockedDispose();
Add(ref expiredItems, cacheItem);
}
}
// now remove items from the cache
if (expiredItems != null)
{
for (int i = 0; i < expiredItems.Count; i++)
{
this.cacheItems.Remove(expiredItems[i].Key);
}
}
setTimer = calledFromTimer && (this.Count > 0);
}
if (setTimer)
{
idleTimer.Set(this.settings.IdleTimeout);
}
}
void PurgeCache(bool calledFromTimer)
{
List<KeyValuePair<TKey, Item>> itemsToClose = null;
lock (ThisLock)
{
this.GatherExpiredItems(ref itemsToClose, calledFromTimer);
}
if (itemsToClose != null)
{
for (int i = 0; i < itemsToClose.Count; i++)
{
itemsToClose[i].Value.LocalDispose();
}
}
}
// dispose all the Items if they are IDisposable
public void Dispose()
{
lock (ThisLock)
{
foreach (Item item in this.cacheItems.Values)
{
if (item != null)
{
// We need to Dispose every item in the cache even when it's refcount is greater than Zero, hence we call Dispose instead of LocalDispose
item.Dispose();
}
}
this.cacheItems.Clear();
// we don't cache after Dispose
this.settings.CacheLimit = 0;
this.disposed = true;
if (this.idleTimer != null)
{
this.idleTimer.Cancel();
this.idleTimer = null;
}
}
}
// public surface area is synchronized through this.parent.ThisLock
class Item : ObjectCacheItem<TValue>
{
readonly ObjectCache<TKey, TValue> parent;
readonly TKey key;
readonly Action<TValue> disposeItemCallback;
TValue value;
int referenceCount;
public Item(TKey key, TValue value, Action<TValue> disposeItemCallback)
: this(key, value)
{
this.disposeItemCallback = disposeItemCallback;
}
public Item(TKey key, TValue value, ObjectCache<TKey, TValue> parent)
: this(key, value)
{
this.parent = parent;
}
Item(TKey key, TValue value)
{
this.key = key;
this.value = value;
this.referenceCount = 1; // start with a reference
}
public int ReferenceCount
{
get
{
return this.referenceCount;
}
}
public override TValue Value
{
get
{
return this.value;
}
}
public DateTime CreationTime
{
get;
set;
}
public DateTime LastUsage
{
get;
set;
}
public override bool TryAddReference()
{
bool result;
// item may not be valid or cachable, first let's sniff for disposed without taking a lock
if (this.parent == null || this.referenceCount == -1)
{
result = false;
}
else
{
bool disposeSelf = false;
lock (this.parent.ThisLock)
{
if (this.referenceCount == -1)
{
result = false;
}
else if (this.referenceCount == 0 && this.parent.ShouldPurgeItem(this, DateTime.UtcNow))
{
LockedDispose();
disposeSelf = true;
result = false;
this.parent.cacheItems.Remove(this.key);
}
else
{
// we're still in use, simply add-ref and be done
this.referenceCount++;
Fx.Assert(this.parent.cacheItems.ContainsValue(this), "should have a valid value");
Fx.Assert(this.Value != null, "should have a valid value");
result = true;
}
}
if (disposeSelf)
{
this.LocalDispose();
}
}
return result;
}
public override void ReleaseReference()
{
bool disposeItem;
if (this.parent == null)
{
Fx.Assert(this.referenceCount == 1, "reference count should have never increased");
this.referenceCount = -1; // not under a lock since we're not really in the cache
disposeItem = true;
}
else
{
lock (this.parent.ThisLock)
{
// if our reference count will still be non zero, then simply decrement
if (this.referenceCount > 1)
{
InternalReleaseReference();
disposeItem = false;
}
else
{
// otherwise we need to coordinate with our parent
disposeItem = this.parent.Return(this.key, this);
}
}
}
if (disposeItem)
{
this.LocalDispose();
}
}
internal void InternalAddReference()
{
Fx.Assert(this.referenceCount >= 0, "cannot take the item marked for disposal");
this.referenceCount++;
}
internal void InternalReleaseReference()
{
Fx.Assert(this.referenceCount > 0, "can only release an item that has references");
this.referenceCount--;
}
// call this part under the lock, and Dispose outside the lock
public void LockedDispose()
{
Fx.Assert(this.referenceCount == 0, "we should only dispose items without references");
this.referenceCount = -1;
}
public void Dispose()
{
if (Value != null)
{
Action<TValue> localDisposeItemCallback = this.disposeItemCallback;
if (this.parent != null)
{
Fx.Assert(localDisposeItemCallback == null, "shouldn't have both this.disposeItemCallback and this.parent");
localDisposeItemCallback = this.parent.DisposeItemCallback;
}
if (localDisposeItemCallback != null)
{
localDisposeItemCallback(Value);
}
else if (Value is IDisposable)
{
((IDisposable)Value).Dispose();
}
}
this.value = null;
// this will ensure that TryAddReference returns false
this.referenceCount = -1;
}
public void LocalDispose()
{
Fx.Assert(this.referenceCount == -1, "we should only dispose items that have had LockedDispose called on them");
this.Dispose();
}
}
}
}