Declaring Thread in a Constructor in C#

Question

I´m currently figuring out threads and how to work with them. At the same time Im working on my understanding on Events/Global Events (just for context).

I defined a thread inside a object with the function the thread will use on thread.Start().

internal class Name
    {
        private Thread testthread;

        private EventWaitHandle globalEvent;

        private Eventstest evente = new Eventstest(); //Just to add some methods

        public Name(Thread testthread, EventWaitHandle globalEvent)
        {
            this.testthread = testthread;
            this.globalEvent = globalEvent;
        }

        
        public void Execute()
        {
            bool terminate = false;
            bool eventset = false;
            bool rdy = false;

            while (!terminate)
            {
                if (evente.CheckSysEvent(globalEvent)) 
                {
                    eventset = true; //This is just to check with debugger if the event was raised elsewhere
                }
                Thread.Sleep(100);
            }
        }
    }

So now, like in this example in a Windows Forms App, Im trying to set an instance of this class while setting the instance of the thread at the same time (with the work method the should run later on). Im struggling with this part here.

private void btn_runThread_Click(object sender, EventArgs e)
        {
            threadClass = new Name(new Thread(ProblemHere), globalEvent);
            threadClass.Execute();            
        }

This is a button which starts the thread with the work its supposed to do. The variable threadClass is just the initialization in the forms1.cs:

Name threadClass;

I know that it wants a delegate to pass the method which the thread should use on start. I tried pretty much anything I found and cant make it work. I cant just pass the method, that doesnt work. And the stuff I found in the c# documentation is pretty much just passing the method, as far as I understood it. Which is propably wrong. And I just noticed, how am I able to actually call on that property/thread.start if its only created on runtime?

Answer 1

Not a full solution, but a bump to get you going:

What I would suggest is a little refactor like this

internal class Name
{
    private Thread testthread;

    private EventWaitHandle globalEvent;

    private Eventstest evente = new Eventstest(); //Just to add some methods

    public Name(EventWaitHandle globalEvent)
    {
        this.testthread = new Thread(Execute); // Creates a Thread, that is directed to execute `Execute`
        this.globalEvent = globalEvent;
        this.testthread.Start();  // Tells the framework to schedule the thread for execution.
    }
    
    private void Execute()
    {
        bool terminate = false;
        bool eventset = false;
        bool rdy = false;

        while (!terminate)
        {
            if (evente.CheckSysEvent(globalEvent)) 
            {
                eventset = true; //This is just to check with debugger if the event was raised elsewhere
            }
            Thread.Sleep(100);
        }
    }
}

And in the Button handler just do

private void btn_runThread_Click(object sender, EventArgs e)
{
    threadClass = new Name(globalEvent);
}

Mind that there are still a good portion of mistakes and ooopsies, but at least, this will keep your GUI thread running and you may gain an understanding to go on from here.

---

A totally different approach (if you are willing to consider it) would be to use a System.Windows.Forms.Timer instead. With that you can have a method called every X time, which would check the state of the globalevent as you are trying to get the thread to doing. The timer, however, makes this a little more convenient.

Answer 2

The typical way would be to create the thread in the constructor, as described in the answer by Fildor.

But I want to point out that using the Thread object directly is rarely the correct way to do things since there are other tools more suited for whatever you are tryibng to do:

• If you want to do something compute heavy on a background thread once, and update the UI after it has been done. Use Task.Run and async/await
• If you want to do something every X seconds. Use a timer. There are both timers that run on the main thread or a background thread, see differences between timers.
• If you want to run an compute heavy operation in parallel, use Parallel.For, possibly in combination with Task.Run.
• If you want to call IO intensive methods without freezing the UI, use async/await in combination with the appropriate Async methods.
• If you want to create a producer/consumer or other processing pipeline there is the DataFlow library