What is the simplest way to do background tasks in Windows.Forms?

Question

Background tasks being stuff that involves network I/O, disk I/O, or other long-running tasks that may or may not take place over a network. It will often intermix with code that updates the GUI, which needs to be running on another thread, the GUI thread.

Simple meaning that when opening a Form.cs file, the source code is as easy or easier to read than before. In practice, the flow of the source code must still read sequentially with regards to the order in which the code is executed, regardless of which thread it executes on. All the supporting fabric must be reusable and hidden away somewhere, rather than being included in each Form.

Googling MSDN: found that the solution officially sanctioned by Microsoft is the System.ComponentModel.BackgroundWorker, which falls (very!) short on the second point.

(There's also an officially sanctioned Silverlight/XAML/3.5 solution model in System.Windows.Threading.Dispatcher.)

Answer 1

You can still use the BackgroundWorker. It does not need to live as a component on the form. You can just as easily wrap it into a class that can then be reused in each of the forms.

However, this will be little different from simply setting up the worker for the background task when needed.

Answer 2

Use BackgroundWorker for that

Answer 3

Can you explain why you say the BackgroundWorker falls short?

In most cases it requires 2-3 extra lines of code.

Answer 4

If you really don't like BackgroundWorker, you could create your own base class for background actions, as I did here.

Answer 5

This is the simplest idea I've come up with so far. It may be entirely un-kosher, I've coded incredibly close to zero Windows.Forms applications.

It involves a helper which has two main methods, Background() and Foreground(). Either of these take a delegate specified in the form of a lambda expression. Background() starts any given delegate on a background thread and returns immediately. Foreground() sends any given delegate "back" to the GUI thread using Form.BeginInvoke() and returns immediately.

In the following is a code example of how to use this design pattern, provided that the helper is already implemented.

public class Form1 : Form {
    protected ProgressBar progressBar1;
    protected Button button1;

    protected BackgroundHelper helper = new BackgroundHelper();

    public void button1_Click(...) {
     // Execute code in the background.
     helper.Background(() => {
      for (int i = 0; i <= 100; i++) {
       // Continually report progress to user.
       helper.Foreground<int>(i, j => {
        progressBar1.Value = j;
       });
       // Simulate doing I/O or whatever.
       Thread.Sleep(25);
      }
     });
    }
}

This keeps the code neatly sequential, provides shared variables in a good place, and allows loops that span the two threads.

To clarify what the helper does,

• The constructor starts a background thread that waits on a queue.
• Both Background() and Foreground() returns immediately.
• Background() enqueues code to run in the background thread using the internal queue.
• Foreground() does the same, with BeginInvoke on the GUI thread that first created the helper.

EDIT: Implementation:
http://code.google.com/p/backgrounder/

Answer 6

Following your question of Disk I/O for example, I wrote an asynchronous File-scanner class recently (or the 100th time over all the years). It's re-usable like you want, by just instantiating a new instance and hooking into the events.

I encapsulated the functionality inside a class that implements cross-thread safety. the class fires off events to notify the caller of updates and when it's complete.

You say that "the source code must still read sequentially with regards to the order in which the code is executed", but realize that threads run parallel to each other. That's why its good to separate the code structures.

This demonstrates isolating reusable code into a separate class...

Public Class FileScanner
    Public Event Scan_Complete(sender As Object)
    Public Event Scan_Update(sender As Object, filename As String)
    Public Event Scan_Error(sender As Object, ex As Exception)
    Private Delegate Sub del_ScanComplete()

    Sub New(syncObject As Control, path String)
     Me.SynchronizeObject = syncObject
     ThreadPool.QueueUserWorkItem(New WaitCallback(AddressOf ScanFilesAsync), path)
    End Sub

    Private Sub ScanFilesAsync(ByVal state As Object)

     ' scan files here

     ' call the method to raise the Complete event
     ScanComplete()

    End Sub

    Private Sub ScanComplete()

     If SynchronizeObject.InvokeRequired Then
      ' we cant raise event on a different thread than our caller
      ' so lets invoke our method on the same caller thread
      Dim d As New del_ScanComplete(AddressOf ScanComplete)
      SynchronizeObject.Invoke(d)
     Else
      ' no synchronize needed, tell the caller we are done
      RaiseEvent Complete(Me)
     End If

    End Sub

End Class

Answer 7

An alternativ for doing background tasks in Windows Forms and raising events when they are done, is to use the AsyncOperationManager and AsyncOperation classes. To note is here that the AsyncOperation has to be created in the UI thread to work properly. Otherwise the UI code has to check for InvokeRequired.

public class BackgroundTask{

  private AsyncOperation _asyncOperation;
  public EventHandler Done;

  public BackgroundTask(){
    _asyncOperation = AsyncOperationManager.CreateOperation();
  }

  public void DoAsync(object userState) {
    System.Threading.ThreadPool.QueueUserWorkItem( ExecuteDo, userState);
  }

  private void ExecuteDo(object state) {
    // Do your work here
    // Raise event after finish
    _asyncOperation.PostOperationCompleted( Finished, EventArgs.Empty );
  }

  private void LookUpFinished( object eventargs ) {
    OnDone( ( EventArgs) eventargs );
  }

  private void OnDone( LookUpEventArgs e ) {
    EventHandler localEvent = Done;
    if ( localEvent!= null ) {
      localEvent(this,e);
    } 
  }
}

Here´s the code how to use it:

public class MyForm : Form {

  public MyForm() {
    InitializeComponent();
  }

  protected override OnShown(EventArgs e) {
    BackgroundTask task = new BackgroundTask();
    task.Done += SignalTaskDone;
  }

  private void SignalTaskDone(object sender, EventArgs e){
    MessageBox.Show(this, "Task finished");
  }
}