Just sharing a small app that demonstrates the use of BackgroundWorker in WPF.

The app has two list boxes, one act as source of all the Process that needs to be processed and the other list box for the running and completed Processes.

The click of Start button starts the processing of Process.

Clicking on Cancel aborts the thread.

The XAML for the app.

<Window x:Class="BackgroundWorkerSampleApp.MainWindow"
 xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
 xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
 Title="MainWindow" Height="324" Width="525" Loaded="Window_Loaded">
 <Grid Height="289">
 <ListBox Height="187" HorizontalAlignment="Left" Margin="20,52,0,0" Name="lstSource" VerticalAlignment="Top" Width="171"
 />
 <Button Content="Start" Height="41" HorizontalAlignment="Left" Margin="212,101,0,0" Name="btnStart" VerticalAlignment="Top" Width="75" Click="btnStart_Click" />
 <Button Content="Cancel" Height="42" HorizontalAlignment="Left" Margin="212,148,0,0" Name="btnCancel" VerticalAlignment="Top" Width="75" ContentStringFormat="Cancel" Click="btnCancel_Click" />
 <ListBox Height="187" HorizontalAlignment="Left" Margin="320,52,0,0" Name="lstDestination" VerticalAlignment="Top" Width="171" />
 <TextBlock Height="25" HorizontalAlignment="Left" Margin="195,252,0,0" Name="txtStatus" Text="" VerticalAlignment="Top" Width="232" />
 </Grid>
</Window>

The code behind for the app.

namespace BackgroundWorkerSampleApp
{
 using System.Collections.ObjectModel;
 using System.ComponentModel;
 using System.Threading;
 using System.Windows;

/// <summary>
 /// Interaction logic for MainWindow.xaml
 /// </summary>
 public partial class MainWindow : Window
 {
 #region Constants and Fields

private readonly BackgroundWorker backgroundWorker;

private readonly ObservableCollection<Process> obcProcess;

private readonly ObservableCollection<Process> obcRunningProcess;

private Thread workerThread;

#endregion

#region Constructors and Destructors

public MainWindow()
 {
 this.InitializeComponent();
 this.obcProcess = new ObservableCollection<Process>();
 this.obcRunningProcess = new ObservableCollection<Process>();
 this.lstSource.ItemsSource = this.obcProcess;
 this.lstDestination.ItemsSource = this.obcRunningProcess;
 this.lstSource.DisplayMemberPath = "ProcessName";
 this.lstDestination.DisplayMemberPath = "ProcessName";

// intialize BackgroundWorker class properties
 this.backgroundWorker = new BackgroundWorker();
 this.backgroundWorker.DoWork += this.backgroundWorker_DoWork;
 this.backgroundWorker.RunWorkerCompleted += this.backgroundWorker_RunWorkerCompleted;
 }

#endregion

#region Methods

/// <summary>
 /// Executes the process.
 /// </summary>
 /// <param name="backgroundWorker">The background worker.</param>
 private void ExecuteProcess(BackgroundWorker backgroundWorker)
 {
 if (this.obcProcess.Count > 0)
 {
 this.obcRunningProcess.Add(this.obcProcess[0]);
 backgroundWorker.RunWorkerAsync(this.obcProcess[0]);
 this.obcProcess.RemoveAt(0);
 }
 }

/// <summary>
 /// Handles the Loaded event of the Window control.
 /// </summary>
 /// <param name="sender">The source of the event.</param>
 /// <param name="e">The <see cref="System.Windows.RoutedEventArgs"/> instance containing the event data.</param>
 private void Window_Loaded(object sender, RoutedEventArgs e)
 {
 var proc1 = new Process();
 proc1.ProcessName = "Process 1";

var proc2 = new Process();
 proc2.ProcessName = "Process 2";

var proc3 = new Process();
 proc3.ProcessName = "Process 3";

this.obcProcess.Add(proc1);
 this.obcProcess.Add(proc2);
 this.obcProcess.Add(proc3);
 }

/// <summary>
 /// Handles the DoWork event of the backgroundWorker control.
 /// </summary>
 /// <param name="sender">The source of the event.</param>
 /// <param name="e">The <see cref="System.ComponentModel.DoWorkEventArgs"/> instance containing the event data.</param>
 private void backgroundWorker_DoWork(object sender, DoWorkEventArgs e)
 {
 this.workerThread = Thread.CurrentThread;
 var process = e.Argument as Process;
 Thread.Sleep(5000);
 process.ProcessName = process.ProcessName + " Processed";
 }

/// <summary>
 /// Handles the RunWorkerCompleted event of the backgroundWorker control.
 /// </summary>
 /// <param name="sender">The source of the event.</param>
 /// <param name="e">The <see cref="System.ComponentModel.RunWorkerCompletedEventArgs"/> instance containing the event data.</param>
 private void backgroundWorker_RunWorkerCompleted(object sender, RunWorkerCompletedEventArgs e)
 {
 if (e.Error != null)
 {
 MessageBox.Show(e.Error.Message);
 }
 else if (e.Cancelled)
 {
 MessageBox.Show("Cancelled");
 }
 else
 {
 if (this.obcProcess.Count > 0)
 {
 this.obcRunningProcess.Add(this.obcProcess[0]);
 this.backgroundWorker.RunWorkerAsync(this.obcProcess[0]);
 this.obcProcess.RemoveAt(0);
 }
 else
 {
 this.txtStatus.Text = "Processing Completed";
 }
 }
 }

/// <summary>
 /// Handles the Click event of the btnCancel control.
 /// </summary>
 /// <param name="sender">The source of the event.</param>
 /// <param name="e">The <see cref="System.Windows.RoutedEventArgs"/> instance containing the event data.</param>
 private void btnCancel_Click(object sender, RoutedEventArgs e)
 {
 this.workerThread.Abort();
 this.txtStatus.Text = "Processing Aborted";
 }

/// <summary>
 /// Handles the Click event of the btnStart control.
 /// </summary>
 /// <param name="sender">The source of the event.</param>
 /// <param name="e">The <see cref="System.Windows.RoutedEventArgs"/> instance containing the event data.</param>
 private void btnStart_Click(object sender, RoutedEventArgs e)
 {
 this.ExecuteProcess(this.backgroundWorker);
 }

#endregion
 }
}

Hope it helps.