barcode scanner in asp.net web application THREADING IN SILVERLIGHT in VB.NET

Generation QR Code 2d barcode in VB.NET THREADING IN SILVERLIGHT

worker.DoWork += new DoWorkEventHandler(performLengthyOperation); CustomWorkerArgs args = new CustomWorkerArgs(); args.index = index; args.sleepTime = 25000; bwButtons[index].Content = "Cancel"; resultBoxes[index].Text = "Starting..."; workers[index] = worker; worker.RunWorkerAsync(args); } } The index is retrieved via the Tag attribute, and then the corresponding worker entry in the workers array is checked. This entry is set to null when BackgroundWorker completes (or errors or is cancelled), so if you find it not null, then the worker is active and working. Otherwise, a new BackgroundWorker is created. This is where we set WorkReportsProgress and WorkerSupportsCancellation to true. Again, these properties should be set to true only when you construct the method that does work to explicitly handle the cancel condition and to report progress. Next, the event handlers are registered. Let s take a closer look at these. DoWork is registered with the method that actually does the work. In this case, this is the performLengthyOperation that you already implemented. The rest of this method creates a CustomWorkerArgs instance, configures it, and passes it to the BackgroundWorker in the RunWorkerAsync method. RunWorkerAsync is what starts the actual work, provided DoWork is registered with the work method. The progress handler is straightforward. The UserState property of ProgressChangedEventArgs contains the object originally passed to RunWorkerAsync. The source of this property, however, is the second (optional) parameter to the ReportProgress method of BackgroundWorker. If you need to pass something custom specifically to the progress report handler, you can do it using the UserState property. void worker_ProgressChanged(object sender, ProgressChangedEventArgs e) { int index = ((CustomWorkerArgs)e.UserState).index; resultBoxes[index].Text = "In progress: " + e.ProgressPercentage + "%"; } The RunWorkerCompleted event handler is much more interesting. Here, you must check whether the background worker was cancelled or if it had an error. If either of these conditions is true, you can t use the Result property of the RunWorkerCompletedEventArgs, or else your code will throw an exception. void worker_RunWorkerCompleted(object sender, RunWorkerCompletedEventArgs e) { BackgroundWorker bw = (BackgroundWorker)sender; int index; if (e.Error != null || e.Cancelled) { // if there's an Error or this worker was cancelled, // we can't access Result without throwing an exception if (bw == workers[0]) index = 0; else if (bw == workers[1]) index = 1; else

index = 2; if (e.Error != null) resultBoxes[index].Text = "Exception: " + e.Error.Message; else resultBoxes[index].Text = "Cancelled"; } else { index = ((CustomWorkerArgs)e.Result).index; resultBoxes[index].Text = "Completed"; } bwButtons[index].Content = "Start"; workers[index] = null; } If there is no error and the worker was not cancelled, the Result property can be accessed. The else block illustrates accessing Result, providing a quick way to arrive at the right text block. Remember that all of these event handlers happen in the thread that created the BackgroundWorker. Since these workers were created on the user interface thread, it s possible to directly access the various text blocks to set their Text property to something appropriate. There are two big advantages to using the BackgroundWorker. First, it makes it easy to do work on a background thread without needing to worry about manually creating and managing a thread. Second, the various event handlers happen on the calling thread, making modification of a user interface easy without needing to use a Dispatcher.

One of the trickiest problems when it comes to working with multiple threads is using shared resources typically, shared memory in the form of objects or primitive types. When it comes to shared data, one potential issue is known as a race condition. Figure 12-4 illustrates two threads attempting to increment a single integer variable named value. However, a simple increment is split into smaller operations behind the scenes: the value of the variable is read, incremented, and stored back into the variable.