19

In WPF due to the intricacies on how the interface is updated I sometimes have to perform actions after a short delay.

Currently I'm doing this simply by:

 var dt = new DispatcherTimer(DispatcherPriority.Send); dt.Tick += (s, e) => { dt.Stop(); //DoStuff }; dt.Interval = TimeSpan.FromMilliseconds(200); dt.Start();

But it's both a bit ugly and perhaps too much overhead to create a new timer each time (?) What's the best from a performance standpoint to do it, ie execute most promptly? And what's good way to rewrite the above code into something like:

 this.Dispatcher.BeginInvoke(new Action(delegate() { //DoStuff }), DispatcherPriority.Send,TimeSpan.FromMilliseconds(200));

Where Timespan is the delay, Thanks for any input :)

Improve this question
3
  • Instead of waiting for something before updating, can't you move responsibility for updating the UI to the thing you're waiting on? This would avoid timers. Commented Sep 18, 2010 at 8:09
  • 1
    unfortunately not, it's hacky things like updating the ui and hiding it after a short delay so the window is updated when it's shown again Commented Sep 18, 2010 at 8:26
  • 1
    Makes me feel better that lots of other people have the same problem and the same hack solutions as me. Commented Feb 14, 2019 at 5:26

4 Answers 4

Reset to default
14

I wouldn't assume that the DispatcherTimer is heavy-weight... why not just write an extension method on Dispatcher which allows you to use the syntax you want, and uses a DispatcherTimer in the background? I would personally call it DelayInvoke rather than BeginInvoke though... and I'd also fix it to always use Action rather than an arbitrary delegate... that will make it easier to use lambda expressions:

Dispatcher.DelayInvoke(TimeSpan.FromMilliseconds(200), () => { ... });

(I tend to find it's more readable if anonymous functions are used as the final argument in a method call, but that's just a personal preference.)

Given that you'll quite possibly want to use milliseconds most of the time, you could have another helper method too:

Dispatcher.DelayInvokeMillis(200, () => { ... });

Another alternative to try is merely to use the existing BeginInvoke method but with a very low priority, so your delegate will only be invoked after everything else has finished. Without knowing the details of your situation, it's hard to know whether that'll work or not - but it's worth trying.

Improve this answer
Sign up to request clarification or add additional context in comments.

3 Comments

An extension method would be very nice, but wouldn't that mean I would first have to do a begininvoke on the dispatcher to be on the right thread and then set up the timer, which is a little more overhead than just having the timer? Might not be an issue though...
@MattiasK: Why would it need to do that? It wouldn't really need to interact with the dispatcher at all... that would just be for the sense of consistency. Admittedly I don't know what happens if you create a DispatcherTimer from a different thread... but if it works when done directly, it would work from an extension method without any extra problems.
@MattiasK: I've just checked, and you can tell the DispatcherTimer constructor which Dispatcher it should run on - so you'd use that overload from the extension method, and specify the Dispatcher which had been passed to the method.
13

A .NET 4.5 way:

 public async void MyMethod() { await Task.Delay(20); await Dispatcher.BeginInvoke((Action)DoStuff); }
Improve this answer

2 Comments

Pros and cons over the timer method above?
Simpler as it doesn't need a lambda... that's probably it.
3

I'm not fond of the DispatcherTimer because there is no easy way to pass parameters in other than through function scope/closures.

Instead I use a Task.Delay() and wrap that into a Dispatcher.Delay() extension method:

public static class DispatcherExtensions { public static void Delay(this Dispatcher disp, int delayMs, Action<object> action, object parm = null) { var ignore = Task.Delay(delayMs).ContinueWith((t) => { disp.Invoke(action, parm); }); } public static void DelayWithPriority(this Dispatcher disp, int delayMs, Action<object> action, object parm = null, DispatcherPriority priority = DispatcherPriority.ApplicationIdle) { var ignore = Task.Delay(delayMs).ContinueWith((t) => { disp.BeginInvoke(action, priority, parm); }); } public static async Task DelayAsync(this Dispatcher disp, int delayMs, Action<object> action, object parm = null, DispatcherPriority priority = DispatcherPriority.ApplicationIdle) { await Task.Delay(delayMs); await disp.BeginInvoke(action, priority, parm); } }

To call this then:

Dispatcher.Delay(4000, (win) => { var window = win as MainWindow; window.ShowStatus(null, 0); },this);
Improve this answer

1 Comment

Very neat solution. Can you detail the pros/cons of using Task.Delay vs a Timer ? Is it just the ability to pass arguments that is your concern?
0

You might be able to use the Paul Stowell's DelayBinding class from here: http://www.paulstovell.com/wpf-delaybinding.

With this can can bind to a DependencyProperty on a class that can execute the action when the property changes. The binding will manage the delay. Might be particularly nice if you have a MVVM-type design.

Improve this answer

Comments

Start asking to get answers

Find the answer to your question by asking.

Ask question

Explore related questions

See similar questions with these tags.