The Background Worker in Silverlight

So here comes background worker in the picture. As the name itself suggests, background worker means...background worker. It is actually a thread with completed event.

There are times when you need to do some heavy work. Of course there are times in everyone's life when Mom forces you to clean your room, but I am not talking about that "heavy" work, not now I mean. From heavy work, I mean like when you need to iterate in a very large collection to make changes in its entities or something like that. If you are planning to do it in the main thread of Silverlight itself, then believe me buddy, you are in serious trouble. Doing that kind of stuff might block your user interface.

So here comes Background Worker into the picture. As the name itself suggests, Background Worker means ... background worker. It is actually a separate thread with a completed event. There are two basic events in Background Worker that actually do the work, yeah I mean literally,

  • DoWork
  • RunWorkerCompleted

Are the two. DoWorker does the heavy lifting. RunWorkerCompleted is called when DoWorker finishes doing the heavy lifting. Let me first give you my mainpage.cs class that has the Background Worker initialized and its events created.

   1: public partial class MainPage : UserControl

   2: {

   3:     readonly BackgroundWorker _bWorker = new BackgroundWorker();

   4: 

   5:     public MainPage()

   6:     {

   7:         InitializeComponent();

   8:         _bWorker.DoWork += _bWorker_DoWork;

   9:         _bWorker.RunWorkerCompleted += _bWorker_RunWorkerCompleted;

  10:     }

  11: 

  12:     void _bWorker_DoWork(object sender, DoWorkEventArgs e)

  13:     {

  14:         //Heavy lifting goes here

  15:     }

  16: 

  17:     void _bWorker_RunWorkerCompleted(object sender, RunWorkerCompletedEventArgs e)

  18:     {

  19:         //When heavy lifting completed

  20:     }

  21: }


I have defined here, a read-only object of Background Worker, "_bWorker". The two events DoWork and RunWorkerCompleted, that we were talking about, are created in the constructor. I put my heavy code in the DoWork event, and the code that is dependent on the calculations returned from the heavy code will go into the RunWorkerCompleted event.

Background Worker will not start doing work, not until you tell it to do so. And you can tell it by calling the RunWorkerAsync() function.

In XAML of my main page I have added a button, "Do Work". Here is my page's XAML:

 

   1: <UserControl x:Class="Background.MainPage"

   2:     xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"

   3:     xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"

   4:     xmlns:d="http://schemas.microsoft.com/expression/blend/2008"

   5:     xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"

   6:     mc:Ignorable="d"

   7:     d:DesignHeight="300" d:DesignWidth="400">

   8: 

   9:     <Grid x:Name="LayoutRoot" Background="White">

  10:         <Button Content="Do Work" Width="150"

  11:                 Height="100" Click="ButtonBase_OnClick"/>

  12:     </Grid>

  13: </UserControl>


And on the click event of the button:
 

   1: private void ButtonBase_OnClick(object sender, RoutedEventArgs e)

   2: {

   3:    _bWorker.RunWorkerAsync();

   4: }


The RunWorkerAsync function orders the Background Worker to start doing the task assigned, yes in the background, of course.