EDIT (12/6/2014): If you like C#, WPF, 3D, and Golf, check out my latest side project: https://www.youtube.com/watch?v=8pWq8vhZqbg
If you don’t like golf, don’t click the link!
This is the third visitation of the topic of UI and worker thread interaction. Based upon excellent feedback through the comments (thanks Peter Ritchie and others) I have renamed and modified the previous ThreadBarrier implementation (which was a poor name to begin with since a thread barrier concept already represents something else). The previous pattern of encapsulating a thread and communicating to the UI via events raised on the UI thread is still my recommendation: see the first post for a long winded explanation, and the second post for more examples. However, there are many people that already have existing code that uses the Control.InvokeRequired and Control.Invoke pattern such as:
delegate void UpdateProgressDelegate(int progress);
public void UpdateProgressBar(int progress)
{
if (this.InvokeRequired == false)
{
this.progressBarDownload.Value = progress;
}
else
{
this.Invoke(new UpdateProgressDelegate(UpdateProgressBar), new object[] { progress });
}
}
The new implementation is intended to replace this code and support the original ThreadBarrier concept.
Introducing the DelegateMarshaler
The DelegateMarshaler implementation is virtually identical to the ThreadBarrier except for four minor differences:
- The marshaler is created using a static method DelegateMarshaler.Create() so an exception can be thrown if no SynchronizationContext exists (console app, or before UI is started, etc.)
- If the calling thread is already the target thread (UI thread), then the delegate is invoked normally rather than a cross thread invoke. This is similar to InvokeRequired being false.
- The DelegateMarshaler supports methods with 0 to 4 arguments.
- Static methods wrap ThreadPool.QueueUserWorkItem in a type safe way.
A compact example
void buttonDownload_Click(object sender, EventArgs e)
{
DelegateMarshaler marshaler = DelegateMarshaler.Create();
DelegateMarshaler.QueueOnThreadPoolThread(
(fileName) =>
{
//simulate download
for (int i = 0; i < 100; ++i)
{
marshaler.Invoke(UpdateProgressBar, i);
Thread.Sleep(50);
}
marshaler.Invoke(ShowDownloadComplete, fileName);
},
“somefile.txt”);
}
private void UpdateProgressBar(int progress)
{
this.progressBarDownload.Value = progress;
}
private void ShowDownloadComplete(string fileName)
{
this.labelFileDownload.Text = fileName;
}
Using the DelegateMarshaler consists of creating the marshaler on the UI thread and invoking the methods that update the UI (preferably from the worker thread). Invoke will call the method synchronously, and BeginInvoke will call the method asynchronously allowing the worker to continue running while the UI updates. If your thread is a separate method altogether (which is usually the case), you would want to save the DelegateMarshaler instance as a private field in your form or control so it can be used in the thread method.
The DelegateMarshaler Implementation
public sealed class DelegateMarshaler
{
private SynchronizationContext _synchronizationContext;
public static DelegateMarshaler Create()
{
if (SynchronizationContext.Current == null)
{
throw new InvalidOperationException(“No SynchronizationContext exists for the current thread.”);
}
return new DelegateMarshaler(SynchronizationContext.Current);
}
private DelegateMarshaler(SynchronizationContext synchronizationContext)
{
this._synchronizationContext = synchronizationContext;
}
private bool IsMarshalRequired
{
get
{
return this._synchronizationContext != SynchronizationContext.Current;
}
}
public void Invoke<T>(Action<T> action, T arg)
{
if (this.IsMarshalRequired == false)
{
// already on the target thread, just invoke delegate directly
action(arg);
}
else
{
// marshal the delegate call to the target thread
this._synchronizationContext.Send(delegate { action(arg); }, null);
}
}
//simplifies use of threadpool so arguments do not need to be cast
public static void QueueOnThreadPoolThread<T>(Action<T> action, T arg)
{
ThreadPool.QueueUserWorkItem(delegate { action(arg); });
}
}
It is such a small class, feel free to modify it to fit your needs. Download the sample for the complete code and comments:
Notable Links
http://thevalerios.net/matt/2008/05/a-type-safe-backgroundworker-wrapper/
http://weblogs.asp.net/justin_rogers/articles/126345.aspx
http://www.codeproject.com/KB/cs/AOPInvokeRequired.aspx
