Mehrere Funktionen mit unterschiedlichen Wartezeiten hintereinander ausführen

Hi,

ich möchte gerne verschiedene Funktionen hintereinander ausführen. Dazwischen liegen verschiedene Wartezeiten. Nach einem Durchlauf sollen die Funktionen erneut aufgerufen werden, usw. bis der User "Stop" oder "Pause" drückt. Ich habe eine Windows-Forms-Anwendung.

Zuerst habe ich einfach mittels Thread.Sleep zwischen den Funktionen gewartet. Das ist leider unvorteilhaft, da dadurch die Anwendung eingefroren wird.

Ich habe mir gedacht, die beste Lösung, und immer hier im Forum empfohlen, sei ein Timer. Jedoch wird dadurch der Programmablauf sehr unübersichtlich, was ich mit folgedem Code verdeutlichen will:

 private void tmrDoWork_Tick(object sender, EventArgs e)
        {
			//timer stoppen, damit er sich nicht "überschlägt"
            tmrDoWork.Stop();

			//pause-funktion
            if (currWorkState == WorkState.Pause)
            {
                tmrWork.Interval = 100;
                tmrWork.Start();
                return;
            }

			if (currWorkState == WorkState.Method1)
			{
				Method1();
				currWorkState = WorkState.Method2;
				tmrWork.Interval = 100;
                tmrWork.Start();
                return;
			}

			if (currWorkState == WorkState.Method2)
			{
				//solange bedingung nicht erfüllt ist, 2 sekunden warten und erneut prüfen
                if (!Bedingung())
                {
                    tmrWork.Interval = 2000;
                    tmrWork.Start();
                    return;
                }
                else
                {
                    currWorkState = WorkState.Method3;
                    tmrWork.Interval = 10000;
                    tmrWork.Start();
                    return;
                }
			}
			
			if (currWorkState == WorkState.Method3)
			{
				Method3();
				tmrWork.Interval = 1;
                tmrWork.Start();
                return;
			}			
            
}

Das Ganze mit mitteln wie Thread.Sleep sieht viel übersichtlicher aus und ist leichter zu verstehen:

private void DoWork()
{
	while(!bStop)
	{	
		while(bPause)
		{
			Thread.Sleep(200);
		}
		
		Method1();
		Thread.Sleep(100);
		
		while(!Bedingung)
		{
			Thread.Sleep(2000);			
		}
		
		Method2();
		Thread.Sleep(10000);
		Method3();
	}
}

Wie macht man es "richtig", damit sich der Programmcode besser lesen lässt? Ist der Timer die richtige Wahl oder sind andere Instrumente besser geeignet? BackgroundWorker, Threads...

Danke im Voraus!

Die Frage die sich aufdrängelt ist warum die Wartezeiten. Das riecht ein wenig nach nicht optimalem Design. Wenn du die ganze Funktionen in einen seperaten Thread auslagerst wäre dein Problem aber im Grunde schon gelöst.
Ist es für dich vorstellbar DoWork dem Backgroundworker Control zu überlassen?

Hallo ravel,

verabschiede dich schnell von der Idee, als könntest du in Windows-Forms sequentiell programmieren. Das ist nicht so. In Windows Forms läuft es ereignisgesteuert. Damit und mit der entsprechenden Denkweise solltest du dich unbedingt anfreunden. Solange du noch in sequentieller Programmierung denkst, werden da immer komische Konstruktionen herauskommen.

Wenn der sequentielle Ablauf im konkreten Fall unbedingt nötig ist, kannst du die Übersichtlichkeit etwas erhöhen, indem du für die unterschiedlichen Schritte jeweils einen eigenen EventHandler verwendest ... den du dann natürlich in dem jeweils vorher gehenden Schritt statt des bisherigen registrieren musst.

herbivore

Hallo ravel,

ansonsten kannst du dir mit einem Stack und einem Timer eine Klasse bauen, die du in etwa wie folgt bedienen könntest:

myclass.AppendAction(() => Method1(), 1000);
myclass.AppendAction(() => Method2(), 2000);
myclass.AppendAction(() => Method3(), 5000);

Wobei der erste Parameter eine Action wäre und der zweite die jeweilige Wartezeit vor der Ausführung.