using System;
using System.Threading;
using System.Threading.Tasks;
using System.Windows.Forms;

namespace WorkWithMultithreading
{
    public partial class MainForm : Form
    {
        private const int timeout = 5000;

        private bool isPaused = false;
        private bool isStopped = false;
        private SynchronizationContext synchronizationContext;
        private CancellationTokenSource cancelTokenSource;
        private Task workingTask;
        public MainForm()
        {
            InitializeComponent();
            synchronizationContext = SynchronizationContext.Current;
        }

        private void btStart_Click(object sender, System.EventArgs e)
        {
            if (workingTask?.IsCompleted??true)
            {
                cancelTokenSource = new CancellationTokenSource();
                isStopped = false;
                workingTask = Task.Run(async () =>
                {
                    while (!isStopped && !cancelTokenSource.IsCancellationRequested)
                    {
                        if (!isPaused)
                        {
                            DateTime dt;

                            synchronizationContext.Send((_) =>
                            {
                                dt = dtpInputDate.Value.Date.AddDays(1);
                                edtResult.Text = dt.ToString();
                            }, null);
                        }

                        await Task.Delay(timeout);
                    }
                }, cancelTokenSource.Token);
            }
        }

        private void btPause_Click(object sender, System.EventArgs e)
        {
            if (!isStopped)
            {
                isPaused = !isPaused;
                btPause.Text = isPaused ? "Continue" : "Pause";
            }
        }

        private void btStop_Click(object sender, System.EventArgs e)
        {
            isStopped = true;
            edtResult.Text = string.Empty;
            cancelTokenSource.Cancel();
        }

        private void MainForm_FormClosing(object sender, FormClosingEventArgs e)
        {
            isStopped = true;
            workingTask?.Wait();
        }
    }
}

N>        private bool isPaused = false;
N>        private bool isStopped = false;
N>

N>                            synchronizationContext.Send((_) =>
N>                            {
N>                                dt = dtpInputDate.Value.Date.AddDays(1);
N>                                edtResult.Text = dt.ToString();
N>                            }, null);
N>                        }

N>

//в гуёвом треде
uiScheduler = TaskScheduler.FromCurrentSynchronizationContext();
....
//внутри таски
task = Task.Factory.StartNew(.........CancellationToken, TaskCreationOptions, uiScheduler )
task.Wait()

                   .ContinueWith(task => {
                    if (task.Exception != null) {
                        AggregateException _exc = task.Exception.Flatten();
                        ShowError(_exc.InnerException);
            return;
                    }

           ....
            //тут твоя логика
                }, CancellationToken.None, TaskContinuationOptions.OnlyOnFaulted, GetUITaskScheduler());

        private volatile bool isPaused = false;
        private volatile bool isStopped = false;

private volatile bool isPaused = false;

N>>        private bool isPaused = false;
N>>        private bool isStopped = false;

_FR>Кажется, это не очень хороший совет человеку, который только начинает разбираться со всем этим

Ключевое слово volatile означает, что поле может изменить несколько потоков, выполняемых одновременно. Компилятор, среда выполнения или даже аппаратное обеспечение могут изменять порядок операций чтения и записи в расположения в памяти для повышения производительности. Поля, которые объявлены volatile, исключаются из некоторых типов оптимизации.

_FR>>Кажется, это не очень хороший совет человеку, который только начинает разбираться со всем этим

Ф>Ключевое слово volatile означает, что поле может изменить несколько потоков, выполняемых одновременно. Компилятор, среда выполнения или даже аппаратное обеспечение могут изменять порядок операций чтения и записи в расположения в памяти для повышения производительности. Поля, которые объявлены volatile, исключаются из некоторых типов оптимизации.

_FR>>Я перечитал ещё раз код в стартовом сообщении и не увидел, чтобы хоть одно из полей, объявление которых вы рекомендовали изменить подобным образом, менялось бы из разных потоков

Frankly, I discourage you from ever making a volatile field. Volatile fields are a sign that you are doing something downright crazy: you’re attempting to read and write the same value on two different threads without putting a lock in place. Locks guarantee that memory read or modified inside the lock is observed to be consistent, locks guarantee that only one thread accesses a given hunk of memory at a time, and so on. The number of situations in which a lock is too slow is very small, and the probability that you are going to get the code wrong because you don’t understand the exact memory model is very large. I don’t attempt to write any low-lock code except for the most trivial usages of Interlocked operations. I leave the usage of volatile to real experts.