How to close modal window after a Task completes?

Question

I have two default windows. I want one window starts a work, shows another window in the modal (dialog) form (progress indicating, but now it is not important), then closes it after this work has been finished. I have the following problems in my implementation:

1) after the work completes ("Completed!" message box shows up, but it also is not important and is just indication), the ProgressWindow doesn't close automatically;

2) if I close it by clicking manually the red cross, the System.InvalidOperationException with the message "The calling thread cannot access this object because a different thread owns it." occurs at the line

await task;

3) the code in ContinueWith actually is performed BEFORE the Go method finishes - why?

How can I achieve such a behavior?

My implementation:

namespace WpfApp1
{
    public partial class MainWindow : Window
    {
        public MainWindow()
        {
            InitializeComponent();
        }

        async void Window_MouseLeftButtonDown(object sender, MouseButtonEventArgs e)
        {
            Window w = new ProgressWindow();

            var task = 
                Task
                .Run(() => Go())
                .ContinueWith(completedTask => w.Close());
            w.ShowDialog();
            await task; // InvalidOperationException throws
        }

        async protected void Go()
        {
            await Task.Delay(500); // imitate some work    
            MessageBox.Show("Completed!"); // indicate that work has been completed
        }
    }
}

Answer 1

There is no need to use a continuation here, just stick to await. Not only that, but because you used async void the program did not wait half a second before closing the window.

Also, there is really no benefit in this case to use Task.Run since Go already can be made awaitable.

The improved and simplified code is:

public partial class MainWindow : Window
{
    public MainWindow()
    {
        InitializeComponent();
    }

    async void Window_MouseLeftButtonDown(object sender, MouseButtonEventArgs e)
    {
        Window w = new ProgressWindow();
        Task work = Go(w);
        w.ShowDialog();
        await work; // exceptions in unawaited task are difficult to handle, so let us await it here.
    }

    async Task Go(Window w)
    {
        await Task.Delay(500);    
        w.Close();
    }
}

The reason you got the error was that (the continuation of) the Task created by Task.Run executes on a non-UI thread and it is not allowed to access the UI (w.Close();) in a non-UI thread.

If you have work that benefits from Task.Run you can modify the Go() method like this:

async Task Go(Window w)
{
    await Task.Run(() => { 
        // ... heavy work here  
    });    
    w.Close();
}

Answer 2

Here is an extension method ShowDialogUntilTaskCompletion that can be used in place of the built-in ShowDialog. It closes automatically the window when the supplied Task is completed. In case the task completes with an exception, the window is still closed, and the method returns without throwing.

It's possible to prevent the user from closing the window (and causing the method to return before the task is complete) by handling the Closing event on the window and setting the CancelEventArgs.Cancel property to true. The method unsubscribes from the event before calling Window.Close() method otherwise that would get cancelled too.

public static class WindowExtensions
{
    public static bool? ShowDialogUntilTaskCompletion(this Window window,
        Task task, int minDurationMsec = 500)
    {
        ArgumentNullException.ThrowIfNull(window);
        ArgumentNullException.ThrowIfNull(task);
        if (minDurationMsec < 0)
            throw new ArgumentOutOfRangeException(nameof(minDurationMsec));

        Task closeDelay = Task.Delay(minDurationMsec);
        window.Closing += PreventUserClosing;
        HandleTaskCompletion();
        return window.ShowDialog();

        async void HandleTaskCompletion()
        {
            try
            {
                await Task.Yield(); // Ensure that the completion is asynchronous
                await task;
            }
            catch { } // Ignore exception
            finally
            {
                await closeDelay;
                window.Closing -= PreventUserClosing;
                window.Close();
            }
        }

        void PreventUserClosing(object sender, CancelEventArgs e)
        {
            e.Cancel = true;
        }
    }
}

As a bonus it also accepts a minDurationMsec parameter, to keep the window visible for the minimum duration specified (so that the window is not closed in the blink of an eye).

Usage example:

async void Window_MouseLeftButtonDown(object sender, MouseButtonEventArgs e)
{
    Window w = new ProgressWindow();
    Task task = Task.Delay(2000); // Simulate some asynchronous work
    w.ShowDialogUntilTaskCompletion(task);
    try
    {
        // Most likely the task will be completed at this point
        await task;
    }
    catch (Exception ex)
    {
        // Handle the case of a faulted task
    }
}

Answer 3

I read the Peter Bons's answer and rethink it - his approach uses the asynchronous Go method (as it was in my question of course) and then awaits its result without Task.Run. Another variant which I came to is based on the answers of Peter Bons and Andrew Shkolik. I call a synchronous method Go asynchronously through Task.Run and use Dispatcher to manipulate the window.

public partial class MainWindow : Window
{
    public MainWindow()
    {
        InitializeComponent();
    }

    async void Window_MouseLeftButtonDown(object sender, MouseButtonEventArgs e)
    {
        Window w = new ProgressWindow();
        Task work = Task.Run(() => Go(w));
        w.ShowDialog();
        await work;
    }

    void Go(Window w)
    {
        Thread.Sleep(2000); // imitate some work
        Dispatcher.BeginInvoke(
            new Action(() =>
            {
                w.Close();
            }));
    }
}

Answer 4

Maybe a bit late but here is a fully working solution based on TPL an IProgress

public partial class ProgressDlg<T> : Form where T : class
{
    public bool ErrorOccured { get; private set; }

    private CancellationTokenSource cts;
    private readonly Func<ProgressWorkerData<T>, Task> worker;

    private readonly Form owner;

    public ProgressDlg(Form owner, Func<ProgressWorkerData<T>, Task> worker, bool allowCancel = false)
    {
        this.owner  = owner;
        this.worker = worker;

        InitializeComponent();

        if (!allowCancel)
            panelCancel.Visible = false;
    }

    public void Start(CancellationToken ct)
    {
        Start(null, ct);
    }

    public void Start(T userData, CancellationToken ct)
    {
        bool useWaitCursor          = Application.UseWaitCursor;
        Application.UseWaitCursor   = true;

        var progress = new Progress<ProgressData>(value =>
        {
            labelMessage.Text       = value.Message;
            labelMessage.ForeColor  = value.IsError ? Color.Red : Color.Black;
        });

        cts = CancellationTokenSource.CreateLinkedTokenSource(ct);

        Task.Run(async () =>
        {
            try
            {
                await worker.Invoke(new ProgressWorkerData<T>(userData, progress, cts.Token));
            }
            catch (OperationCanceledException)
            {
            }
            catch (Exception)
            {
                ErrorOccured = true;
            }
            finally
            { 
                cts.Dispose();
            }
        }, cts.Token)
        .ContinueWith(completedTask =>
        {
            Close();
        }, TaskScheduler.FromCurrentSynchronizationContext());

        ShowDialog(owner);

        Application.UseWaitCursor = useWaitCursor;
    }
}

Basically what OP was missing is

.ContinueWith(completedTask =>
{
    Close();
}, TaskScheduler.FromCurrentSynchronizationContext());

The CancellationTokenSource (cts) can be used to cancel a longer operation by e.g. clicking on a dialog's button

Usage:

private void Button_Click(object sender, EventArgs e)
{
    using (var progDlg = new ProgressDlg<string>(this, DoWork, true))
        progDlg.Start(data, CancellationToken); //This is a blocking call
}

private async Task DoWork(ProgressWorkerData<string> workerData)
{
    string myData = workerData.UserData;
    await Task.Delay(10000, workerData.CancellationToken);  //Do sth
}

For completeness

public class ProgressData
{
    public string Message { get; set; }
    public bool IsError { get; set; }

    public ProgressData(string message, bool isError = false)
    {
        Message = message;
        IsError = isError;
    }
}

public class ProgressWorkerData
{
    public CancellationToken CancellationToken { get; }

    private readonly IProgress<ProgressData> progress;

    public ProgressWorkerData(IProgress<ProgressData> progress, CancellationToken ct)
    {
        this.progress       = progress;
        CancellationToken   = ct;
    }

    public void Report(string message, bool isError = false)
    {
        progress.Report(new ProgressData(message, isError));
    }
}

public class ProgressWorkerData<T> : ProgressWorkerData
{
    public T UserData { get; }

    public ProgressWorkerData(T userData, IProgress<ProgressData> progress, CancellationToken ct) :
        base(progress, ct)
    {
        UserData = userData;
    }
}    

Answer 5

You trying to close window from background thread... If you still want use Task.Run().ContinueWith() then you should use Dispatcher to close window. But better use async\await syntax.

    async void Window_MouseLeftButtonDown(object sender, MouseButtonEventArgs e)
    {
        Window w = new ProgressWindow();

        var task = Task.Run(() => Go()).ContinueWith(completedTask =>
            {
                Application.Current.Dispatcher.BeginInvoke(
                DispatcherPriority.Send, new Action(() =>
                {
                    w.Close(); 
                }));

            });
        w.ShowDialog();
        await task;
    }

Answer 6

async (p) => 
      { 
      await Task.Run(() => { 
      
      if (p == null) return; 
      //code
      }).ConfigureAwait(true); 
      p.Close(); 
      });