Question

I am using Visual C# sand I’m using a Windows Form rather than a console application. Therefore I’m not working in Main (), but rather in the Form File. I’m also very new to C# so sorry if some of my questions are stupid.

What I basically need to do is when my program starts up I need it to keep looping forever. Where would I put this code since I don’t have a Main ()? Do I put it in the function that has InitializeComponent() in it? I need the loop to start right after the program starts. However, I have some variables that I need declared first before the loop. So basically I need the variables to be declared and then the infinite loop to start. The variables are global.

Secondly, I need the infinite loop to break when the user presses a button. How would I do this? I was thinking something among the lines of:

while (buttonIsPressed == false)
{
   //do whatever I need to do
}

However, I realized the button’s function will never be called since I am stuck in that loop. I can’t set the variable from the button’s function if I never reach the button’s function due to being in an infinite loop. Any ideas? I was thinking about threads but I have absolutely no experience with threads so am a bit reluctant to try it out.

---

Additional, from comments:

A chat application. When the program starts I need it to keep
listening. However, when the user clicks "connect" it stops listening
and instead initiates a connection

I am creating a chat client. So basically when my program starts up, I
need it to keep listening. However, when the user clicks "connect" it
needs to stop listening and instead initiate a connection

Answer 1

That’s a natural question for someone who’s coming from a (completely) different background.

Programming Windows Forms applications is event driven. When a Windows Forms application starts, a form is loaded (check Program.cs file) and there is a Main loop that is hidden from you to concentrate on the important things in your program.

You don’t need to put anything in the Main loop to respond to an event (like a button clicked event). You just handle the button clicked event by creating an event handler for the Click event of the Button). You can use the designer or do that manually in the code.

When you create a method to handle an event (and as such the method is called an event handler) it is called automatically when the event is raised/triggered. For example a method handler for the Click event for the Button on your form would be called when the user clicked the button.

This MSDN topic contains all the information you need: Creating Event Handlers in Windows Forms. If you need more clarification, please ask! 🙂

UPDATE: Create an event handler just like above and also create a loop in the Form_Loaded event handler. Be sure to call Application.DoEvents(); inside the loop. This way the event handler for the button click can be handled (in the handler add code to modify a boolean that would make the loop’s condition false to cancel the loop).

UPDATE 2:
To make this answer more complete, I mention that you should also consider running the loop on a new thread, not the UI one (and therefore avoid needing to use DoEvents, which has its negatives as my peers pointed out). The following example shows how to create a Thread and cancel it on a Button Click:

    System.Threading.Thread t;
    private void Form1_Load(object sender, EventArgs e)
    {
        //create and start a new thread in the load event.
        //passing it a method to be run on the new thread.
        t = new System.Threading.Thread(DoThisAllTheTime);
        t.Start();
    }

    public void DoThisAllTheTime()
    {
        while (true)
        {
            //you need to use Invoke because the new thread can't access the UI elements directly
            MethodInvoker mi = delegate() { this.Text = DateTime.Now.ToString(); };
            this.Invoke(mi);
        }
    }

    private void button1_Click(object sender, EventArgs e)
    {
        //stop the thread.
        t.Suspend();
    } 

Finally, consider using a BackgroundWorker which encapsulates creating and managing Threads for you.