C#

Chesnokov Yuriy wrote:

Only if the function is non-blocking it would be possible that a second timer event arrives before previous RunWorkerAsync completed.

using System;
using System.ComponentModel;
using System.Threading;

namespace DaveyM69.ComponentModel
{
    [DefaultEvent("DoWork")]
    [DefaultProperty("WorkerReportsProgress")]
    public class SaferBackgroundWorker : Component
    {
        public event DoWorkEventHandler DoWork;
        public event ProgressChangedEventHandler ProgressChanged;
        public event RunWorkerCompletedEventHandler RunWorkerCompleted;

        private bool cancellationPending;
        private bool isBusy;
        private AsyncOperation operation;
        private SendOrPostCallback operationCompleted;
        private SendOrPostCallback progressReporter;
        private object syncLock = new object();
        private bool workerReportsProgress;
        private bool workerSupportsCancellation;
        private ParameterizedThreadStart workerThreadStart;

        public SaferBackgroundWorker()
        {
            cancellationPending = false;
            isBusy = false;
            operation = null;
            operationCompleted = new SendOrPostCallback(OperationCompleted);
            progressReporter = new SendOrPostCallback(ProgressReporter);
            workerReportsProgress = false;
            workerSupportsCancellation = false;
            workerThreadStart = new ParameterizedThreadStart(WorkerThreadStart);
        }

        [Browsable(false)]
        public bool CancellationPending
        {
            get { lock (syncLock) { return cancellationPending; } }
        }
        [Browsable(false)]
        public bool IsBusy
        {
            get { lock (syncLock) { return isBusy; } }
        }
        [DefaultValue(false)]
        public bool WorkerReportsProgress
        {
            get { lock (syncLock) { return workerReportsProgress; } }
            set { lock (syncLock) { workerReportsProgress = value; } }
        }
        [DefaultValue(false)]
        public bool WorkerSupportsCancellation
        {
            get { lock (syncLock) { return workerSupportsCancellation; } }
            set { lock (syncLock) { workerSupportsCancellation = value; } }
        }

        public void CancelAsync()
        {
            if (!WorkerSupportsCancellation)
                throw new InvalidOperationException("Worker doesn't support cancellation");
            SetCancellationPending(true);
        }
        protected virtual void OnDoWork(DoWorkEventArgs e)
        {
            DoWorkEventHandler eh = DoWork;
            if (eh != null)
                eh(this, e);
        }
        protected virtual void OnProgressChanged(ProgressChangedEventArgs e)
        {
            ProgressChangedEventHandler eh = ProgressChanged;
            if (eh != null)
                eh(this, e);
        }
        protected virtual void OnRunWorkerCompleted(RunWorkerCompletedEventArgs e)
        {
            RunWorkerCompletedEventHandler eh = RunWorkerCompleted;
            if (eh != null)
                eh(this, e);
        }
        private void OperationCompleted(object state)
        {
            SetIsBusy(false);
            SetCancellationPending(false);
            OnRunWorkerCompleted((RunWorkerCompletedEventArgs)state);
        }
        private void ProgressReporter(object state)
        {
            OnProgressChanged((ProgressChangedEventArgs)state);
        }
        public void ReportProgress(int percentProgress)
        {
            ReportProgress(percentProgress, null);
        }
        public void ReportProgress(int percentProgress, object userState)
        {
            if (!WorkerReportsProgress)
                throw new InvalidOperationException("Worker doesn't report progress");
            ProgressChangedEventArgs arg = new ProgressChangedEventArgs(percentProgress, userState);
            if (operation == null)
                progressReporter(arg);
            else
                operation.Post(progressReporter, arg);
        }
        public void RunWorkerAsync()
        {
            RunWorkerAsync(null);
        }
        public void RunWorkerAsync(object argument)
        {
            if (IsBusy)
                throw new InvalidOperationException("Worker is busy");
            SetIsBusy(true);
            SetCancellationPending(false);
            operation = AsyncOperationManager.CreateOperation(null);
            workerThreadStart.BeginInvoke(argument, null, null);
        }
        private void SetCancellationPending(bool value)
        {
            lock (syncLock) { cancellationPending = value; }
        }
        private void SetIsBusy(bool value)
        {
            lock (syncLock) { isBusy = value; }
        }
        private void WorkerThreadStart(object obj)
        {
            object result = null;
            Exception error = null;
            bool cancelled = false;
            try
            {
                DoWorkEventArgs doWorkArgs = new DoWorkEventArgs(obj);
                OnDoWork(doWorkArgs);
                if (doWorkArgs.Cancel)
                    cancelled = true;
                else
                    result = doWorkArgs.Result;
            }
            catch (Exception exception)
            {
                error = exception;
            }
            RunWorkerCompletedEventArgs e = new RunWorkerCompletedEventArgs(result, error, cancelled);
            operation.PostOperationCompleted(operationCompleted, e);
        }
    }
}

for (int i = 0; i < this.drives.Count; i++)
{
    if (this.drvBackgroundWorkers[i].IsBusy == false)
    {
         BackgroundWorkerArgument argument = new BackgroundWorkerArgument()
         {
             threadId = i,
             drive = this.drives[i]
         };
         this.drvBackgroundWorkers[i].RunWorkerAsync(argument);
    }                                
}

System.Threading.Timer timer;
int count;

public override void Test(int arg) {
    timer=new System.Threading.Timer(new TimerCallback(ticker), null, 30, 30);
}

protected void output(string s) {
    Console.WriteLine(DateTime.Now.ToString("HH:mm:ss.fff ")+s);
}

public void ticker(object dummy) {
    output("ticker("+count+") start");
    for (int i=0; i<10000000; i++) { } // waste time, simulate loaded system
    output("ticker("+count+") stop");
    count++;
    if (count>10) {
        timer.Change(Timeout.Infinite, Timeout.Infinite);
        output("done");
    }
}