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

 /// <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 bool Equals (LockCookie obj)
		{
			if (this.ThreadId == obj.ThreadId &&
			    this.ReaderLocks == obj.ReaderLocks &&
			    this.WriterLocks == obj.WriterLocks) {
				return(true);
			} else {
				return(false);
			}
		}

 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 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 LockCookie UpgradeToWriterLock(int millisecondsTimeout)
 {
     LockCookie result = new LockCookie();
     this.FCallUpgradeToWriterLock(ref result, millisecondsTimeout);
     return result;
 }

 private extern void RestoreLockInternal(ref LockCookie lockCookie);

 public void RestoreLock(ref LockCookie lockCookie)
 {
     this.RestoreLockInternal(ref 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 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)
		{
			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 RestoreLock(ref LockCookie lockCookie)
 {
 }

 private extern void FCallReleaseLock(ref LockCookie result);

 public LockCookie ReleaseLock()
 {
     LockCookie result = new LockCookie();
     this.FCallReleaseLock(ref result);
     return result;
 }

 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 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)
 {
     this.DowngradeFromWriterLockInternal(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;
        }

 private extern void DowngradeFromWriterLockInternal(ref LockCookie lockCookie);

 public void DowngradeFromWriterLock(ref LockCookie lockCookie)
 {
 }