CancelEvent.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading;
 
namespace MyCaffe.basecode
{
    public class CancelEvent : IDisposable
    {
        bool m_bOwnOriginal = true;
        WaitHandle m_hOriginalCancel = null;
        List<Tuple<WaitHandle, bool, string>> m_rgCancel = new List<Tuple<WaitHandle, bool, string>>();
        WaitHandle[] m_rgHandles = new WaitHandle[1];
        string m_strName = null;
        object m_syncObj = new object();
 
        public CancelEvent()
        {
            m_hOriginalCancel = new EventWaitHandle(false, EventResetMode.ManualReset, m_strName);
            setHandles();
        }
 
 
        public CancelEvent(string strGlobalName)
        {
            if (strGlobalName == null)
            {
                m_hOriginalCancel = new EventWaitHandle(false, EventResetMode.ManualReset, m_strName);
            }
            else
            {
                m_strName = strGlobalName;
                m_hOriginalCancel = EventWaitHandle.OpenExisting(strGlobalName, System.Security.AccessControl.EventWaitHandleRights.Synchronize | System.Security.AccessControl.EventWaitHandleRights.Modify);
            }
 
            setHandles();
        }
 
        public CancelEvent(CancelEvent evtCancel)
        {
            m_hOriginalCancel = new EventWaitHandle(false, EventResetMode.ManualReset, m_strName);
            m_rgCancel.Add(new Tuple<WaitHandle, bool, string>(evtCancel.m_hOriginalCancel, false, evtCancel.Name));
            setHandles();
        }
 
        private void setHandles()
        {
            lock (m_syncObj)
            {
                m_rgHandles = new WaitHandle[m_rgCancel.Count + 1];
                m_rgHandles[0] = m_hOriginalCancel;
 
                for (int i = 0; i < m_rgCancel.Count; i++)
                {
                    m_rgHandles[i + 1] = m_rgCancel[i].Item1;
                }
            }
        }
 
        public void AddCancelOverride(string strName)
        {
            EventWaitHandle evtWait = EventWaitHandle.OpenExisting(strName, System.Security.AccessControl.EventWaitHandleRights.Synchronize | System.Security.AccessControl.EventWaitHandleRights.Modify);
 
            if (!Contains(strName))
            {
                m_rgCancel.Add(new Tuple<WaitHandle, bool, string>(evtWait, true, strName));
                setHandles();
            }
        }
 
        public void AddCancelOverride(CancelEvent evtCancel)
        {
            if (!Contains(evtCancel))
            {
                m_rgCancel.Add(new Tuple<WaitHandle, bool, string>(evtCancel.m_hOriginalCancel, false, evtCancel.Name));
                setHandles();
            }
        }
 
        public void AddCancelOverride(WaitHandle evtCancel)
        {
            if (!Contains(evtCancel))
            {
                m_rgCancel.Add(new Tuple<WaitHandle, bool, string>(evtCancel, false, null));
                setHandles();
            }
        }
 
        public bool Contains(CancelEvent evt)
        {
            return Contains(evt.m_hOriginalCancel);
        }
 
        public bool Contains(WaitHandle evt)
        {
            foreach (Tuple<WaitHandle, bool, string> item in m_rgCancel)
            {
                if (item.Item1 == evt)
                    return true;
            }
 
            return false;
        }
 
        public bool Contains(string strName)
        {
            foreach (Tuple<WaitHandle, bool, string> item in m_rgCancel)
            {
                if (item.Item3 == strName)
                    return true;
            }
 
            return false;
        }
 
        public bool RemoveCancelOverride(string strName)
        {
            int nIdx = -1;
            bool bResult = false;
 
            for (int i = 0; i < m_rgCancel.Count; i++)
            {
                if (m_rgCancel[i].Item3 == strName)
                {
                    nIdx = i;
                    break;
                }
            }
 
            if (nIdx >= 0)
            {
                if (m_rgCancel[nIdx].Item2)
                    m_rgCancel[nIdx].Item1.Dispose();
 
                m_rgCancel.RemoveAt(nIdx);
                bResult = true;
            }
 
            setHandles();
 
            return bResult;
        }
 
        public bool RemoveCancelOverride(CancelEvent evtCancel)
        {
            int nIdx = -1;
            bool bResult = false;
 
            for (int i = 0; i < m_rgCancel.Count; i++)
            {
                if (m_rgCancel[i].Item1 == evtCancel.m_hOriginalCancel)
                {
                    nIdx = i;
                    break;
                }
            }
 
            if (nIdx >= 0)
            {
                if (m_rgCancel[nIdx].Item2)
                    m_rgCancel[nIdx].Item1.Dispose();
 
                m_rgCancel.RemoveAt(nIdx);
                bResult = true;
            }
 
            setHandles();
 
            return bResult;
        }
 
        public bool RemoveCancelOverride(WaitHandle evtCancel)
        {
            bool bResult = false;
 
            int nIdx = -1;
 
            for (int i = 0; i < m_rgCancel.Count; i++)
            {
                if (m_rgCancel[i].Item1 == evtCancel)
                {
                    nIdx = i;
                    break;
                }
            }
 
            if (nIdx >= 0)
            {
                m_rgCancel.RemoveAt(nIdx);
                bResult = true;
            }
 
            setHandles();
 
            return bResult;
        }
 
        public string Name
        {
            get { return m_strName; }
        }
 
        public void Set()
        {
            if (m_hOriginalCancel is EventWaitHandle)
                ((EventWaitHandle)m_hOriginalCancel).Set();
        }
 
        public void Reset()
        {
            if (m_hOriginalCancel is EventWaitHandle)
                ((EventWaitHandle)m_hOriginalCancel).Reset();
        }
 
        public bool WaitOne(int nMs = int.MaxValue)
        {
            if (WaitHandle.WaitAny(Handles, nMs) == WaitHandle.WaitTimeout)
                return false;
 
            return true;
        }
 
        public WaitHandle[] Handles
        {
            get
            {
                lock (m_syncObj)
                {
                    return m_rgHandles;
                }
            }
        }
 
        #region IDisposable Support
 
        protected virtual void Dispose(bool disposing)
        {
            if (m_bOwnOriginal && m_hOriginalCancel != null)
            {
                m_hOriginalCancel.Dispose();
                m_hOriginalCancel = null;
            }
 
            foreach (Tuple<WaitHandle, bool, string> item in m_rgCancel)
            {
                if (item.Item2)
                    item.Item1.Dispose();
            }
 
            m_rgCancel.Clear();
            m_rgHandles = null;
        }
 
        public void Dispose()
        {
            Dispose(true);
        }
        #endregion
    }
}