Show progress only if a background operation is long

I'm developing a C# operation and I would like to show a modal progress dialog, but only when an operation will be long (for example, more than 3 seconds). I execute my operations in a background thread.

The problem is that I don't kno开发者_Python百科w in advance whether the operation will be long or short.

Some software as IntelliJ has a timer aproach. If the operation takes more than x time, then show a dialog then.

What do you think that is a good pattern to implement this?

• Wait the UI thread with a timer, and show dialog there?
• Must I DoEvents() when I show the dialog?

---

Here's what I'd do:

1) Use a BackgroundWorker.

2) In before you call the method RunWorkerAsync, store the current time in a variable.

3) In the DoWork event, you'll need to call ReportProgress. In the ProgressChanged event, check to see if the time has elapsed greater than three seconds. If so, show dialog.

Here is a MSDN example for the BackgroundWorker: http://msdn.microsoft.com/en-us/library/cc221403(v=vs.95).aspx

Note: In general, I agree with Ramhound's comment. Just always display the progress. But if you're not using BackgroundWorker, I would start using it. It'll make your life easier.

---

I will go with the first choice here with some modifications:

First run the possible long running operation in different thread.
Then run a different thread to check the first one status by a wait handle with timeout to wait it for finish. if the time out triggers there show the progress bar.

Something like:

private ManualResetEvent _finishLoadingNotifier = new ManualResetEvent(false);

private const int ShowProgressTimeOut = 1000 * 3;//3 seconds


private void YourLongOperation()
{
    ....

    _finishLoadingNotifier.Set();//after finish your work
}

private void StartProgressIfNeededThread()
{
    int result = WaitHandle.WaitAny(new WaitHandle[] { _finishLoadingNotifier }, ShowProgressTimeOut);

    if (result > 1)
    {
        //show the progress bar.
    } 
}

---

Assuming you have a DoPossiblyLongOperation(), ShowProgressDialog() and HideProgressDialog() methods, you could use the TPL to do the heavy lifting for you:

var longOperation = new Task(DoPossiblyLongOperation).ContinueWith(() => myProgressDialog.Invoke(new Action(HideProgressDialog)));

if (Task.WaitAny(longOperation, new Task(() => Thread.Sleep(3000))) == 1)
    ShowProgressDialog();

---

I would keep the progress dialog separate from the background activity, to separate my UI logic from the rest of the application. So the sequence would be (This is essentially the same as what IntelliJ does):

1. UI starts the background operation (in a BackgroundWorker) and set up a timer for X seconds
2. When the timer expires UI shows the progress dialog (if the background task is still running)
3. When the background task completes the timer is cancelled and the dialog (if any) is closed

Using a timer instead of a separate thread is more resource-efficient.

---

Recommended non-blocking solution and no new Threads:

try
{
   var t = DoLongProcessAsync();
   if (await Task.WhenAny(t, Task.Delay(1000)) != t) ShowProgress();
   await t;
}
finally
{
   HideProgress();
}

---

I got the idea from Jalal Said answer. I required the need to timeout or cancel the progress display. Instead of passing an additional parameter (cancellation token handle) to the WaitAny I changed the design to depend on Task.Delay()

private const int ShowProgressTimeOut = 750;//750 ms seconds
public static void Report(CancellationTokenSource cts)
{
    Task.Run(async () =>
    {
        await Task.Delay(ShowProgressTimeOut);
        if (!cts.IsCancellationRequested)
        {
            // Report progress
        }
    });
}

Use it like so;

private async Task YourLongOperation()
{
    CancellationTokenSource cts = new CancellationTokenSource();
    try
    {
        // Long running task on background thread
        await Task.Run(() => {
            Report(cts);
            // Do work
            cts.Cancel();
        });
    }
    catch (Exception ex) { }
    finally {cts.Cancel();}
}