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?

Solution 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;
}

Solution 2

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

Solution 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

Solution 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;
        }
    }
}

Solution 5

Extending the idea from this answer:

new AutoResetEvent(false).WaitOne(1000);

View more solutions

Comments

[default]

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

[Servy]

@Fulproof 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.

[Fulproof]

@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

[Fulproof]

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()?

[QrystaL]

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

[Servy]

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

[Imran Rizvi]

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

[Servy]

@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.

[Edward Brey]

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.

[Servy]

@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.

[svick]

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

[Ilya Luzyanin]

@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?

[Servy]

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

[Adam Robinson]

@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.

[Servy]

@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.

[Amit G]

Shouldn't the Timer be disposed?

[RollingStone]

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.

[OneWorld]

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

[Alex R.]

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

[Alex R.]

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 ?

[Edward Brey]

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.

[Alex R.]

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

[moien]

This should be answer.

[S.Serpooshan]

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