How to run a function for each element in a list on a different thread sequentially and update the (passive) view after each function has run?

Question

I have a WinForm «Passive View» and a «Controller» where the controller is running a long running function for each element in a list.

I want the following:

• The functions shall run sequentially
• The view mustn't freeze while looping the list and running the functions
• After each function has run, the view shall be updated with the result of the run

The (single-threaded) code looks like this as of now:

View.DateSpan.Workdays.ForEach( 
   d => {
           var processRunInfo = _processRunner.Run( configFile, d );

           UdateViewFrom( processRunInfo );
         } );

The code above "works" but causes the view to freeze since it uses the very same thread, and it updates the view batch-wise.

Workdays is an IEnumerable<DateTime>, and ForEach does what ForEach of List<T> does but is an extension method from MoreLINQ.

_processRunner.Run runs an external command line application with the arguments supplied.

Answer 1

Running the foreach loop in a separate thread with a callback to the Invoke of your control (form) would be my solution.

The link below contains a decent example. http://msdn.microsoft.com/en-us/library/zyzhdc6b.aspx

Answer 2

You should make long-running calculation in the separate thread (not the main GUI thread), so that main thread that have message loop can be free. Than, inside of for-each loop, you should marshal UpdateViewForm method to the GUI thread using Control.Invoke method. You can choose to wrap methods in PassiveView, like this:

public void DoSomething() {
    if (this.InvokeRequired) {
        this.Invoke(DoSomethingDelegate);
        ...
    }
}

or just, instead of standard method invocation, use something like this:

myFormControl1.Invoke(myFormControl1.myDelegate);

Answer 3

Another option would be to take advantage of PLINQ - Parallel Linq

http://msdn.microsoft.com/en-us/magazine/cc163329.aspx

And you could do something like

View.DateSpan.Workdays.AsParallel().ForEach( 
   d => {
           var processRunInfo = _processRunner.Run( configFile, d );

           UdateViewFrom( processRunInfo );
         } );

You would still most likely have to handle the return update in a callback event.

Answer 4

+1 to Nenad and Bastiaan for pointing me in the Control.Invoke direction.

In order to fully reap the benefits of the «passive view» pattern, I don't want any knowledge of the Control type of WinForms in the «supervising controller» (that type should only be known by the implementer of the view interface, i.e. the one derived from Form).

Here's how I solved the issue satisfactory:

• The controller creates a new Thread instance with the ForEach loop a an argument, and then starts the created instance.

Before:

View.DateSpan.Workdays.ForEach(d =>
                                  {
                                     // do stuff...
                                  } );

After:

new Thread( () => View.DateSpan.Workdays.ForEach( d =>
                                                     {
                                                        // do stuff...
                                                     } ) ).Start();

• The view's widget update methods use a helper method that checks if the request comes from another thread, and if so uses Invoke. See the code below.

Before:

public string Status
{
  set { _statusLabel.Text = value ); }
}

After:

public string Status
{
  set { ExecuteOnUIThread( _statusLabel, () => _statusLabel.Text = value ); }
}

The helper method:

private static void ExecuteOnUIThread( Control control, Action action )
{
    if ( control.InvokeRequired )
    {
       control.Invoke( action );
    }
    else
    {
       action();
    }
 }

The production WinForm view works like a charm, and with the addition of a while loop that spins the thread while the background thread does its work in my BDD stories, so do they with my old view «test spy».