Gibt es einen besseren warten-Muster für c#?

Einen viel besseren Weg zur Umsetzung dieses Musters ist es, Ihre Thing Objekt machen eine Veranstaltung, auf der die Verbraucher warten kann. Zum Beispiel ein ManualResetEvent oder AutoResetEvent. Dies vereinfacht Ihre consumer-code werden die folgenden

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

//It happened

Den code auf der Thing Seite ist auch nicht wirklich komplexer.

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

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

Einer Schleife ist nicht eine SCHRECKLICHE Art und Weise, auf etwas zu warten, wenn es nichts anderes gibt, für das Programm zu tun, während Sie wartet (zum Beispiel beim herstellen einer Verbindung zu einer DB). Allerdings sehe ich einige Probleme mit Ihnen.

    //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();
    }

Kurz gesagt, der obige code sieht mehr wie ein "wiederholen" wiederholen", das war bastardized arbeiten eher wie ein timeout. Hier ist, wie würde ich die Struktur einer timeout-Schleife:

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

Ich würde werfen Sie einen Blick auf die WaitHandle Klasse. Speziell die ManualResetEvent Klasse, wartet, bis das Objekt gesetzt ist. Sie können auch angeben timeout-Werte für es und überprüfen, ob es gesetzt wurde danach.

//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();
}

Ich in der Regel davon abhalten das auslösen von Ausnahmen.

//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

Hier ist, wie Sie es tun können, mit System.Threading.Tasks:

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

Aber wenn Sie nicht verwenden können, die Aufgaben für einige Grund (wie eine Anforderung .Net 2.0), dann können Sie ManualResetEvent wie bereits in JaredPar Antwort oder so etwas wie dieses:

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

Mit der Warte - /Puls-Ansatz nicht explizit, Ereignisse zu erstellen, so brauchen Sie nicht zu kümmern, entsorgen Sie Sie.

Beispiel:

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