Mehrere Threads nacheinander Abarbeiten

Hi,

wie ich dem Beitrag Methode soll auf jeden Fall bis zuende ausgeführt werden trotz Thread.Suspend zu sehen, spiele ich mometan mit Threads rum.

Ich habe jetzt mind. 2 Stunden meine Anwendung ge-debugged und seh den Wald von lauter Bäumen nicht mehr. Also entschuldige ich mich schonmal im Voraus, falls diese Frage zu einfach ist.

Was ich möchte:
Ein Prozess soll 2 Sekunden laufen, pausiert werden und der nächste Prozess soll angeworfen werden, 2 Sekunden laufen, pausiert werden, nächster Prozess, usw.

Ich gehe dabei folgendermaßen vor (dank der Tipps aus einem anderen Beitrag):

• Prozess1 starten (als Thread)
• 2 Sekunden warten
• Prozess1 pausieren
• Wenn Prozess sicher pausiert ist, wird PauseEvent ausgelöst
• im PauseEvent starte ich dann den nächsten Prozess also: Prozess2 starten, 2 Sekunden warten, Prozess2 pausieren. --> PauseEvent wird gefeuert, gleiches Spiel mit Prozess3 usw..

Das Ganze in Code gegossen sieht so aus:

        Worker wrk = new Worker();

        private void btnStart_Click(object sender, EventArgs e)
        {            
            wrk.PauseEvent += new Worker.PauseEventHandler(wrk_PauseEvent);
            wrk.Start();
            Thread.Sleep(2000);
            wrk.Pause();
        }

        void wrk_PauseEvent(object sender, EventArgs e)
        {
            //nächsten thread aufrufen. zu testzwecken und der einfachheit halber rufe ich den selben thread nochmal auf
            wrk.Start();
            Thread.Sleep(2000);
            wrk.Pause();
        }

using System;
using System.Threading;

namespace TEST
{
    class Worker
    {
        public delegate void PauseEventHandler(object sender, EventArgs e);
        public event PauseEventHandler PauseEvent;

        private bool bPause = false;

        public void Start()
        {
            if (bPause)
            {
                Resume();
            }
            else
            {
                Thread tDoIt = new System.Threading.Thread(new System.Threading.ThreadStart(DoIt));
                tDoIt.Start();
            }
        }

        private void Resume()
        {
            bPause = false;
        }

        public void Pause()
        {
            bPause = true;
        }

        private void DoIt()
        {
            //do something
            Thread.Sleep(3000);
            CheckForPause();

            //do something
            Thread.Sleep(2000);
            CheckForPause();
        }

        private void CheckForPause()
        {
            if (bPause)
            {                
                //event irgendwie asynchron aufrufen?
                PauseEvent(this, new EventArgs());
                while (bPause)
                {
                    Thread.Sleep(100);
                }
            }
        }
    }
}

Jetzt zu meinem Problem:
Wenn das erste Mal pausiert wird, wird richtigerweise das PauseEvent gefeuert aber nachfolgender Code (die while-Schleife zum Warten) nicht ausgeführt.

Kann ich das PauseEvent irgendwie asynchron aufrufen oder ist mein Ansatz komplett falsch gedacht?

Wie löse ich das Problem am Besten?

Hallo,

//nächsten thread aufrufen. zu testzwecken und der einfachheit halber rufe ich den selben thread nochmal auf  

Das dürfte der Grund sein. Wenn Du 2 Instanzen von Deinem Worker erstellst, müsste es passen.

Erklärung:
Status bPause == true
PauseEvent ruft Start auf, Start ruft Resume auf.
Status bPause == false

also kein Grund mehr in die Schleife zu gehen.

Grund, MarsStein

Hallo MarsStein,

Du hattest natürlich völlig recht.
Mit mehreren Workern funktioniert es wunderbar.

Danke und Gruß

Welchen parktischen Hintergrund hat das was Du da schreibst?
Mir fällt beim besten Willen kein Grund ein, warum ich einen Thread wegen eines anderen nach 2 Sekunden schlafen schicken soll.