How to put a task to sleep (or delay) in C# 4.0?

Question

There is Task.Delay in .NET 4.5

How can I do the same in .NET 4.0?

Glen

Thread.Sleep? – Gomar

Have a look here: msdn.microsoft.com/en-us/library/hh194845.aspx Or use Thread.Sleep and add a reference to using System.Threading; – Sedda

possible duplicate: https://mcmap.net/q/76765/-correct-way-to-delay-the-start-of-a-task – Gomar

@Default, for using Sleep() the task should have always: 1)spawned a separate thread, and 2)only one. No less and no more and 3)it cannot be reused. Nothing of this holds for a task. It is not a dupe, your link is about delaying a the start of a task. My question is about putting it to sleep at any moment after its start – Glen

@Mobstaa, I could not find any conceptual difference between my reference and yours. What was the point? – Glen

I'm confused, Task.Delay() does not put a task to sleep, it creates a new Task. If you wait on that, then it will put a task to sleep for the given amount of time. Is that what you're looking for? A Task that will complete after specified time? – Corned

@Default Besides what was already written Thread.Sleep blocks a thread instead of releasing it back to thread pool, what would lead to thread starvation in a multi threaded system like ASP.Net. – Kibler

@Sedda Task.Delay is not available in .Net 4.0. – Kibler

@EliArbel: Why? I thought it is OK to use Thread.Sleep in synchronous code. – Hockett

Answer 1

You can use a Timer to create a Delay method in 4.0:

public static Task Delay(double milliseconds)
{
    var tcs = new TaskCompletionSource<bool>();
    System.Timers.Timer timer = new System.Timers.Timer();
    timer.Elapsed+=(obj, args) =>
    {
        tcs.TrySetResult(true);
    };
    timer.Interval = milliseconds;
    timer.AutoReset = false;
    timer.Start();
    return tcs.Task;
}

Catinacation

thanks, I didn't specify but I am trying to add multithreading to my WPF application. Should I use there the Timer with Callback argument? And in Callback() definition use Dispatcher.BeginInvoke()? – Glen

@Glen You're not performing any UI interaction when the timer fires, so there's no reason to. – Catinacation

how to add cancellationToken to it, which Task.Delay provides? – Kerman

@ImranRizvi Add a continuation that does nothing and pass the cancellation token to that continuation. You could of course modify this method to take a cancellation token if you wanted, and just cancel the TCS when the token cancel event fires, if you feel up for making that modification. – Catinacation

Doesn't this create a race condition? If the timer object would happen to get garbage collected before the timer expires, it seems that TrySetResult would never get called. – Carlist

@EdwardBrey The Timer class specifically handles this internally to ensure that users of it don't need to hold onto a reference to it for it's lifetime. As long as the timer is currently running it adds a reference to itself from a rooted location and then removes it when it's no longer running. – Catinacation

@Servy, I know, this is pretty old question, but I gotta ask - why this solution doesn't explicitly dispose created timer instances? Shouldn't they be disposed? – Unwrap

@IlyaLuzyanin The finalizer should take care of it, but you can explicitly dispose it in the event handler if you want. – Catinacation

@Servy: You should never depend on a finalizer to dispose of an IDisposable. It should always be disposed of explicitly unless there is specific documentation (e.g. as there is with Task) that states otherwise. – Pencil

@AdamRobinson It all depends on context. It depends on what the object is, what the unmanaged resource is, what the consequences are for not cleaning it up, and the specifics of the program using it. Some cases are more important than others, but it's generally a good idea, yes. – Catinacation

Can you please explain if this is better than the answer provided by 'QrystaL' and why? – Linlithgow

Answer 2

Use the Microsoft.Bcl.Async package from NuGet, it has TaskEx.Delay.

Peaslee

Important piece of information is that the class name is TaskEx and not Task ! – Rewrite

This should be answer. – Lejeune

Answer 3

using System;
using System.Threading;
using System.Threading.Tasks;

class Program
{
    static void Main()
    {
        Delay(2000).ContinueWith(_ => Console.WriteLine("Done"));
        Console.Read();
    }

    static Task Delay(int milliseconds)
    {
        var tcs = new TaskCompletionSource<object>();
        new Timer(_ => tcs.SetResult(null)).Change(milliseconds, -1);
        return tcs.Task;
    }
}

From the section How to implement Task.Delay in 4.0

Theda

I added the example to your answer, in case the link goes dead for some reason. – Gomar

@Glen He wrote is using LinqPad, which adds an extension method to object that prints the value of it's ToString method out. Note that he doesn't use that, nor any other non-library methods in his actual implementation, just the example function that tests it out. – Catinacation

@Servy, thanks. I asked the question in order to reduce the number of the unknowns (and getting answers) but not adding puzzles to resolve. I.e. a person who asks usually does not have expertise to complete the puzzle – Glen

Updated, so you can just copy-paste and run ) – Theda

Shouldn't the Timer be disposed? – Dub

Answer 4

Below is the code and sample harness for a cancellable Task.Delay implementation. You are likely interested in the Delay method.:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace DelayImplementation
{
    class Program
    {
        static void Main(string[] args)
        {
            System.Threading.CancellationTokenSource tcs = new System.Threading.CancellationTokenSource();

            int id = 1;
            Console.WriteLine(string.Format("Starting new delay task {0}. This one will be cancelled.", id));
            Task delayTask = Delay(8000, tcs.Token);
            HandleTask(delayTask, id);

            System.Threading.Thread.Sleep(2000);
            tcs.Cancel();

            id = 2;
            System.Threading.CancellationTokenSource tcs2 = new System.Threading.CancellationTokenSource();
            Console.WriteLine(string.Format("Starting delay task {0}. This one will NOT be cancelled.", id));
            var delayTask2 = Delay(4000, tcs2.Token);
            HandleTask(delayTask2, id);

            System.Console.ReadLine();
        }

        private static void HandleTask(Task delayTask, int id)
        {
            delayTask.ContinueWith(p => Console.WriteLine(string.Format("Task {0} was cancelled.", id)), TaskContinuationOptions.OnlyOnCanceled);
            delayTask.ContinueWith(p => Console.WriteLine(string.Format("Task {0} was completed.", id)), TaskContinuationOptions.OnlyOnRanToCompletion);
        }

        static Task Delay(int delayTime, System.Threading.CancellationToken token)
        {
            TaskCompletionSource<object> tcs = new TaskCompletionSource<object>();

            if (delayTime < 0) throw new ArgumentOutOfRangeException("Delay time cannot be under 0");

            System.Threading.Timer timer = null;
            timer = new System.Threading.Timer(p =>
            {
                timer.Dispose(); //stop the timer
                tcs.TrySetResult(null); //timer expired, attempt to move task to the completed state.
            }, null, delayTime, System.Threading.Timeout.Infinite);

            token.Register(() =>
                {
                    timer.Dispose(); //stop the timer
                    tcs.TrySetCanceled(); //attempt to mode task to canceled state
                });

            return tcs.Task;
        }
    }
}

Marteena

Looks not good! If I'll call a lot of delay with the same CancellationToken, I'll got a lot of delegates registered on the token. – Dustidustie

Answer 5

Extending the idea from this answer:

new AutoResetEvent(false).WaitOne(1000);

Irrational

Answer 6

You can download the Visual Studio Async CTP and use TaskEx.Delay

Accepter

That's not a good idea, the CTP contains known bugs that will never be fixed. Using Bcl.Async is a much better choice. – Corned

Answer 7

In many cases, a sheer AutoResetEvent is better than a Thread.Sleep()...

AutoResetEvent pause = new AutoResetEvent(false);
Task timeout = Task.Factory.StartNew(()=>{
pause.WaitOne(1000, true);
});

hope that it helps

Jinja

I think the original idea is to block the current thread, not to do wait on a yet another thread and just be notified later on the current thread. So, how about this ? – Irrational

Answer 8

    public static void DelayExecute(double delay, Action actionToExecute)
    {
        if (actionToExecute != null)
        {
            var timer = new DispatcherTimer
            {
                Interval = TimeSpan.FromMilliseconds(delay)
            };
            timer.Tick += (delegate
            {
                timer.Stop();
                actionToExecute();
            });
            timer.Start();
        }
    }

Tangential

Answer 9

Here's a succinct, timer-based implementation with proper cleanup:

var wait = new TaskCompletionSource<bool>();
using (new Timer(_ => wait.SetResult(false), null, delay, Timeout.Infinite))
    await wait.Task;

To use this code on .NET 4.0, you need the Microsoft.Bcl.Async NuGet package.

Carlist

The OP is asking about 4.0 - there is no "await" in 4.0. – Irrational

The await keyword is part of the C# language, which is separate from the .NET Framework version. The problem is that Task<T> does not have GetAwaiter, which await relies on. Microsoft.Bcl.Async supplies this. I updated my answer to mention the NuGet package. – Carlist

If one to use Microsoft.Bcl.Async, isn't TaskEx.Delay more succint, then? – Irrational