How do I update a GUI thread / class from a worker thread / class?

So, after some research based on the answers above, further googling and asking a colleague who knows a little about C #, my chosen solution is below. I am still interested in comments, suggestions and clarifications.

First, some more details about the problem, which is actually quite typical in the sense that the GUI controls something that should remain completely abstract through a series of events that the GUI should respond to. There are several separate problems:

• The events themselves, with different data types. Events will be added, removed, changed as the program develops.
• How to connect multiple classes that make up the GUI (different UserControls) and classes that abstract the hardware.
• All classes can create and consume events and should be kept separate whenever possible.
• The compiler needs to identify the encoding devices as accurately as possible (for example, an event that sends one data type, but a comumer waiting for another)

The first part of this event. Since the GUI and device can generate multiple events, possibly associated with different data types, the event dispatcher is handy. This should be common for both events and data, so:

    // Define a type independent class to contain event data
    public class EventArgs<T> : EventArgs
    {
    public EventArgs(T value)
    {
        m_value = value;
    }

    private T m_value;

    public T Value
    {
        get { return m_value; }
    }
}

// Create a type independent event handler to maintain a list of events.
public static class EventDispatcher<TEvent> where TEvent : new()
{
    static Dictionary<TEvent, EventHandler> Events = new Dictionary<TEvent, EventHandler>();

    // Add a new event to the list of events.
    static public void CreateEvent(TEvent Event)
    {
        Events.Add(Event, new EventHandler((s, e) => 
        {
            // Insert possible default action here, done every time the event is fired.
        }));
    }

    // Add a subscriber to the given event, the Handler will be called when the event is triggered.
    static public void Subscribe(TEvent Event, EventHandler Handler)
    {
        Events[Event] += Handler;
    }

    // Trigger the event.  Call all handlers of this event.
    static public void Fire(TEvent Event, object sender, EventArgs Data)
    {
        if (Events[Event] != null)
            Events[Event](sender, Data);

    }
}

      

        
        
        
      

    

Now we need some events in and out of the C world, I like enums, so I define some events that will boost the GUI:

    public enum DEVICE_ACTION_REQUEST
    {
    LoadStuffFromXMLFile,
    StoreStuffToDevice,
    VerifyStuffOnDevice,
    etc
    }

      

        
        
        
      

    

Now, within the scope (usually the namespace) of the static EventDispatcher class, a new dispatcher can be defined:

        public void Initialize()
        {
        foreach (DEVICE_ACTION_REQUEST Action in Enum.GetValues(typeof(DEVICE_ACTION_REQUEST)))
            EventDispatcher<DEVICE_ACTION_REQUEST>.CreateEvent(Action);
        }

      

        
        
        
      

    

This creates an event handler for each event in the enumeration.

And it is consumed by subscribing to the event like this code in the constructor of the consumer device object:

        public DeviceController( )
    {
        EventDispatcher<DEVICE_ACTION_REQUEST>.Subscribe(DEVICE_ACTION_REQUEST.LoadAxisDefaults, (s, e) =>
            {
                InControlThread.Invoke(this, () =>
                {
                    ReadConfigXML(s, (EventArgs<string>)e);
                });
            });
    }

      

        
        
        
      

    

Where InControlThread.Invoke is an abstract class that just wraps the call invocation.

Events can only be raised by the GUI:

        private void buttonLoad_Click(object sender, EventArgs e)
        {
            string Filename = @"c:\test.xml";
            EventDispatcher<DEVICE_ACTION_REQUEST>.Fire(DEVICE_ACTION_REQUEST.LoadStuffFromXMLFile, sender, new EventArgs<string>(Filename));
        }

      

        
        
        
      

    

This has the advantage that if the event creation and consumption types do not match (here the Filename line) the compiler will grumble.

There are many improvements to be made, but these are nuts of the problem. I would be interested, as I said in the comments, especially if there are any glaring omissions / errors or shortcomings. Hope this helps someone.