MSDN Magazine - October 2007 - (Page 68)

pieces of work for the user interface into small discrete blocks for the Dispatcher to execute. Any work that doesn’t need to be done on the UI thread should instead be moved off onto other threads for processing in the background. Typically you will use the Dispatcher class to send worker items to the UI thread for processing. For example, if you want to do some work on a separate thread using the Thread class, you could create a ThreadStart delegate with some work to do on a new thread as shown in Figure 3. This code fails because setting the Text property of the statusText control (a TextBlock) is not being called on the UI thread. When the code attempts to set the Text on the TextBlock, the TextBlock class internally calls its VerifyAccess method to ensure that the call is coming from the UI thread. When it determines the call is from Figure 4 Updating the UI a different thread, it throws an exception. So how can you use the // The Work to perform on another thread Dispatcher to make the call on the UI thread? ThreadStart start = delegate() { The Dispatcher class provides access to invoke code on the UI // thread directly. Figure 4 shows the use of the Dispatcher’s Invoke // Sets the Text on a TextBlock Control. method to call a method called SetStatus to change the TextBlock’s // This will work as its using the dispatcher Text property for you. Dispatcher.Invoke(DispatcherPriority.Normal, new Action (SetStatus), The Invoke call takes three pieces of information: the priority “From Other Thread”); of the item to be executed, a delegate that describes what work to }; // Create the thread and kick it started! perform, and any parameters to pass into the delegate described new Thread(start).Start(); in the second parameter. By calling Invoke, it queues up the delegate to be called on the UI thread. Using the Invoke method enFigure 5 Updating the UI Asynchronously sures that you are going to block until the work is performed on the UI thread. // The Work to perform on another thread ThreadStart start = delegate() As an alternative to using the Dispatcher synchronously, you can { use the BeginInvoke method of the Dispatcher to asynchronously // queue up a work item for the UI thread. Calling the BeginInvoke // This will work as its using the dispatcher method returns an instance of the DispatcherOperation class that DispatcherOperation op = Dispatcher.BeginInvoke( DispatcherPriority.Normal, contains information about the execution of the work item, including new Action (SetStatus), the current status of the work item and the result of the execution “From Other Thread (Async)”); (once the work item has completed). The use of the BeginInvoke DispatcherOperationStatus status = op.Status; method and the DispatcherOperation class is shown in Figure 5. while (status != DispatcherOperationStatus.Completed) { Unlike a typical message pump implementation, the Dispatcher status = op.Wait(TimeSpan.FromMilliseconds(1000)); is a priority-based queue of work items. This allows for better reif (status == DispatcherOperationStatus.Aborted) { sponsiveness because the more important pieces of work are ex// Alert Someone ecuted before less important pieces of work. The nature of the } } prioritization is exemplified by the priorities that are specified in }; the DispatchPriority enumeration (as shown in Figure 6). // Create the thread and kick it started! Generally you should always use DispatcherPriority.Normal for new Thread(start).Start(); the priority of work items that update the appearance of the UI (like the example I used earlier). Figure 6 DispatchPriority Prioritization Levels (in Priority Order) But there are times when you should use different priorities. Priority Description Of particular interest are the Inactive Work items are queued but not processed. three idle priorities (ContextSystemIdle Work items are only dispatched to the UI thread when the system is idle. This is the lowest Idle, ApplicationIdle, and priority of items that are actually processed. SystemIdle). These prioriApplicationIdle Work items are only dispatched to the UI thread when the application itself is idle. ties allow you to specify work ContextIdle Work items are only dispatched to the UI thread after higherpriority work items are processed. items that are only executed Background Work items are dispatched after all layout, rendering, and input items are processed. under very low workloads. Input Work items are dispatched to the UI thread at the same priority as user input. Loaded Render DataBind Normal Send Work items are dispatched to the UI thread after all layout and rendering are complete. Work items are dispatched to the UI thread at the same priority as the rendering engine. Work items are dispatched to the UI thread at the same priority as data binding. Work items are dispatched to the UI thread with normal priority. This is the priority at which most application work items should be dispatched. Work items are dispatched to the UI thread with the highest priority. BackgroundWorker Now that you have a sense of how the Dispatcher works, you might be surprised to know that you will not find use for it in most cases. In 68 msdnmagazine WPF Multithreading

Table of Contents Feed for the Digital Edition of MSDN Magazine - October 2007

Cover Contents Toolbox CLR Inside Out Basic Instincts Data Points Cutting Edge Pooled Threads WPF Threads Parallel Linq Parallel Performance Mobile Apps Test Run Foundations Windows with C++ Netting C++ .NET Matters { End Bracket } Net Nuptials

MSDN Magazine - October 2007

For optimal viewing of this digital publication, please enable JavaScript and then refresh the page. If you would like to try to load the digital publication without using Flash Player detection, please click here.