What's the difference between the first method that runs Task.Run and the one which doesn't run Task.Run?

The listenForClients1 method doesn't block the main thread but the listenForClients2 does. Why is there a difference here? Both tasks seems to be executing but the second doesn't begin working on a new thread.

I want the task to run on a different thread but I'm very confused to why I need to call the Task.Run and what that specific static method does differently that makes the task perform on a different thread?

            if(temp.Name == "buttonStart" && int.TryParse(textBoxPort.Text, out port)) //Startar servern...
            {
                #region Btn appearance:

                temp.Enabled = false;
                buttonStop.Enabled = true;
                buttonStart.BackColor = Color.FromArgb(108, 156, 67);
                buttonStop.BackColor = Color.FromArgb(212, 101, 78);

                #endregion

                listeningTokenSource = new CancellationTokenSource();
                var token = listeningTokenSource.Token;

                listenForClients1(token);

                Invoke(() => { richTextBoxLog.Text += "Testing"; });
            }
            else if(temp.Name == "buttonStop") //Stoppar servern...
            {
                #region Btn appearance:

                temp.Enabled = false;
                buttonStart.Enabled = true;
                buttonStart.BackColor = Color.FromArgb(145, 207, 91);
                buttonStop.BackColor = Color.FromArgb(156, 76, 59);

                #endregion

                listeningTokenSource.Cancel(); //Stoppar processen.
            }
        }

        private async Task listenForClients1(CancellationToken token)
        {
            Task.Run(() =>
            {
                while (!token.IsCancellationRequested)
                {
                    Thread.Sleep(1000);
                    Invoke(() => { richTextBoxLog.Text += "b"; });
                }
                Invoke(() => { richTextBoxLog.Text += "Done"; });
            });
        }

        private async Task listenForClients2(CancellationToken token)
        {
            while (!token.IsCancellationRequested)
            {
                Thread.Sleep(1000);
                Invoke(() => { richTextBoxLog.Text += "b"; });
            }
            Invoke(() => { richTextBoxLog.Text += "Done"; });
        }

Thank you for any answers! Best regards, Lukas.

I tried different methods and expected them both to not block the main thread.

The first one hands off the code to a threadpool thread and will not block. The second function has no handling whatsoever for asynchonicity, so it will block. Invoke was not necessary in the second function, and it's unclear why you needed it.

But neither of these options are correct. What you should do is use await Task.Delay instead, rather than making a blocking Thread.Sleep call.

You also need to call the function using await, otherwise dragons may jump out your screen.

private async Task listenForClients3(CancellationToken token)
{
    try
    {
        while (!token.IsCancellationRequested)
        {
            await Task.Delay(1000, token);
            richTextBoxLog.Text += "b";
        }
    }
    catch (OperationCanceledException)
    { //
    }
    richTextBoxLog.Text += "Done";
}

await listenForClients3(someToken);

Note that there is a slight difference in logic here: because we passed the token to Task.Delay we may get cancelled in the middle of it, whereas the original code will not break out until the end of the timer. To avoid that behaviour you can do await Task.Delay(1000);