How to run an infinite loop without hanging the program? (c#)

Question

I´m using threads in a c# program, but the process that the threads runs, calls another function that has an infinite loop that locks the program, this is, if I click another option of the Windows Form (ex: close, etc.) it will no longer response.

This loop in necessary and, by now, can not be changed.

Is there a way that I could run this loop like "background" and still use the other options in the program, this is: that the loop does not block the process (I would not like to use threads inside of threads!).

Main Program
     |
     -------Thread(Function)
                       |
                       --------In the function ANOTHER
                               function is called with 
                               an infinite loop inside 
                               (this loop is NOT part of the 
                                Thread function directly)     

EDIT: Adding some example code:

//Here I call the threads
private void userTest_Click(object sender, EventArgs e)
    {
        for (int i = 0; i < numberOfDevices; i++)
        {
            try
            {
            Thread t = new Thread(unused => device(i, sender, e));
            t.IsBackground = true;
            t.Start();
            }
            catch (ThreadStateException f)
            {
                MessageBox.Show("ERROR:" + f);  // Display text of exception
            }
         }
      }

The thread function:

    //This infinite loop is useless, so it could be deleted. This is not
    // the loop I´m talking about
    public void device(object i, object s, object f)
    {
        while (true)
        {
            if (!killEm)
            {
                int j = (int)i;
                EventArgs g = (EventArgs)f;
                BSSDK.BS_SetDeviceID(m_ConnectedDeviceHandle[j],
                 m_ConnectedDeviceID[j], m_ConnectedDeviceType[j]);

                UserManagement userTest = new UserManagement();


                userTest.SetDevice(m_ConnectedDeviceHandle[j],
                    m_ConnectedDeviceID[j], m_ConnectedDeviceType[j]);
                userTest.ShowDialog();

            }
            else
            {
                userTest.Dispose();
                MessageBox.Show("Why don´t u kill it!!?");
                break;
            }
        }
    }

In the userTest.ShowDialog() function is the infinite loop I´m talking about

EDIT This is part of the function that is called in userTest.ShowDialog()

private void user_Click(object sender, EventArgs e) {

//THIS IS THE LOOP I´M TALKING!
while (true) {
    Keep listening for an user put his finger in the device
    ...
    Do things with that finger template
    ...   
}

}

Thank you.

Answer 1

Okay; Here's the good news: You don't need threads at all. What you basically have here is a regular Windows Forms component in the form of 'forms'. Those forms must be kept 'active', to respond to events. You don't need to create threads to do this, though.

The key is the System.Windows.Forms.Application static class, which has a function tailor-made for what you need here.

System.Windows.Forms.Application.Run();

This method lets your Form objects run on, responding to events, without letting the function it is called in continue. It 'blocks', letting the message pump respond, until Application.Exit() or some other similar methods are called.

What you want to do in your case is create all of your forms, and call Show() on each one in turn (not ShowDialog()), and then finally call Application.Run(). That gets you what you want.

In order to end your program, you need to have a call to Application.Exit() happen somewhere, in response to something. You have two options that would work quickly for you:

• Create a separate 'control form' that is just a plain Form that, when closed, calls Application.Exit(), perhaps after cycling through all your userManagement forms and closing them, first. You could do this with an event on the control form's Form.OnClosing event, for example.
• Add an event to each of the userManagement forms' Form.OnClosing events that checks for when the last one is closed (or perhaps if any of them is closed?) and, like above, call Application.Exit() there.

Once you call Application.Exit(), any open forms should be torn down (I recommend doing it manually, first...) and then your call in the main thread to Application.Run() will complete, allowing your program to continue... we presume, to end.

---

EDIT: Old answer, for posterity...

You are creating your new thread in the wrong place.

Don't create a new thread for the second window. Instead, create a new thread for the long-running task, and be sure to set it as a background thread, so it doesn't stay alive even when you close the windows.

Ideally, this loop should have a way to be cancelled gracefully, but you seem to suggest you can't touch that code...

Answer 2

You should avoid busy loops, why cannot you loop on some sleeping or pausing system call?

Answer 3

Besides the fact if this is a good idea or not, did you try BackgroundWorker?

http://msdn.microsoft.com/en-us/library/system.componentmodel.backgroundworker(v=VS.80).aspx

Answer 4

You can create a new thread http://msdn.microsoft.com/en-us/library/aa645740%28v=vs.71%29.aspx

or

Perhaps using a timer would be approperiate http://msdn.microsoft.com/en-us/library/system.timers.timer%28v=vs.71%29.aspx

Answer 5

This has nothing to do with threads - even if you call this "infinite loop function" from the main thread, it would still hang your program.

So, whoever authored this function, he/she mush have implemented some mechanism for stopping it, otherwise it would have been quite useless. Short of forcefully killing the thread (Thread.Abort), I suggest investigating this mechanism and employing it in your thread.

BTW, what is the purpose of this function? Some kind of message processing?

--- EDIT ---

OK, so your "infinite loop" is actually Form.ShowDialog. It internally contains a message pump and a way to stop that pump programmatically would be to set Form.DialogResult. Please note that you need to marshal all the UI calls to the proper threads, as indicated by this post.

Also, try running your from through Application.Run(Form), instead of Form.ShowDialog.