public static void Animate(Image image, EventHandler onFrameChangedHandler)
{
if (image != null)
{
ImageInfo item = null;
lock (image)
{
item = new ImageInfo(image);
}
StopAnimate(image, onFrameChangedHandler);
bool isReaderLockHeld = rwImgListLock.IsReaderLockHeld;
LockCookie lockCookie = new LockCookie();
threadWriterLockWaitCount++;
try
{
if (isReaderLockHeld)
{
lockCookie = rwImgListLock.UpgradeToWriterLock(-1);
}
else
{
rwImgListLock.AcquireWriterLock(-1);
}
}
finally
{
threadWriterLockWaitCount--;
}
try
{
if (item.Animated)
{
if (imageInfoList == null)
{
imageInfoList = new List<ImageInfo>();
}
item.FrameChangedHandler = onFrameChangedHandler;
imageInfoList.Add(item);
if (animationThread == null)
{
animationThread = new Thread(new ThreadStart(ImageAnimator.AnimateImages50ms));
animationThread.Name = typeof(ImageAnimator).Name;
animationThread.IsBackground = true;
animationThread.Start();
}
}
}
finally
{
if (isReaderLockHeld)
{
rwImgListLock.DowngradeFromWriterLock(ref lockCookie);
}
else
{
rwImgListLock.ReleaseWriterLock();
}
}
}
}
private void LockAndGet <T>(T data)
{
try {
//ロックを取得する
_rwLock.AcquireReaderLock(_timeout);
//Double-Checked Lockingパターン
if (data == null)
{
System.Threading.LockCookie aLockCookie = default(System.Threading.LockCookie);
try {
aLockCookie = _rwLock.UpgradeToWriterLock(_timeout);
if (data == null)
{
_callFromMe = true;
//初期化用SELECT文を発行し、同じViewInfoに属する他全てのView列と共にメタ情報を取得する
_aViewInfo.RegistAllColumnsType();
}
} finally {
_callFromMe = false;
_rwLock.DowngradeFromWriterLock(ref aLockCookie);
}
}
//RegistAllColumnsType()で登録した値は仮引数であるdataには反映されないことに注意
//Return data
} finally {
//ロックを開放する
_rwLock.ReleaseReaderLock();
}
}
public LockCookie UpgradeToWriterLock(int millisecondsTimeout)
{
LockCookie result = new LockCookie();
this.FCallUpgradeToWriterLock(ref result, millisecondsTimeout);
return(result);
}
/// <summary>
/// Execute the action under a write lock
/// </summary>
/// <param name="cacheAction">The cache action.</param>
public void WriteLock(CacheAction cacheAction)
{
if(readerWriterLock.IsWriterLockHeld)
{
cacheAction();
return;
}
bool readerLockHeld = readerWriterLock.IsReaderLockHeld;
LockCookie writerLock = new LockCookie();
if (readerLockHeld)
{
writerLock = readerWriterLock.UpgradeToWriterLock(Timeout.Infinite);
}
else
readerWriterLock.AcquireWriterLock(Timeout.Infinite);
try
{
cacheAction();
}
finally
{
if (readerLockHeld)
readerWriterLock.DowngradeFromWriterLock(ref writerLock);
else
readerWriterLock.ReleaseWriterLock();
}
}
public LockCookie ReleaseLock()
{
LockCookie result = new LockCookie();
this.FCallReleaseLock(ref result);
return(result);
}
/// <summary>指定当前实例是否等于指定的 <see cref="T:System.Threading.LockCookie" />。</summary>
/// <returns>如果 <paramref name="obj" /> 等于当前实例的值，则为 true；否则为 false。</returns>
/// <param name="obj">要与当前实例进行比较的 <see cref="T:System.Threading.LockCookie" />。</param>
public bool Equals(LockCookie obj)
{
if (obj._dwFlags == this._dwFlags && obj._dwWriterSeqNum == this._dwWriterSeqNum && obj._wReaderAndWriterLevel == this._wReaderAndWriterLevel)
{
return(obj._dwThreadID == this._dwThreadID);
}
return(false);
}
public bool Equals(LockCookie obj)
{
return
(_flags == obj._flags &&
_readerLevel == obj._readerLevel &&
_writerLevel == obj._writerLevel &&
_threadID == obj._threadID);
}
public static void Fade(object caller, EventHandler onFadeChangedHandler)
{
if (caller != null)
{
FadeAnimator.FadeInfo fadeInfo = null;
lock (caller)
{
fadeInfo = new FadeAnimator.FadeInfo(caller);
}
FadeAnimator.StopFade(caller, onFadeChangedHandler);
bool flag1 = FadeAnimator.rwImgListLock.IsReaderLockHeld;
LockCookie cookie1 = new LockCookie();
FadeAnimator.threadWriterLockWaitCount++;
try
{
if (flag1)
{
cookie1 = FadeAnimator.rwImgListLock.UpgradeToWriterLock(-1);
}
else
{
FadeAnimator.rwImgListLock.AcquireWriterLock(-1);
}
}
finally
{
FadeAnimator.threadWriterLockWaitCount--;
}
try
{
if (FadeAnimator.fadeInfoList == null)
{
FadeAnimator.fadeInfoList = new ArrayList();
}
fadeInfo.FadeChangedHandler = onFadeChangedHandler;
FadeAnimator.fadeInfoList.Add((FadeAnimator.FadeInfo)fadeInfo);
if (FadeAnimator.fadeThread == null)
{
FadeAnimator.fadeThread = new Thread(new ThreadStart(FadeAnimator.AnimateFade50ms));
FadeAnimator.fadeThread.Name = typeof(FadeAnimator).Name;
FadeAnimator.fadeThread.IsBackground = true;
FadeAnimator.fadeThread.Start();
}
}
finally
{
if (flag1)
{
FadeAnimator.rwImgListLock.DowngradeFromWriterLock(ref cookie1);
}
else
{
FadeAnimator.rwImgListLock.ReleaseWriterLock();
}
}
}
}
public bool Equals (LockCookie obj)
{
if (this.ThreadId == obj.ThreadId &&
this.ReaderLocks == obj.ReaderLocks &&
this.WriterLocks == obj.WriterLocks) {
return(true);
} else {
return(false);
}
}
public void RestoreLock(ref LockCookie lockCookie)
{
lock (this) {
if (lockCookie.WriterLocks != 0)
{
AcquireWriterLock(-1, lockCookie.WriterLocks);
}
else if (lockCookie.ReaderLocks != 0)
{
AcquireReaderLock(-1, lockCookie.ReaderLocks);
}
}
}
/// <summary>Restores the lock status of the thread to what it was before <see cref="M:System.Threading.ReaderWriterLock.UpgradeToWriterLock(System.Int32)" /> was called.</summary>
/// <param name="lockCookie">A <see cref="T:System.Threading.LockCookie" /> returned by <see cref="M:System.Threading.ReaderWriterLock.UpgradeToWriterLock(System.Int32)" />. </param>
/// <exception cref="T:System.ApplicationException">The thread does not have the writer lock. </exception>
/// <exception cref="T:System.NullReferenceException">The address of <paramref name="lockCookie" /> is a null pointer. </exception>
/// <filterpriority>2</filterpriority>
public void DowngradeFromWriterLock(ref LockCookie lockCookie)
{
lock (this)
{
if (!this.HasWriterLock())
{
throw new ApplicationException("The thread does not have the writer lock.");
}
this.state = lockCookie.ReaderLocks;
this.reader_locks[Thread.CurrentThreadId] = this.state;
if (this.readers > 0)
{
Monitor.PulseAll(this);
}
}
}
private void AcquireLock()
{
switch (_mode)
{
case LockMode.Read:
_lock.AcquireReaderLock(_timeout);
break;
case LockMode.UpgrateToWrite:
_cookie = _lock.UpgradeToWriterLock(_timeout);
break;
case LockMode.Write:
_lock.AcquireWriterLock(_timeout);
break;
}
Logger.TraceFormat("lock {0} acured", _mode);
}
public LockingObject(ReaderWriterLock _lock, AccessMode _lockMode)
{
this.readerWriterLock = _lock;
this.accessMode = _lockMode;
if (this.accessMode == AccessMode.Read)
{
this.readerWriterLock.AcquireReaderLock(-1);
}
else if (this.accessMode == AccessMode.Write)
{
this.readerWriterLock.AcquireWriterLock(-1);
}
else //UpAndDowngrade
{
this.lockCookie = this.readerWriterLock.UpgradeToWriterLock(-1);
}
}
LockCookie GetLockCookie()
{
LockCookie cookie = new LockCookie(Thread.CurrentThreadId);
if (HasWriterLock())
{
cookie.WriterLocks = -state;
}
else
{
object locks = reader_locks [Thread.CurrentThreadId];
if (locks != null)
{
cookie.ReaderLocks = (int)locks;
}
}
return(cookie);
}
private LockCookie GetLockCookie()
{
LockCookie result = new LockCookie(Thread.CurrentThreadId);
if (this.HasWriterLock())
{
result.WriterLocks = -this.state;
}
else
{
object obj = this.reader_locks[Thread.CurrentThreadId];
if (obj != null)
{
result.ReaderLocks = (int)obj;
}
}
return(result);
}
public void DowngradeFromWriterLock(ref LockCookie lockCookie)
{
lock (this) {
if (!HasWriterLock())
{
throw new ApplicationException("The thread does not have the writer lock.");
}
state = lockCookie.ReaderLocks;
reader_locks [Thread.CurrentThreadId] = state;
if (readers > 0)
{
Monitor.PulseAll(this);
}
// MSDN: A thread does not block when downgrading from the writer lock,
// even if other threads are waiting for the writer lock
}
}
public void Remove(IPAddr ip)
{
try
{
locker.AcquireReaderLock(new TimeSpan(0, 1, 0));
try
{
if (list.ContainsKey(ip))
{
LockCookie lc = new LockCookie();
try
{
lc = locker.UpgradeToWriterLock(new TimeSpan(0, 1, 0));
try
{
list.Remove(ip);
}
finally
{
locker.DowngradeFromWriterLock(ref lc);
}
}
catch (ApplicationException e)
{
Logging.LogCenter.Instance.LogException(e);
}
}
}
finally
{
locker.ReleaseReaderLock();
}
}
catch (ApplicationException aex)
{
Logging.LogCenter.Instance.LogException(aex);
}
}
public static void UnregisterMessageClient(IMessageHandlerClient client)
{
if (m_Clients.Contains(client))
{
LockCookie cookie1 = new LockCookie();
bool readerLockHeld = MessageHandler.rwClientsListLock.IsReaderLockHeld;
if (readerLockHeld)
{
cookie1 = MessageHandler.rwClientsListLock.UpgradeToWriterLock(-1);
}
else
{
MessageHandler.rwClientsListLock.AcquireWriterLock(-1);
}
bool unregister = false;
try
{
m_Clients.Remove(client);
unregister = m_Clients.Count == 0;
}
finally
{
if (readerLockHeld)
{
MessageHandler.rwClientsListLock.DowngradeFromWriterLock(ref cookie1);
}
else
{
MessageHandler.rwClientsListLock.ReleaseWriterLock();
}
}
if (BarUtilities.AutoRemoveMessageFilter && unregister && m_FilterOnThread.ContainsKey(System.Threading.Thread.CurrentThread.GetHashCode()))
UninstallMessageFilter();
}
}
public static void RegisterHook(ISkinHook client)
{
if (m_Clients.Contains(client))
return;
if (!m_FilterOnThread.ContainsKey(System.Threading.Thread.CurrentThread.GetHashCode()))
HookThread();
LockCookie cookie1 = new LockCookie();
bool readerLockHeld = NonClientHook.rwClientsListLock.IsReaderLockHeld;
if (readerLockHeld)
{
cookie1 = NonClientHook.rwClientsListLock.UpgradeToWriterLock(-1);
}
else
{
NonClientHook.rwClientsListLock.AcquireWriterLock(-1);
}
try
{
m_Clients.Add(client);
}
finally
{
if (readerLockHeld)
{
NonClientHook.rwClientsListLock.DowngradeFromWriterLock(ref cookie1);
}
else
{
NonClientHook.rwClientsListLock.ReleaseWriterLock();
}
}
}
public static void RegisterMessageClient(IMessageHandlerClient client)
{
if(m_Clients.Contains(client))
return;
if(!m_FilterOnThread.ContainsKey(System.Threading.Thread.CurrentThread.GetHashCode()))
InstallMessageFilter();
LockCookie cookie1 = new LockCookie();
bool readerLockHeld = MessageHandler.rwClientsListLock.IsReaderLockHeld;
if (readerLockHeld)
{
cookie1 = MessageHandler.rwClientsListLock.UpgradeToWriterLock(-1);
}
else
{
MessageHandler.rwClientsListLock.AcquireWriterLock(-1);
}
try
{
m_Clients.Add(client);
}
finally
{
if (readerLockHeld)
{
MessageHandler.rwClientsListLock.DowngradeFromWriterLock(ref cookie1);
}
else
{
MessageHandler.rwClientsListLock.ReleaseWriterLock();
}
}
}
private extern void FCallReleaseLock(ref LockCookie result);
public void DowngradeFromWriterLock(ref LockCookie lockCookie)
{
lock (this) {
if (!HasWriterLock())
throw new ApplicationException ("The thread does not have the writer lock.");
state = lockCookie.ReaderLocks;
reader_locks [Thread.CurrentThreadId] = state;
if (readers > 0) {
Monitor.PulseAll (this);
}
// MSDN: A thread does not block when downgrading from the writer lock,
// even if other threads are waiting for the writer lock
}
}
/// <summary>Indicates whether the current instance is equal to the specified <see cref="T:System.Threading.LockCookie" />.</summary>
/// <returns>true if <paramref name="obj" /> is equal to the value of the current instance; otherwise, false.</returns>
/// <param name="obj">The <see cref="T:System.Threading.LockCookie" /> to compare to the current instance.</param>
public bool Equals(LockCookie obj)
{
return(this.ThreadId == obj.ThreadId && this.ReaderLocks == obj.ReaderLocks && this.WriterLocks == obj.WriterLocks);
}
public bool Equals(LockCookie obj)
{
return(default(bool));
}
public bool Load()
{
try
{
LockCookie upgrade = new LockCookie();
bool upgraded = false;
if (locker.IsReaderLockHeld)
{
upgrade = locker.UpgradeToWriterLock(new TimeSpan(0, 1, 0));
upgraded = true;
}
else
locker.AcquireWriterLock(new TimeSpan(0, 1, 0));
try
{
try
{
if (File.Exists(ConfigurationManagement.Instance.ConfigurationPath + Path.DirectorySeparatorChar + "IPLists.cfg"))
{
XmlSerializer serializer = new XmlSerializer(typeof(SerializableDictionary<string, IPList>));
TextReader reader = new StreamReader(ConfigurationManagement.Instance.ConfigurationPath + Path.DirectorySeparatorChar + "IPLists.cfg");
iplists = (SerializableDictionary<string, IPList>)serializer.Deserialize(reader);
reader.Close();
reader.Dispose();
}
else
{
iplists = new SerializableDictionary<string,IPList>();
}
}
catch (Exception e)
{
Logging.LogCenter.Instance.LogException(e);
iplists = new SerializableDictionary<string, IPList>();
}
}
finally
{
if (upgraded)
locker.DowngradeFromWriterLock(ref upgrade);
else
locker.ReleaseWriterLock();
}
return true;
}
catch (ApplicationException ex)
{
Logging.LogCenter.Instance.LogException(ex);
return false;
}
}
public void RestoreLock(ref LockCookie lockCookie)
{
}
private extern void RestoreLockInternal(ref LockCookie lockCookie);
LockCookie GetLockCookie ()
{
LockCookie cookie = new LockCookie (Thread.CurrentThreadId);
if (HasWriterLock())
cookie.WriterLocks = -state;
else {
object locks = reader_locks [Thread.CurrentThreadId];
if (locks != null) cookie.ReaderLocks = (int)locks;
}
return cookie;
}
public extern void RestoreLock(ref LockCookie lockCookie);
public void RestoreLock(ref LockCookie lockCookie)
{
throw new NotImplementedException();
}
private extern void FCallUpgradeToWriterLock(ref LockCookie result, int millisecondsTimeout);
public void DowngradeFromWriterLock(ref LockCookie lockCookie)
{
this.DowngradeFromWriterLockInternal(ref lockCookie);
}
public void DowngradeFromWriterLock(ref LockCookie lockCookie)
{
}
public void RestoreLock(ref LockCookie lockCookie)
{
}
public void AddToList(string list, IPAddr ip)
{
try
{
LockCookie upgrade = new LockCookie();
bool upgraded = false;
if (locker.IsReaderLockHeld)
{
upgrade = locker.UpgradeToWriterLock(new TimeSpan(0, 1, 0));
upgraded = true;
}
else
locker.AcquireWriterLock(new TimeSpan(0, 1, 0));
try
{
if (!iplists.ContainsKey(list))
{
iplists[list] = new IPList();
}
iplists[list].Add(ip);
}
finally
{
if (upgraded)
locker.DowngradeFromWriterLock(ref upgrade);
else
locker.ReleaseWriterLock();
}
}
catch (ApplicationException a)
{
Logging.LogCenter.Instance.LogException(a);
}
}
public void DowngradeFromWriterLock(ref LockCookie lockCookie)
{
}
private extern void FCallReleaseLock(ref LockCookie result);
public bool Equals(LockCookie obj)
{
return((((obj._dwFlags == this._dwFlags) && (obj._dwWriterSeqNum == this._dwWriterSeqNum)) && (obj._wReaderAndWriterLevel == this._wReaderAndWriterLevel)) && (obj._dwThreadID == this._dwThreadID));
}
public LockCookie ReleaseLock()
{
LockCookie result = new LockCookie();
this.FCallReleaseLock(ref result);
return result;
}
public extern void DowngradeFromWriterLock(ref LockCookie lockCookie);
public void Upgrade()
{
if (_lockMode != IICLockMode.ReaderLock)
throw new InvalidOperationException("lock mode can't upgraded:" + _lockMode);
_lockCookie = _innerLock.UpgradeToWriterLock(_msTimeout);
_lockMode = IICLockMode.UpdatedWriterLock;
}
public void DowngradeFromWriterLock(ref LockCookie lockCookie)
{
this.DowngradeFromWriterLockInternal(ref lockCookie);
}
public void DowngradeFromWriterLock(ref LockCookie lc)
{
this.ExitWriteLock();
}
private extern void DowngradeFromWriterLockInternal(ref LockCookie lockCookie);
public void RestoreLock(ref LockCookie lockCookie)
{
lock (this) {
if (lockCookie.WriterLocks != 0)
AcquireWriterLock (-1, lockCookie.WriterLocks);
else if (lockCookie.ReaderLocks != 0)
AcquireReaderLock (-1, lockCookie.ReaderLocks);
}
}
public void DowngradeFromWriterLock(ref LockCookie lockCookie)
{
throw new NotImplementedException();
}
public void RestoreLock(ref LockCookie lockCookie)
{
this.RestoreLockInternal(ref lockCookie);
}
/// <summary>
/// Returns a DataTable from the Cache.
///
/// </summary>
/// <param name="ACacheableTableName">Name of the DataTable</param>
/// <param name="AType"></param>
/// <returns>DataTable from the Cache</returns>
/// <exception cref="ECacheableTablesMgrTableNotUpToDateException">if the Cacheable
/// DataTable isn't in an up-to-date state. This means it needs to be retrieved
/// anew before it can be used
/// </exception>
public DataTable GetCachedDataTable(String ACacheableTableName, out System.Type AType)
{
CacheableTablesTDSContentsRow ContentsEntryDR;
DataTable TmpTable;
System.Type CachedDataTableType;
LockCookie UpgradeLockCookie = new LockCookie();
// Variable initialisation (just to prevent compiler warnings)
TmpTable = new DataTable();
CachedDataTableType = new System.Data.DataTable().GetType();
try
{
TLogging.LogAtLevel(10, "TCacheableTablesManager.GetCachedDataTable waiting for a ReaderLock...");
// Try to get a read lock [We don't specify a timeout because reading the DB tables into the cached table should be fairly quick]
FReadWriteLock.AcquireReaderLock(SharedConstants.THREADING_WAIT_INFINITE);
TLogging.LogAtLevel(10, "TCacheableTablesManager.GetCachedDataTable grabbed a ReaderLock.");
if (!UDataCacheDataSet.Tables.Contains(ACacheableTableName))
{
throw new ECacheableTablesMgrException(
"TCacheableTablesManager.GetCachedDataTable: Cacheable DataTable '" + ACacheableTableName + "' does not exist in Cache");
}
ContentsEntryDR = GetContentsEntry(ACacheableTableName); // GetContentsEntry reuses the ReaderLock
if (ContentsEntryDR != null)
{
if (ContentsEntryDR.DataUpToDate)
{
try
{
TLogging.LogAtLevel(10, "TCacheableTablesManager.GetCachedDataTable waiting for upgrading to a WriterLock...");
// Need to temporarily upgrade to a write lock to prevent other threads from obtaining a read lock on the cache table while we are modifying the Cache Contents table!
UpgradeLockCookie = FReadWriteLock.UpgradeToWriterLock(SharedConstants.THREADING_WAIT_INFINITE);
TLogging.LogAtLevel(10, "TCacheableTablesManager.GetCachedDataTable upgraded to a WriterLock.");
ContentsEntryDR.LastAccessed = DateTime.Now;
}
finally
{
TLogging.LogAtLevel(10, "TCacheableTablesManager.GetCachedDataTable waiting for downgrading to a ReaderLock...");
// Downgrade from a WriterLock to a ReaderLock again!
FReadWriteLock.DowngradeFromWriterLock(ref UpgradeLockCookie);
TLogging.LogAtLevel(10, "TCacheableTablesManager.GetCachedDataTable downgraded to a ReaderLock.");
}
}
else
{
throw new ECacheableTablesMgrTableNotUpToDateException(ACacheableTableName);
}
}
/*
* To get around multi-threading reading/writing issues that might occur
* when the caller of this function performs read or write operations on the
* DataTable, we must return only a *copy* of the DataTable, not a reference
* to the DataTable!
*/
TmpTable = UDataCacheDataSet.Tables[ACacheableTableName].Copy();
CachedDataTableType = UDataCacheDataSet.Tables[ACacheableTableName].GetType();
}
finally
{
// Release read lock
FReadWriteLock.ReleaseReaderLock();
TLogging.LogAtLevel(10, "TCacheableTablesManager.GetCachedDataTable released the ReaderLock.");
}
if (TmpTable is TTypedDataTable)
{
// The Copy needs to be a typed DataTable, so we need to type it
DataUtilities.ChangeDataTableToTypedDataTable(ref TmpTable, CachedDataTableType, "");
}
TLogging.LogAtLevel(7, "TCacheableTablesManager.GetCachedDataTable: Returned Type: " + TmpTable.GetType().FullName);
AType = TmpTable.GetType();
return TmpTable;
}
public LockCookie UpgradeToWriterLock(int millisecondsTimeout)
{
LockCookie result = new LockCookie();
this.FCallUpgradeToWriterLock(ref result, millisecondsTimeout);
return result;
}
public WriteLatch(ReaderWriterLock lck, int timeout)
{
_mutex = lck;
if (_mutex.IsReaderLockHeld)
{
_upgraded = true;
_cookie = lck.UpgradeToWriterLock(timeout);
}
else
{
_upgraded = false;
lck.AcquireWriterLock(timeout);
}
}
private extern void DowngradeFromWriterLockInternal(ref LockCookie lockCookie);
public void RestoreLock(ref LockCookie lockCookie)
{
this.RestoreLockInternal(ref lockCookie);
}
private extern void FCallUpgradeToWriterLock(ref LockCookie result, int millisecondsTimeout);
private extern void RestoreLockInternal(ref LockCookie lockCookie);
public bool Equals(LockCookie obj)
{
return obj._dwFlags == _dwFlags && obj._dwWriterSeqNum == _dwWriterSeqNum &&
obj._wReaderAndWriterLevel == _wReaderAndWriterLevel && obj._dwThreadID == _dwThreadID;
}
/// <summary>Indicates whether the current instance is equal to the specified <see cref="T:System.Threading.LockCookie" />.</summary><returns>true if <paramref name="obj" /> is equal to the value of the current instance; otherwise, false.</returns><param name="obj">The <see cref="T:System.Threading.LockCookie" /> to compare to the current instance.</param>
public bool Equals(LockCookie obj)
{
throw new NotImplementedException();
}