public bool ContainsKey(string key)
{
Lock.AcquireReaderLock(1000);
try
{
return(settings.ContainsKey(key));
}
finally
{
Lock.ReleaseReaderLock();
}
}
/// <summary>
/// 获取指定的键相关联值
/// </summary>
/// <param name="key"></param>
/// <param name="value"></param>
/// <returns></returns>
public bool TryGetValue(TKey key, out TValue value)
{
rwLock.AcquireReaderLock(lockTimeOut);
bool result;
try
{
result = dictionary.TryGetValue(key, out value);
}
finally
{
rwLock.ReleaseReaderLock();
}
return(result);
}
/// <summary>
/// Returns a reference to the (directed or indirected) edge that connects to a specific successor vertex. This can either be
/// a directed edge starting from this vertex and arriving in the successor or an undirected edge connecting both vertices. This operation is thread-safe.
/// </summary>
/// <param name="successor">The successor to which this vertex connects</param>
/// <returns>The edge between this vertex and the successor in question or null if no such edge exists</returns>
public Edge GetEdgeToSuccessor(Vertex successor)
{
_rwl.AcquireReaderLock(-1);
Edge e = null;
if (_successorToEdgeMap.ContainsKey(successor.ID))
{
e = _successorToEdgeMap[successor.ID];
}
_rwl.ReleaseReaderLock();
return(e);
}
private void Dispose(bool disposing)
{
if (disposed)
{
return;
}
System.Diagnostics.Debug.Assert(disposing);
if (cookie.HasValue)
{
DowngradeToReaderLock();
}
if (type == LockType.ForReading)
{
rwlock.ReleaseReaderLock();
}
else if (type == LockType.ForWriting)
{
rwlock.ReleaseWriterLock();
}
disposed = true;
}
/// <summary>
/// Notifies all registered event handlers of the occurance of an event!
/// </summary>
/// <param name="e">The event that occured</param>
/// <param name="sender">The sender of this event</param>
/// <param name="eArgs">The event arguments</param>
/// <remarks>Overwrite the EventArgs class to set own arguments</remarks>
public void Notify(RoadEvent e, object sender, EventArgs eArgs)
{
try
{
m_lock.AcquireReaderLock(TIMEOUT);
WeakMulticastDelegate eventDelegate;
try
{
eventDelegate = (WeakMulticastDelegate)m_events[e];
}
finally
{
m_lock.ReleaseReaderLock();
}
if (eventDelegate == null)
{
return;
}
eventDelegate.InvokeSafe(new object[] { e, sender, eArgs });
}
catch (ApplicationException ex)
{
if (log.IsErrorEnabled)
{
log.Error("Failed to notify event handler!", ex);
}
}
}
/// <summary>
/// 查找符合条件的对象，并将它们存入一个list中
/// </summary>
/// <param name="adapter">查找条件</param>
/// <returns>如果返回的list的长度为0，表示没有找到符合条件的对象</returns>
public List <T> Search(int adapter, Hashtable paraset)
{
List <T> result = null;
try
{
obj_rwl.AcquireReaderLock(System.Threading.Timeout.Infinite);
//在对象集合中寻找
int getall;//根据管理策略的不同而选择不同的值，如果该策略缓存了所有的数据，则getall为1，表示不需要再到数据库中查询了。
result = this.obj_dependency.Search(ref this.obj_containers, adapter, paraset, out getall);
obj_rwl.ReleaseReaderLock();
if (0 == getall)
{
obj_rwl.AcquireWriterLock(System.Threading.Timeout.Infinite);
result.Clear();
result = SearchDB(adapter, paraset);
if (result.Count > 0)
{
foreach (T t in result)
{
this.obj_dependency.Insert(t.GetMyGuid(), new CCacheItem_WuQi <K, T>(t.GetMyGuid(), t), ref this.obj_containers);
}
}
obj_rwl.ReleaseWriterLock();
}
}
catch (System.Exception e)
{
CExceptionContainer_WuQi.ProcessException(e);
throw e;
}
finally
{
if (obj_rwl.IsReaderLockHeld)
{
obj_rwl.ReleaseReaderLock();
}
if (obj_rwl.IsWriterLockHeld)
{
obj_rwl.ReleaseWriterLock();
}
}
return(result);
}
public TResult Read <TResult>(Func <T, TResult> readMethod)
{
readerWriterLock.AcquireReaderLock(int.MaxValue);
try
{
return(readMethod(data));
}
finally { readerWriterLock.ReleaseReaderLock(); }
}
public bool IsCodeUsed(long timestamp, String code, object user)
{
try
{
rwlock.AcquireReaderLock(lockingTimeout);
return(codes.Contains(new UsedCode(timestamp, code, user)));
}
finally
{
rwlock.ReleaseReaderLock();
}
}
public ToJSON()
{
try
{
_rw_lock.AcquireReaderLock(5000); // or whatever you deem an acceptable timeout
string s = ""; // Serialize here using Newtonsoft
return(s);
}
finally
{
_rw_lock.ReleaseReaderLock();
}
}
/// <summary>
/// Dispose this instance.
/// </summary>
void System.IDisposable.Dispose()
{
if (null != _lock)
{
// If this thread hold a write-lock when this instance was created
// (see constructor) then no read-lock was acquired.
// Note: this design assumes the scope of the write-lock held bigger
// than this instance.
if (true == _lock.IsReaderLockHeld)
{
_lock.ReleaseReaderLock();
this._decrementCount();
//this._printCount();
}
}
}
public override void CopyTo(BillType[] array)
{
rwLock.AcquireReaderLock(timeout);
try
{
collection.CopyTo(array);
}
finally
{
rwLock.ReleaseReaderLock();
}
}
public override void CopyTo(Property[] array)
{
_rwLock.AcquireReaderLock(Timeout);
try
{
_collection.CopyTo(array);
}
finally
{
_rwLock.ReleaseReaderLock();
}
}
public override void CopyTo(StatementPhoneNumber[] array)
{
rwLock.AcquireReaderLock(timeout);
try
{
collection.CopyTo(array);
}
finally
{
rwLock.ReleaseReaderLock();
}
}
public override void CopyTo(eServiceCategory[] array)
{
rwLock.AcquireReaderLock(timeout);
try
{
collection.CopyTo(array);
}
finally
{
rwLock.ReleaseReaderLock();
}
}
public override void CopyTo(PreviousPayment[] array)
{
rwLock.AcquireReaderLock(timeout);
try
{
collection.CopyTo(array);
}
finally
{
rwLock.ReleaseReaderLock();
}
}
/// <summary>
/// Recupera a classe dinâmica associada com as propriedades informada.
/// </summary>
/// <param name="properties"></param>
/// <returns></returns>
public Type GetDynamicClass(IEnumerable <DynamicProperty> properties)
{
rwLock.AcquireReaderLock(System.Threading.Timeout.Infinite);
try
{
Signature signature = new Signature(properties);
Type type;
if (!classes.TryGetValue(signature, out type))
{
type = CreateDynamicClass(signature.Properties);
classes.Add(signature, type);
}
return(type);
}
finally
{
rwLock.ReleaseReaderLock();
}
}
/// <summary>
/// 释放读者锁
/// </summary>
public void ReleaseReaderLock()
{
m_lock.ReleaseReaderLock();
}
