我想在两条指令之间等待几秒钟，但不会阻塞执行。
例如Thread.Sleep(2000)不好，因为它会阻塞执行。
这个想法是我调用一个方法，然后等待 X 秒（例如 20 秒）来监听事件的到来。在 20 秒结束时，我应该根据 20 秒内发生的情况进行一些操作。
【问题讨论】：
我认为您所追求的是Task.Delay。这不会像 Sleep 那样阻塞线程，这意味着您可以使用异步编程模型使用单个线程来执行此操作。
async Task PutTaskDelay()
{
await Task.Delay(5000);
}
private async void btnTaskDelay_Click(object sender, EventArgs e)
{
await PutTaskDelay();
MessageBox.Show("I am back");
}
【讨论】：
PutTaskDelay()，直接拨打await Task.Delay(5000);就可以了
我用：
private void WaitNSeconds(int segundos)
{
if (segundos < 1) return;
DateTime _desired = DateTime.Now.AddSeconds(segundos);
while (DateTime.Now < _desired) {
System.Windows.Forms.Application.DoEvents();
}
}
【讨论】：
这是使用另一个线程的好例子：
// Call some method
this.Method();
Task.Factory.StartNew(() =>
{
Thread.Sleep(20000);
// Do things here.
// NOTE: You may need to invoke this to your main thread depending on what you're doing
});
以上代码需要.NET 4.0或以上，否则试试：
ThreadPool.QueueUserWorkItem(new WaitCallback(delegate
{
Thread.Sleep(20000);
// Do things here
}));
【讨论】：
如果您无法将环境升级到 .NET 4.5 以获得对 async 和 await API 的访问权限，Omar 的解决方案是不错的*。也就是说，为了避免性能不佳，应该进行一项重要的更改。应在调用 Application.DoEvents() 之间添加轻微延迟，以防止 CPU 使用过多。通过添加
Thread.Sleep(1);
在调用 Application.DoEvents() 之前，您可以添加这样的延迟（1 毫秒）并阻止应用程序使用所有可用的 cpu 周期。
private void WaitNSeconds(int seconds)
{
if (seconds < 1) return;
DateTime _desired = DateTime.Now.AddSeconds(seconds);
while (DateTime.Now < _desired) {
Thread.Sleep(1);
System.Windows.Forms.Application.DoEvents();
}
}
*有关使用 Application.DoEvents() 的潜在陷阱的更详细讨论，请参阅 https://blog.codinghorror.com/is-doevents-evil/。
【讨论】：
如果你不想阻塞，也不想使用多线程，这里有适合你的解决方案： https://msdn.microsoft.com/en-us/library/system.timers.timer(v=vs.110).aspx
UI Thread 没有被阻塞，定时器等待 2 秒再做某事。
这是来自上面链接的代码：
// Create a timer with a two second interval.
aTimer = new System.Timers.Timer(2000);
// Hook up the Elapsed event for the timer.
aTimer.Elapsed += OnTimedEvent;
aTimer.Enabled = true;
Console.WriteLine("Press the Enter key to exit the program... ");
Console.ReadLine();
Console.WriteLine("Terminating the application...");
【讨论】：
你好，这是我的建议
.......
var t = Task.Run(async () => await Task.Delay(TimeSpan.FromSeconds(Consts.FiveHundred)).ConfigureAwait(false));
//just to wait task is done
t.Wait();
请记住“等待”，否则延迟运行不会影响应用程序
【讨论】：
在我的情况下，我需要这样做，因为我已经将一个方法传递给了我正在等待的线程，这导致了锁定，因为 metod 在 GUI 线程上运行并且线程代码有时会调用该方法。
Task<string> myTask = Task.Run(() => {
// Your code or method call
return "Maybe you want to return other datatype, then just change it.";
});
// Some other code maybe...
while (true)
{
myTask.Wait(10);
Application.DoEvents();
if (myTask.IsCompleted) break;
}
【讨论】：
Application.DoEvents()。这是邪恶和阴险的。
如果可能，首选方法应该是使用异步方式或第二个线程。
如果这不可能或不想要，使用DoEvents() 的任何实现都是一个坏主意，因为它可能会导致问题Possible problems with DoEvents。这主要是关于带有 Winforms 的 DoEvents，但 WPF 中可能存在的陷阱是相同的。
然后在 Dispatcher 上放置一个具有所需睡眠时间的帧：
using System;
using System.Threading;
using System.Windows.Threading;
public static void NonBlockingSleep(int timeInMilliseconds)
{
DispatcherFrame df = new DispatcherFrame();
new Thread((ThreadStart)(() =>
{
Thread.Sleep(TimeSpan.FromMilliseconds(timeInMilliseconds));
df.Continue = false;
})).Start();
Dispatcher.PushFrame(df);
}
【讨论】：
您可以使用本地时间。例如等待 10 秒：
LocalTime tenSecondsLater = LocalTime.now().plus(10, ChronoUnit.SECONDS);
while (tenSecondsLater.isAfter(LocalTime.now())) {}
// continue
【讨论】：
查看System.Threading.Timer 类。我想这就是你要找的。p>
code example on MSDN 似乎表明这个类与你正在尝试做的非常相似（在特定时间后检查状态）。
MSDN 链接中提到的代码示例：
using System;
using System.Threading;
class TimerExample
{
static void Main()
{
// Create an AutoResetEvent to signal the timeout threshold in the
// timer callback has been reached.
var autoEvent = new AutoResetEvent(false);
var statusChecker = new StatusChecker(10);
// Create a timer that invokes CheckStatus after one second,
// and every 1/4 second thereafter.
Console.WriteLine("{0:h:mm:ss.fff} Creating timer.\n",
DateTime.Now);
var stateTimer = new Timer(statusChecker.CheckStatus,
autoEvent, 1000, 250);
// When autoEvent signals, change the period to every half second.
autoEvent.WaitOne();
stateTimer.Change(0, 500);
Console.WriteLine("\nChanging period to .5 seconds.\n");
// When autoEvent signals the second time, dispose of the timer.
autoEvent.WaitOne();
stateTimer.Dispose();
Console.WriteLine("\nDestroying timer.");
}
}
class StatusChecker
{
private int invokeCount;
private int maxCount;
public StatusChecker(int count)
{
invokeCount = 0;
maxCount = count;
}
// This method is called by the timer delegate.
public void CheckStatus(Object stateInfo)
{
AutoResetEvent autoEvent = (AutoResetEvent)stateInfo;
Console.WriteLine("{0} Checking status {1,2}.",
DateTime.Now.ToString("h:mm:ss.fff"),
(++invokeCount).ToString());
if(invokeCount == maxCount)
{
// Reset the counter and signal the waiting thread.
invokeCount = 0;
autoEvent.Set();
}
}
}
// The example displays output like the following:
// 11:59:54.202 Creating timer.
//
// 11:59:55.217 Checking status 1.
// 11:59:55.466 Checking status 2.
// 11:59:55.716 Checking status 3.
// 11:59:55.968 Checking status 4.
// 11:59:56.218 Checking status 5.
// 11:59:56.470 Checking status 6.
// 11:59:56.722 Checking status 7.
// 11:59:56.972 Checking status 8.
// 11:59:57.223 Checking status 9.
// 11:59:57.473 Checking status 10.
//
// Changing period to .5 seconds.
//
// 11:59:57.474 Checking status 1.
// 11:59:57.976 Checking status 2.
// 11:59:58.476 Checking status 3.
// 11:59:58.977 Checking status 4.
// 11:59:59.477 Checking status 5.
// 11:59:59.977 Checking status 6.
// 12:00:00.478 Checking status 7.
// 12:00:00.980 Checking status 8.
// 12:00:01.481 Checking status 9.
// 12:00:01.981 Checking status 10.
//
// Destroying timer.
【讨论】：