WPF Dispatching, Invoking...

Infographics by vecteezy.com

found in PRISM platform (I checked ver. 4). We can publish there our events in global Container. But some times we won't use it or we can't. I created something similar to prism solution, so it's not quite my idea, but I think it can be helpful.

I created some structures:

- Dispatching class
- UIDispatcher class
- InvokeOptions enumeration


First of all, and a basic thing, is to get UI Dispatcher. UI Dispatcher is a default WPF application dispatcher, co we can get it from static field like below.

Dispatcher uiDispatcher = Application.Current.Dispatcher;

view raw ui_dispatcher_for_wpf_init.cs hosted with ❤ by GitHub

But before we can use it, we should check if Application.Current isn't null. It can be null in special cases, e.g. when we run Visual Studio Unit Tests.

	Dispatcher uiDispatcher = null;
	if (Application.Current != null)
	{
	uiDispatcher = Application.Current.Dispatcher;
	}

view raw ui_dispatcher_for_wpf_2.cs hosted with ❤ by GitHub

Because sometimes we can get null instead of Dispatcher instance, I found iteresting solution in PRISM. We can create something similar to small bridge class, that will help to omit this issue. This class here will be called UIDispatcher.

	class UIDispatcher
	{
	public void BeginInvoke(Delegate method, params object[] args)
	{
	if ( Application.Current != null )
	{
	Application.Current.Dispatcher.BeginInvoke(method, DispatcherPriority.Normal, args);
	}
	}
	}

view raw UIDispatcherForWPF.cs hosted with ❤ by GitHub

UIDispatcher is a simple class that have BeginInvoke method used to invoke some delegate in UI Thread, using UI Dispatcher if it is accessible. We can also pass arguments to this method.

Because I wanted to create universal invoking solution I decided to create similar invoke-thread-options to this in PRISM. So I created InvokeOptions enumeration.

	public enum InvokeOptions
	{
	PublisherThread,
	UIThread,
	BackgroundThread
	}

view raw UIDispatcherInvokeOptionsEnum.cs hosted with ❤ by GitHub

I ignored comments to clean code. PublisherThread option invoke method in the current thread, UIThread - in UI Thread, BackgroundThread - in background worker as Thread Pool Work Item (in my opinion better solution than background worker).

Finally We can see a target class:

	public static class Dispatching
	{
	static UIDispatcher _uiDispatcher;
	static UIDispatcher UIDispatcher
	{
	get
	{
	if ( _uiDispatcher == null )
	{
	_uiDispatcher = new UIDispatcher();
	}
	return _uiDispatcher;
	}
	}
	public static void Invoke(Action method, InvokeOptions option)
	{
	switch ( option )
	{
	case InvokeOptions.UIThread:
	UIDispatcher.BeginInvoke(method);
	break;
	case InvokeOptions.BackgroundThread:
	ThreadPool.QueueUserWorkItem(delegate(object o)
	{
	method();
	});
	break;
	case InvokeOptions.PublisherThread:
	default:
	method.Invoke();
	break;
	}
	}
	public static void Invoke<TArg>(Action<TArg> method, TArg arg, InvokeOptions option)
	{
	switch ( option )
	{
	case InvokeOptions.UIThread:
	UIDispatcher.BeginInvoke(method, arg);
	break;
	case InvokeOptions.BackgroundThread:
	ThreadPool.QueueUserWorkItem(delegate(object o)
	{
	method(arg);
	});
	break;
	case InvokeOptions.PublisherThread:
	default:
	method.Invoke(arg);
	break;
	}
	}
	}

view raw DispatchingClassUsingUIDispatcherForWPF.cs hosted with ❤ by GitHub

What we can see here, there are two methods Invoke, used to invoke our methods or delegates in one of Thread options. I created two methods because I often use parameterless methods or delegates so the second was not needed. The second is helpful with others.

And how to use it, to have all clear.

	public void ParameterlessMethod()
	{
	// Doing some work
	}
	public void ParamMethod(EventArgs e)
	{
	// bla bla other work
	}
	public void Invoker()
	{
	// Invoke in current Thread
	ParameterlessMethod();
	ParamMethod(EventArgs.Empty);
	Dispatching.Invoke(ParameterlessMethod, InvokeOptions.PublisherThread);
	Dispatching.Invoke<eventargs>(ParamMethod, EventArgs.Empty, InvokeOptions.PublisherThread);
	// Invoke in current UI Thread
	Dispatching.Invoke(ParameterlessMethod, InvokeOptions.UIThread);
	Dispatching.Invoke<eventargs>(ParamMethod, EventArgs.Empty, InvokeOptions.UIThread);
	// Invoke in background
	Dispatching.Invoke(ParameterlessMethod, InvokeOptions.BackgroundThread);
	Dispatching.Invoke<eventargs>(ParamMethod, EventArgs.Empty, InvokeOptions.BackgroundThread);
	}

view raw InvokerMethodExample.cs hosted with ❤ by GitHub

All of code presented here can be download in one file in Downloads section below.

Hope this will be helpful.