Могу ли я создать поток, который может изменять пользовательский интерфейс и который я могу прервать?

Во-первых - не отключайте проверки между потоками ... формы имеют сходство потоков ...

Во-вторых, старайтесь не прерывать потоки; это нехорошо - вы должны предпочесть чистое завершение работы (например, отмену, которую поддерживает BackgroundWorker)

Один из вариантов - написать метод-оболочку, который:

• принимает типизированный делегат (так что вы можете называть его проще)
• выполняет необходимую проверку (генерирует исключение для завершения и развертывания)

Например:

    void worker_DoWork(object sender, DoWorkEventArgs e)
    {
        try {
          Action<Action> update = thingToDo =>
          {
              if (worker.CancellationPending) throw new SomeException();
              this.Invoke(thingToDo);
          };

          //...
          string tmp = "abc"; // long running
          update(() => this.Text = tmp);

          tmp = "def"; // long running
          update(() => textbox1.Text = tmp);
        } catch (SomeException) {
          e.Cancel = true;
        }
    }

Это все еще немного беспорядочно, но, возможно, чище, чем прерывание потоков слева и справа ...

Вы можете избежать использования Invoke, используя объект SynchronizationContext, который был введен во фреймворке 2. Хорошо, это то же самое, вы заменяете одно на другое, но на самом деле это более эффективно и надежно. В любом случае, кросс-потокам нужны проверки, потому что без этого вы никогда не сможете получить доступ к элементу управления, созданному в другом потоке.

Об этом читайте в: http://www.codeproject.com/KB/cpp/SyncContextTutorial.aspxhttp://codingly.com/2008/08/04/invokerequired-invoke-synchronizationcontext/

Какой-то код, раскрывающий мою идею:

   private Thread workerThread;

        private AsyncOperation operation;

        public event EventHandler SomethingHappened;

        public MySynchronizedClass()
        {
            operation = AsyncOperationManager.CreateOperation(null);

            workerThread = new Thread(new ThreadStart(DoWork));

            workerThread.Start();
        }

        private void DoWork()
        {
            operation.Post(new SendOrPostCallback(delegate(object state)
            {
                EventHandler handler = SomethingHappened;

                if (handler != null)
                {
                    handler(this, EventArgs.Empty);
                }
            }), null);

            operation.OperationCompleted();
        }

Я отвечаю вам здесь, потому что комментарии слишком короткие. Я лично использую BackgroundWorker, и когда метод завершается, поток освобождается. В основном то, что вы делаете:

bw = new BackgroundWorkerExtended();
bw.DoWork += (DoWorkEventHandler)work;
bw.WorkerSupportsCancellation = true;
//bw.WorkerReportsProgress = true;
bw.RunWorkerCompleted += (RunWorkerCompletedEventHandler)workCompleted;
//bw.ProgressChanged+=new ProgressChangedEventHandler(bw_ProgressChanged);
bw.RunWorkerAsync();

Другое дело, если вы используете Post, он будет асинхронным, если вы используете Send, он будет синхронным.

Отменить: bw.CancelAsync ();

В дополнение к предложению BackgroundWorker и связанному с ним комментарию BackgroundWorker выполняет маршалинг обратного вызова OnProgress обратно в поток пользовательского интерфейса, поэтому вы МОЖЕТЕ обновлять данные оттуда без необходимости выполнять Invoke ().

Я не могу точно сказать, полезно это или нет, и в любом случае это метод, который вы могли бы довольно легко использовать без фонового рабочего.

Я подозреваю, что если фоновой задаче нужно знать так много о форме, которую она выполняет bazillion вызовы, тогда у вас может возникнуть проблема разделения задач, о которой в любом случае стоит подумать.