在不阻塞主线程的情况下等待一段时间

Question

I wish my method to wait about 500 ms and then check if some flag has changed. How to complete this without blocking the rest of my application?

Answer 1

Thread.Sleep(500) will force the current thread to wait 500ms. It works, but it's not what you want if your entire application is running on one thread.

In that case, you'll want to use a Timer , like so:

using System.Timers;

void Main()
{
    Timer t = new Timer();
    t.Interval = 500; // In milliseconds
    t.AutoReset = false; // Stops it from repeating
    t.Elapsed += new ElapsedEventHandler(TimerElapsed);
    t.Start();
}

void TimerElapsed(object sender, ElapsedEventArgs e)
{
    Console.WriteLine("Hello, world!");
}

You can set AutoReset to true (or not set it at all) if you want the timer to repeat itself.

Answer 2

You can use await Task.Delay(500); without blocking the thread like Sleep does, and with a lot less code than a Timer.

Answer 3

I don't really understand the question.

If you want to block before checking, use Thread.Sleep(500);

If you want to check asynchronously every x seconds, you can use a Timer to execute a handler every x milliseconds.

This will not block your current thread.

Answer 4

如果有问题的方法与应用程序的其余部分在不同的线程上执行，请执行以下操作：

Thread.Sleep(500);

Answer 5

System.Threading.Thread.Sleep(500);

Update

This won't block the rest of your application, just the thread that is running your method.

Answer 6

Using a timer should do the trick

if you need to use a thread then here is an example

void Main()
{
    System.Threading.Thread check= new System.Threading.Thread(CheckMethod);
    check.Start();
}

private void CheckMethod()
{
     //Code
     Thread.Sleep(500);
}

Answer 7

Asynchron Task:

 var task = new Task (() => function_test()); task.Start();

public void function_test() { `Wait for 5000 miliseconds`   Task.Delay(5000);` }

Answer 8

I've recently been struggling with the same issue where I needed an action to be run on schedule without blocking the UI.

Here's my solution:

private void Button_Click(object sender, RoutedEventArgs e)
{
    RunOnSchedule(interval, cancellationToken);
}

private void RunOnSchedule(int interval, CancellationToken cancellationToken)
{
    // Start the task you want to run on schedule
    TaskToRunOnSchedule(args);
    Task.Run(async () => 
    {
        // This loop checks if the task was requested to be cancelled every 1000 ms
        for (int x = 0; x < interval; x+=1000)
        {
            if (cancellationToken.IsCancellationRequested)
            {
                break;
            }

            await Task.Delay(1000);
        }
    }).GetAwaiter().OnCompleted(() =>
    {
        // Once the task for delaying is completed, check once more if cancellation is requested, as you will reach this point regardless of if it was cancelled or not.
        if (!cancellationToken.IsCancellationRequested)
        {
            // Run this method again
            RunOnSchedule(interval, cancellationToken);
        }
    });
}

Answer 9

In a WinForms application, when I want to wait on the main thread without blocking the app, I usually use

private void Wait (double milliseconds)
{
    DateTime next = System.DateTime.Now.AddMilliseconds(milliseconds);
    while (next > System.DateTime.Now)
        Application.DoEvents();
}