c# 有更好的等待模式吗？

Question

我发现自己曾多次编写过这种类型的代码。

for (int i = 0; i < 10; i++)
{
   if (Thing.WaitingFor())
   {
      break;
   }
   Thread.Sleep(sleep_time);
}
if(!Thing.WaitingFor())
{
   throw new ItDidntHappenException();
}

它只是看起来像糟糕的代码，有没有更好的方法来做到这一点/这是糟糕设计的症状吗？

Answer 1

实现此模式的更好方法是让您的Thing 对象公开一个消费者可以等待的事件。例如ManualResetEvent 或AutoResetEvent。这极大地简化了你的消费者代码如下

if (!Thing.ManualResetEvent.WaitOne(sleep_time)) {
  throw new ItDidntHappen();
}

// It happened

Thing 一侧的代码实际上也不再复杂。

public sealed class Thing {
  public readonly ManualResetEvent ManualResetEvent = new ManualResetEvent(false);

  private void TheAction() {
    ...
    // Done.  Signal the listeners
    ManualResetEvent.Set();
  }
}

Answer 2

使用事件。

让您等待的事物在完成时（或未能在分配的时间内完成）引发事件，然后在您的主应用程序中处理该事件。

这样你就没有任何Sleep 循环。

Answer 3

如果您的程序在等待时（例如在连接到数据库时）没有其他事情可做，那么循环并不是等待某事的可怕方式。但是，我发现您的问题存在一些问题。

    //It's not apparent why you wait exactly 10 times for this thing to happen
    for (int i = 0; i < 10; i++)
    {
        //A method, to me, indicates significant code behind the scenes.
        //Could this be a property instead, or maybe a shared reference?
        if (Thing.WaitingFor()) 
        {
            break;
        }
        //Sleeping wastes time; the operation could finish halfway through your sleep. 
        //Unless you need the program to pause for exactly a certain time, consider
        //Thread.Yield().
        //Also, adjusting the timeout requires considering how many times you'll loop.
        Thread.Sleep(sleep_time);
    }
    if(!Thing.WaitingFor())
    {
        throw new ItDidntHappenException();
    }

简而言之，上面的代码看起来更像是一个“重试循环”，它被搞得更像是一个超时。以下是我构建超时循环的方式：

var complete = false;
var startTime = DateTime.Now;
var timeout = new TimeSpan(0,0,30); //a thirty-second timeout.

//We'll loop as many times as we have to; how we exit this loop is dependent only
//on whether it finished within 30 seconds or not.
while(!complete && DateTime.Now < startTime.Add(timeout))
{
   //A property indicating status; properties should be simpler in function than methods.
   //this one could even be a field.
   if(Thing.WereWaitingOnIsComplete)
   {
      complete = true;
      break;
   }

   //Signals the OS to suspend this thread and run any others that require CPU time.
   //the OS controls when we return, which will likely be far sooner than your Sleep().
   Thread.Yield();
}
//Reduce dependence on Thing using our local.
if(!complete) throw new TimeoutException();

Answer 4

如果可能，将异步处理封装在 Task<T> 中。这提供了世界上最好的：

• 您可以使用task continuations 以类似事件的方式响应完成。
• 您可以使用完成的可等待句柄等待，因为Task<T> 实现了IAsyncResult。
• 使用Async CTP 可以轻松组合任务；他们还与Rx 配合得很好。
• 任务有一个非常干净的内置异常处理系统（特别是，它们正确地保留了堆栈跟踪）。

如果您需要使用超时，那么 Rx 或 Async CTP 可以提供。

Answer 5

我会看看WaitHandle 类。特别是等待直到设置对象的ManualResetEvent 类。您还可以为其指定超时值并检查它是否在之后设置。

// Member variable
ManualResetEvent manual = new ManualResetEvent(false); // Not set

// Where you want to wait.
manual.WaitOne(); // Wait for manual.Set() to be called to continue here
if(!manual.WaitOne(0)) // Check if set
{
   throw new ItDidntHappenException();
}

Answer 6

对Thread.Sleep 的调用始终是应避免的主动等待。
一种替代方法是使用计时器。为了方便使用，您可以将其封装到一个类中。

Answer 7

我通常不鼓励抛出异常。

// Inside a method...
checks=0;
while(!Thing.WaitingFor() && ++checks<10) {
    Thread.Sleep(sleep_time);
}
return checks<10; //False = We didn't find it, true = we did

Answer 8

我认为您应该使用 AutoResetEvents。当您等待另一个线程完成它的任务时，它们工作得很好

例子：

AutoResetEvent hasItem;
AutoResetEvent doneWithItem;
int jobitem;

public void ThreadOne()
{
 int i;
 while(true)
  {
  //SomeLongJob
  i++;
  jobitem = i;
  hasItem.Set();
  doneWithItem.WaitOne();
  }
}

public void ThreadTwo()
{
 while(true)
 {
  hasItem.WaitOne();
  ProcessItem(jobitem);
  doneWithItem.Set();

 }
}

Answer 9

下面是使用System.Threading.Tasks 的方法：

Task t = Task.Factory.StartNew(
    () =>
    {
        Thread.Sleep(1000);
    });
if (t.Wait(500))
{
    Console.WriteLine("Success.");
}
else
{
    Console.WriteLine("Timeout.");
}

但是，如果由于某种原因（例如 .Net 2.0 的要求）您不能使用任务，那么您可以使用 JaredPar 的回答中提到的 ManualResetEvent 或使用类似的东西：

public class RunHelper
{
    private readonly object _gate = new object();
    private bool _finished;
    public RunHelper(Action action)
    {
        ThreadPool.QueueUserWorkItem(
            s =>
            {
                action();
                lock (_gate)
                {
                    _finished = true;
                    Monitor.Pulse(_gate);
                }
            });
    }

    public bool Wait(int milliseconds)
    {
        lock (_gate)
        {
            if (_finished)
            {
                return true;
            }

            return Monitor.Wait(_gate, milliseconds);
        }
    }
}

使用等待/脉冲方法，您无需显式创建事件，因此您无需关心如何处理它们。

使用示例：

var rh = new RunHelper(
    () =>
    {
        Thread.Sleep(1000);
    });
if (rh.Wait(500))
{
    Console.WriteLine("Success.");
}
else
{
    Console.WriteLine("Timeout.");
}