Alright, enough of a side track back to the threading issue. Basically in the .Net 1.1 land you had to declare a a delegate and then create a instance of that delegate and then use that instance in your thread to do the actual updating. It can get quite messy. At least from my perspective. Here is a small example:

     public class UI
     {
        public delegate void UpdateProgressBarDelegate(int percent);
        public UpdateProgressBarDelegate updateProgress;

        public UI()
       {
           updateProgress = new UpdateProgressBarDelegate(incrementProgressbar);
       }
    }

Now in a function somewhere on the working thread you would have this:

     private class doingTheUpdate(int percent)
     {
         mainUI = updateProgress.Invoke(new object() { percent });
     }

With .Net 2.0 it gets a bit simplified and you can use the EventHandler class to create an event and you don’t have to declare the delegate and then create an instance. Below is an example:

    public class MyUI
    {
       public event EventHandler UpdateProgressEvent;

       public void InvokeUpdateEvent(int percent)
       {
          InvokeUpdateEvent(UpdateProgressEvent, percent)
       }

       [MethodImpl(MethodImplOptions.NoInlining)]
       private void InvokeUpdateEvent(EventHandler handler, int percent)
       {
          if( handler != null )
          {
             MyEventArgs e = new MyEventArgs(percent);
             handler.BeginInvoke(this, e, null, null);
          }
       }
   }

Now doesn’t that seem a bit more concise. I admit I am doing some other things there to help make this thread safe and I got most of this from Dave Brook’s at Aliens ate my GUI. So I will try to summarize what it is doing.
First where it looks like I am declaring the method InvokeUpdateEvent twice, once as public and once as private, I am. The reason this is done is because you can get a race condition if you just check for null and then call the event. A way to fix this potential race conditions Dave explains it very well so I won’t try.

“One counter measure is to make a copy of the delegate. Delegates are immutable so by copying it to a temporary variable you keep a copy of the original state of the delegate, irrespective of any thread context switches. Making any change to the state of the delegate creates a new one on the heap and updates the reference to which the delegate point.”

As well on the private InvokeUpdateEvent declaration there is a attribute added. This is added because the JIT compiler might optimize the code above and basically get you back to the state before where the race condition can occur. So the [MethodImpl(MethodImplOptions.NoInlining)] attribute is used to tell the JIT not to optimize this function.

The only other item in there is MyEventArgs class. This would just be a class that inherits from the EventArgs class and adds any info that needs to be sent with the event. In this example it was just the percent to update a progressbar.

Hope this helps. I know it helped me.

 Edit:

Well I have jumped the gun a bit on this one and it looks like I needed to add one more thing to this to make it work on threads. when I call the event in the last function I still will need a BeginInvoke to make sure that it is run on the correct thread or else I get a cross threaded exception thrown. I have edited the code above to reflect this.

Also if you have any suggestions to improve this please post a comment. I am not perfect even though I tell myself I am.