public abstract class AsyncWorker
    {
        public enum WorkState{Ready, Working, Pause,Resume,Aborted, Done, Error}

        private WorkState m_State;
        private bool m_Wait;
        private Thread m_Thread;

        protected AsyncWorker(bool wait)
        {
            m_State = WorkState.Ready;
            m_Wait = wait;
            m_Thread = new Thread(new ThreadStart(Work));
        }

        public void Start()
        {
            OnStateChangedSync(WorkState.Ready);
            m_Thread.Start();
            while( m_Wait && m_Thread.IsAlive )
            {
                OnIdle();
                Thread.Sleep(200);
            }
        }

        public void Pause()
        {
            if( m_State == WorkState.Working)
            {
                m_Thread.Suspend();
                m_State = WorkState.Pause;
                OnStateChanged(WorkState.Pause);
            }
        }

        public void Resume()
        {
            if( m_State == WorkState.Pause )
            {
                m_State = WorkState.Working;
                m_Thread.Resume();
                OnStateChanged(WorkState.Resume);
            }
        }

        public void Abort()
        {
            if( m_State == WorkState.Working || m_State == WorkState.Pause )
            {
                m_Thread.Abort();
                m_State = WorkState.Aborted;
                OnStateChanged(WorkState.Aborted);
            }
        }

        private void Work()
        {
            try
            {
                m_State = WorkState.Working;
                OnStateChangedSync(WorkState.Working);

                DoWork();

                m_State = WorkState.Done;
                OnStateChanged(WorkState.Done);
            }
            catch (Exception e)
            {
                m_State = WorkState.Error;
                OnError(e);
                OnStateChanged(WorkState.Error);
            }
        }

        protected abstract void DoWork();

        private void OnStateChangedSync(WorkState state)
        {
            if( StateChanged != null )
                StateChanged(this, state);
        }

        private void OnStateChanged(WorkState state)
        {
            if( StateChanged != null )
                StateChanged.BeginInvoke(this, state, null, null);
        }

        protected void OnIdle()
        {
            if( Idle != null )
            {
                lock(this)        // 有可能会很高频率调用
                    Idle(this);
            }
        }

        protected void OnError(Exception e)
        {
            if( Error != null )
                Error.BeginInvoke(this, e, null, null);
        }

        public delegate void StateChangedEventHandler(AsyncWorker sender, WorkState state);
        public delegate void IdleEventHandler(AsyncWorker sender);
        public delegate void ErrorEventHandler(AsyncWorker sender, Exception e);

        public event StateChangedEventHandler StateChanged;
        public event IdleEventHandler Idle;
        public event ErrorEventHandler Error;
    }

    /**//// <summary>
    /// 反映进度的变化的接口
    /// </summary>
    public interface IProgress
    {
        int Total{get;}
        int CurrentProgress{get;}
        string Description{get;}
    }

    public class ProgressMoniter : AsyncWorker
    {
        public delegate void ProgressEventHandler(string text, int percent);

        public event ProgressEventHandler Progress;

        IProgress m_Progress;
        private bool m_Exit;

        public bool Exit { get { return m_Exit; } set { m_Exit = value; } }

        public ProgressMoniter(IProgress progress) : base(false)
        {
            m_Progress = progress;
            m_Exit = false;
        }

        protected override void DoWork()
        {
            while( !m_Exit )
            {
                lock(m_Progress)
                    OnProgress(m_Progress.Description, m_Progress.Total, m_Progress.CurrentProgress);
                Thread.Sleep(200);
            }
        }

        private void OnProgress(string description, int total, int progress)
        {
            if( Progress != null )
                Progress.BeginInvoke(description, (int)((long)progress * 100 / (long)total), null, null);
        }
    }