mirror of
https://github.com/BepInEx/mono.git
synced 2026-11-19 01:31:17 -10:00
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
509 lines
16 KiB
C#
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();
|
|
}
|
|
}
|
|
|
|
}
|
|
}
|