How to start a loop upon button click, then stop it upon same button click again

Toggle Loops: Start and Stop C# Loops with a Single Button Click

Learn how to implement a C# loop that starts when a button is clicked and stops when the same button is clicked again, providing a clean toggle mechanism for background processes.

In many interactive applications, you'll encounter scenarios where a user action, such as clicking a button, needs to initiate a continuous process. Equally important is the ability to halt that process using the same control. This article will guide you through creating a C# application (applicable to WinForms, WPF, or console applications with minor adaptations) where a single button acts as a toggle to start and stop a loop.

Understanding the Core Concept: State Management

The fundamental challenge in toggling a loop with a single button is managing the 'state' of the loop. The button needs to know whether the loop is currently running or stopped to determine its next action. We'll achieve this using a boolean flag. When the button is clicked, we'll check this flag: if the loop is stopped, we start it and set the flag to 'running'; if it's running, we signal it to stop and set the flag to 'stopped'.

flowchart TD
    A[User Clicks Button] --> B{Is Loop Running?}
    B -- No --> C[Set `isRunning` = true]
    C --> D[Start Loop in New Thread]
    D --> E[Update Button Text to "Stop"]
    B -- Yes --> F[Set `isRunning` = false]
    F --> G[Wait for Loop to Finish]
    G --> H[Update Button Text to "Start"]

Flowchart of the button click logic for toggling a loop

Implementing the Toggle Logic

To prevent the UI from freezing, any long-running loop should execute on a separate thread or as an asynchronous task. This ensures your application remains responsive while the loop is active. We'll use a CancellationTokenSource for a robust way to signal the loop to stop gracefully.

using System;
using System.Threading;
using System.Threading.Tasks;
using System.Windows.Forms; // Example for WinForms

public partial class MainForm : Form
{
    private CancellationTokenSource _cts;
    private bool _isLoopRunning = false;

    public MainForm()
    {
        InitializeComponent(); // Assuming a button named 'toggleButton'
        toggleButton.Text = "Start Loop";
    }

    private async void toggleButton_Click(object sender, EventArgs e)
    {
        if (!_isLoopRunning)
        {
            // Start the loop
            _cts = new CancellationTokenSource();
            _isLoopRunning = true;
            toggleButton.Text = "Stop Loop";
            toggleButton.Enabled = false; // Disable button while starting

            try
            {
                await Task.Run(() => RunMyLoop(_cts.Token));
            }
            catch (OperationCanceledException)
            {
                // Loop was cancelled, expected behavior
            }
            finally
            {
                _isLoopRunning = false;
                toggleButton.Text = "Start Loop";
                toggleButton.Enabled = true; // Re-enable button
                _cts.Dispose(); // Clean up the CancellationTokenSource
                _cts = null;
                MessageBox.Show("Loop has stopped.");
            }
        }
        else
        {
            // Stop the loop
            if (_cts != null)
            {
                _cts.Cancel();
                toggleButton.Enabled = false; // Disable button while stopping
            }
        }
    }

    private void RunMyLoop(CancellationToken cancellationToken)
    {
        int counter = 0;
        while (!cancellationToken.IsCancellationRequested)
        {
            // Simulate work
            Thread.Sleep(500); 
            counter++;
            // Update UI (if needed, use Invoke/BeginInvoke for WinForms/WPF)
            // For example: Invoke((MethodInvoker)delegate { labelStatus.Text = $"Running: {counter}"; });
            Console.WriteLine($"Loop iteration: {counter}");
        }
        Console.WriteLine("Loop received cancellation request and is stopping.");
    }

    // Optional: Handle form closing to ensure loop is stopped
    protected override void OnFormClosing(FormClosingEventArgs e)
    {
        if (_isLoopRunning && _cts != null)
        {
            _cts.Cancel();
            // Optionally wait for the task to complete before closing
            // e.Cancel = true; // Prevent immediate close if waiting
        }
        base.OnFormClosing(e);
    }
}

C# code for a WinForms application demonstrating loop toggling.

Key Components Explained

Let's break down the essential parts of the solution:

• _isLoopRunning (boolean flag): This variable tracks the current state of the loop. It's crucial for the button to decide whether to start or stop.
• CancellationTokenSource (_cts): This object is the standard way to signal cancellation to asynchronous operations and tasks in .NET. When _cts.Cancel() is called, the cancellationToken.IsCancellationRequested property inside the loop becomes true, allowing the loop to exit gracefully.
• Task.Run(() => RunMyLoop(_cts.Token)): This executes the RunMyLoop method on a separate thread from the UI thread. The await keyword ensures that the toggleButton_Click method pauses until RunMyLoop completes (either naturally or due to cancellation), preventing UI blocking.
• try-catch (OperationCanceledException): When _cts.Cancel() is called, Task.Run will often throw an OperationCanceledException. Catching this exception allows for clean handling of the cancellation.
• Button State Management: Disabling the button (toggleButton.Enabled = false;) while the loop is starting or stopping prevents multiple rapid clicks that could lead to unexpected behavior or race conditions.

Graceful Shutdown and Resource Management

It's important to ensure that your loop stops cleanly and releases any resources. The CancellationTokenSource is a disposable object, so it should be disposed of when no longer needed (e.g., in the finally block or when the application closes). The OnFormClosing override provides an opportunity to cancel the loop if the user tries to close the application while the loop is still running.

By following this pattern, you can create robust and responsive applications that allow users to easily control background processes with a simple toggle button.