Thread and GUI with invoke issue

Question

I have a method for exporting data. I do it via a new thread so that the GUI remains responsive. At the end it opens a SaveFileDialog which is not working without an invoke. With the below modification it's working but again, the GUI is unresponsive. Any clue?

private void button1_Click(object sender, EventArgs e)
{
   Thread thread = new Thread(method);
   thread.Start();
}
public void medhod()
{
   if (this.InvokeRequired)
   {
       Invoke(new MethodInvoker(delegate() { method(); }));
   }
   else
   {
       //Code
       //SaveFileDialog
   }
}

*Edit: Another approach would be to leave the export code in the new thread, and put the SaveFileDialog back to the original thread. All I need is 1st thread to "pause" and then continue once the 2nd thread is over. Ideas are welcome.

Answer 1

The problem is running any sort of UI component in a non-UI thread is generally a bad idea - especially a modal dialog.

Instead, put the actual background processing code into another thread and once finished call back into the UI thread and launch the save dialog. The TPL makes this sort of thing very trivial e.g.

Task.Factory.StartNew(() => {
    // do background processing
}).ContinueWith((task) => {
    // show save dialog
}, TaskScheduler.FromCurrentSynchronizationContext());

Answer 2

Your issue is probably what Luaan comment points. You have long operation which you want to put into thread, but then you invoke the whole operation into UI thread and it will block the UI thread for a duration.

Do it like this:

private void button1_Click(object sender, EventArgs e)
{
    (new Thread(method)).Start();
}
private void method()
{
    //Code
    Invoke(() =>
    {
        //SaveFileDialog
    });
}

You don't need to check for InvokeRequired, because it will be required anyway. The way you use it is a pattern of defining method, which can be called from either thread. But in this case it typically contains very short operation to interact with UI controls.

Answer 3

Try this:

void btnClick(object sender, EventArgs e)
{
    var t = new Thread(doStuff);
    t.SetApartmentState(ApartmentState.STA);
    t.Start();
}

void doStuff()
{
    SaveFileDialog sfd = new SaveFileDialog();

    sfd.ShowDialog();   
}

The SaveFileDialog is run in a separate thread (it has to have a single threaded apartment), and it doesn't block the UI thread of your application. However, be very careful about everything you do, it can be very unstable.

The basic issue is that your application is running a Windows Messaging loop, which is basically a loop that iterates over Windows Messages coming from the OS (and other applications). If the loop is stuck for some reason, the application becomes unresponsive (when you click the mouse, the OS sends a WM_MOUSEDOWN and many more methods to your message queue, which has to be depopulated by the message loop to do anything). Being in the ShowDialog method is exactly one of the ways the loop gets stuck - your form can no longer process any messages, because it never gets a chance to.

Now, what Invoke does is, that it adds the method you want to call to another queue on the target form. The next chance the form gets during the windows messaging loop, it executes all the items in the invoke queue - again, the messaging loop gets stuck.

Now, how does the dialog receive windows messages? Easy, in practice, it creates its own WM loop. This is very little but another while loop, that only terminates as the modal dialog closes - blocking the messaging loop of the parent form (or rather, the application).

The problem with the code above is that it could steal the messaging loop from our parent window. The solution is to explicitly create a new window with a new messaging loop, by explicitly passing the owner to ShowDialog:

void doStuff()
{
    NativeWindow nw = null;

    try
    {
        nw = new NativeWindow();

        nw.CreateHandle(new CreateParams());
        SaveFileDialog sfd = new SaveFileDialog();

        sfd.ShowDialog(nw);
    }
    finally
    {
        if (nw != null)
            nw.DestroyHandle();
    }
}

Answer 4

try to use BeginInvoke() that is asyncronous instead of Invoke that is syncronous see What's the difference between Invoke() and BeginInvoke() for a better trattation of the argument.