"black box" and re-use is exactly what my previous post was driving at;
really, in order to talk happily to multiple (disparate) UIs, it is best to
follow the eventing model. The following illustrates this using a summy
worker; note that you could also use the BackgroundWorker for some of this,
but this then necessitates your worker class integrating with the worker
directly, which is a pain. Anyways, code follows; note it demonstrates sync
and async, using the ISynchronizeInvoke interface so that the worker can
liaise with the UI thread (using BeginInvoke since we don't need any return
data; if this was a CancelEventArgs-style handler, then you would Invoke so
that you wait for the updated values).

using System;
using System.Windows.Forms;
using System.ComponentModel;
using System.Threading;
using System.Diagnostics;

static class Program {
   static void Main() {
       using (MyForm form = new MyForm()) {
           form.ShowDialog();
       }
   }
}
class MyForm :Form {
   Button sync, async;
   ProgressBar bar;
   public MyForm() {
       bar = new ProgressBar();
       bar.Dock = DockStyle.Bottom;
       bar.Minimum = 0; bar.Maximum = 100; bar.Style =
ProgressBarStyle.Continuous;
       sync = new Button(); sync.Dock = DockStyle.Left; sync.Text = "Sync";
       async = new Button();  async.Dock = DockStyle.Right; async.Text =
"Async";
       Controls.Add(sync); Controls.Add(async); Controls.Add(bar);
       sync.Click += delegate {
           MyWorker worker = new MyWorker();
           worker.ProgressChanged += UpdateProgress;
           worker.DoWork();
       };
       async.Click += delegate {
           MyWorker worker = new MyWorker(this);
           worker.ProgressChanged += UpdateProgress;
           ThreadPool.QueueUserWorkItem((WaitCallback)delegate {
               worker.DoWork();
           });
       };
   }
   void UpdateProgress(object sender, ProgressChangedEventArgs args) {
       sync.Enabled = async.Enabled = (args.Percent == 100);
       bar.Value = args.Percent;
   }

}

class ProgressChangedEventArgs : EventArgs {
   public readonly int Percent;
   public ProgressChangedEventArgs(int percent) {Percent = percent;}
}
delegate void ProgressChangeEventHandler(object sender,
ProgressChangedEventArgs args);
class MyWorker {
   readonly ISynchronizeInvoke _threadingMaster;
   public MyWorker() :this (null) { }
   public MyWorker(ISynchronizeInvoke threadingMaster) {
       _threadingMaster = threadingMaster;
   }
   public void DoWork() {
       Random rand = new Random();
       for(int i = 0; i<=100;i++) {
           Debug.WriteLine(i);
           Thread.Sleep(rand.Next(50));
           OnProgressChanged(i);
       }
   }
   public event ProgressChangeEventHandler ProgressChanged;
   protected void OnProgressChanged(int percent) {
       ProgressChangeEventHandler handler = ProgressChanged;
       if (handler == null) return;
       ProgressChangedEventArgs args = new
ProgressChangedEventArgs(percent);
       if (_threadingMaster != null && _threadingMaster.InvokeRequired) {
           _threadingMaster.BeginInvoke(handler, new object[] { this,
args });
       } else {
           handler(this, args);
       }
   }
}

Have your class raise events.  Then, any form that uses it
can optionally subscribe to them.

Here is a 1.1 sample:

http://www.eggheadcafe.com/articles/asynchronous_events.asp