How do I make a BackgroundWorker that lives with Application respond to Events sent from UI thread?

Question

I am writing a WinForms application. I will have 2 threads, a UI thread and Operation thread. The UI thread produces Control events, and I want the Operation thread to consume them. The Operation thread is automated and will run Tasks for hardware control concurrently with the consumption of new events. Control events are but not limited to Start/Stop the automation

I am using BackgroundWorker because my Operation thread will also update the UI in the MVP architecture style.

Example of what I'd like, simplified for brevity.

public class UI : Form
{
    Operation _operation;
    BackgroundWorker _operationBackgroundWorker;
    
    public UI_Load(object sender, EventArgs e)
    {
        _operationBackgroundWorker.RunWorkerAsync();
    }
    
    private void operationBackgroundWorkerDoWork(object sender, DoWorkEventArgs e)
    {
        BackgroundWorker worker = sender as BackgroundWorker;
        _operation.DoWorkAsync(worker);
    }
    
    private void operationBackgroundWorkerRunWorkerCompleted(object sender, RunWorkerCompletedEventArgs e)
    {
        // Only executed if something fails.
    }
    
    private void btnStart_Click(object sender, EventArgs e)
    {
        /* Much later in the Application lifecycle,
         * somehow trigger an event on operation thread
         * to begin operation.
         */
    }
}

/* The operation thread. This code must run as long as the 
 * application is open, or until a critical error occurs.
 */
public class Operation
{
    public async Task DoWorkAsync(BackgroundWorker worker)
    {
        // Live as long as the application and consume
        // user control events fired by UI thread.
        while (!worker.CancellationPending)
        {
            /* Make thread "sleep" until an event is triggered.
             * It should be possible to fire an event while another
             * operation is in progress such as stop or manual
             * override (a Queue). Operation thread also uses a
             * BackgroundWorker to execute hardware commands
             * to not block Event queue execution.
             */
             
             // Example operation
             foreach (var event in eventQueue)
             {
                switch (event)
                {
                    case Start:
                        // Run concurrently, for loop moves on
                        // to next event.
                        _automationWorker.RunWorkAsync();
                        // Uses Control.BeginInvoke() on controls
                        // to not block itself.
                        ControlView.ChangeControlToPause();
                    case Pause:
                        PauseAutomationWorker();
                        ControlView.ChangeControlToResume();
                    case Stop:
                        StopAutomationWorker();
                        ControlView.ChangeControlToStopped();
                }
             }
        }
    }
}

I have previously written my application with async/await and no separate Operation thread. That did not work because it made the codebase difficult to maintain and (I failed to find the bug) sometimes make the UI hang or not respond to new control inputs. Therefore I am looking for a cleaner alternative.

Answer 1

The BackgroundWorker invokes the DoWork event handler on the ThreadPool. Since your requirement is to have an "Operation thread", I assume that the thread should be dedicated to this purpose only, and so you should use the Thread constructor. As a conveyor belt for passing messages to the Operation thread from the UI thread, you can use a BlockingCollection<T>. Example:

_queue = new BlockingCollection<Command>();
_operationThread = new Thread(() =>
{
    foreach (Command command in _queue.GetConsumingEnumerable())
    {
        switch (command)
        {
            case Command.Start:
                // Do something
                break;
            case Command.Pause:
                // Do something else
                break;
        }
    }
})
{ IsBackground = true };
_operationThread.Start();

From the UI thread:

private void btnStart_Click(object sender, EventArgs e)
{
    _queue.Add(Command.Start);
}

In the FormClosing or FormClosed event of the form:

_queue.CompleteAdding();
_operationThread.Join();

Going the other way around, i.e. passing messages from the Operation thread back to the UI thread, is another story. You shouldn't manipulate UI controls directly from the Operation thread. You could use a Progress<T> instance, or the Control.Invoke/Control.BeginInvoke methods among other ways.