Communication between threads via delegates?

Question

I am looking for a solution for interthread communication. Thread A is the main thread of a windows app. I starts a Thread B that is working independant of thread a, they do not share code. But thread A has to get some feedback about status of thread b. I try to solve this with a delegate. I am very sorry, I forgot to add that I have to work on .net 3.5, c#, WEC7

It is important that the code

public void OnMyEvent(string foo)
        {
            MessageBox.Show(foo);
        }

is executed in context of thread a, how can I achieve this

public partial class Form1 : Form
{
//...
    public void StartThread(Object obj)
    {
        new ClassForSecondThread(obj as Parameters);            
    }

    private void button1_Click(object sender, EventArgs e)
    {
        //ParameterizedThreadStart threadstart = new ParameterizedThreadStart(startThread);
        ParameterizedThreadStart threadstart = new ParameterizedThreadStart(StartThread);
        Thread thread = new Thread(threadstart);
        Parameters parameters = new Parameters(){MyEventHandler = OnMyEvent};
        thread.Start(parameters);                        
    }

    public void OnMyEvent(string foo)
    {
        MessageBox.Show(foo);
    }
}

//This code is executed in Thread B
public class ClassForSecondThread
{
    public ClassForSecondThread(Parameters parameters)
    {
        if (parameters == null) 
            return;
        MyEventhandler += parameters.MyEventHandler;
        DoWork();
    }

    private void DoWork()
    {
        //DoSomething
        if (MyEventhandler != null)
            MyEventhandler.DynamicInvoke("Hello World");// I think this should be executed async, in Thread A
        Thread.Sleep(10000);
        if (MyEventhandler != null)
            MyEventhandler.DynamicInvoke("Hello World again"); // I think this should be executed async, in Thread A
    }

    public event MyEventHandler MyEventhandler;
}
public class Parameters
{
    public MyEventHandler MyEventHandler;
}

public delegate void MyEventHandler(string foo);

Answer 1

For what it is worth you can simplify your code considerably by using the new async and await keywords in C# 5.0.

public class Form1 : Form
{
  private async void button1_Click(object sender, EventArgs args)
  {
    OnMyEvent("Hello World");
    await Task.Run(
      () =>
      {
        // This stuff runs on a worker thread.
        Thread.Sleep(10000);
      });
    OnMyEvent("Hello World again");
  }

  private void OnMyEvent(string foo)
  {
    Message.Show(foo);
  }

}

In the code above OnMyEvent is executed on the UI thread in both cases. The first call be executed before the task starts and the second call will be executed after the task completes.

Answer 2

As you want to call the MessageBox on the main UI thread, you can achieve what you want using Control.Invoke.

     Invoke((MethodInvoker)(() => MessageBox.Show(foo)));

The Invoke method can be called directly on the Form and you won't be in the context of Thread B within the delegate - the code will run on the same thread as the Form.

EDIT: OP question: if I understood Control.Invoke correctly, it always acts in the context of a control?

Although the Invoke method uses a Control (in this case the form) to get a handle to the UI thread it is running on, the code within the delegate is not specific to the UI. If you want to add more statements and expand it to include more stuff, just do this:

        string t = "hello"; //declared in the form

        //Thread B context - Invoke called
        Invoke((MethodInvoker)(() => 
            {
                //Back to the UI thread of the Form here == thread A 
                MessageBox.Show(foo);
                t = "dd";
            }));

Also, if you are updating things in a multi threaded environment where the data is accessible to more than one thread, then you will need to investigate sychronization - applying locks to data etc.