Gibt es ein besseres Warteschema für c#?

Question

Ich habe diese Art von Kodierung schon ein paar Mal erlebt.

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

Es sieht einfach nach schlechtem Code aus, gibt es einen besseren Weg, dies zu tun / ist es ein Symptom für schlechtes Design?

Answer 1

Ein Aufruf zur Thread.Sleep ist immer eine aktive Wartezeit, die vermieden werden sollte.
Eine Alternative wäre die Verwendung einer Zeitschaltuhr. Zur einfacheren Verwendung könnten Sie diesen in einer Klasse kapseln.

Answer 2

Ich rate normalerweise davon ab, Ausnahmen zu machen.

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

Ich denke, Sie sollten AutoResetEvents verwenden. Sie funktionieren hervorragend, wenn Sie darauf warten, dass ein anderer Thread seine Aufgabe beendet

Beispiel:

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 4

So können Sie es machen mit System.Threading.Tasks :

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

Wenn Sie Tasks jedoch aus irgendeinem Grund nicht verwenden können (z. B. eine Anforderung von .Net 2.0), können Sie ManualResetEvent wie in der Antwort von JaredPar erwähnt, oder verwenden Sie 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 dem Wait/Pulse-Ansatz erstellen Sie nicht explizit Ereignisse, so dass Sie sich nicht um deren Beseitigung kümmern müssen.

Beispiel für die Verwendung:

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