How can stop thread worker , which is run background?

I using async and await in my project , now i want to stop worker thread, which is running background, How can i do it

I try with this below

private CancellationTokenSource cancellationToken;

private async void method1(int parameter) {
  //do something
}

private async Task method2(int parameter) {
  await Task.Run(() =>{
    method1(parameter);
    Task.Delay(1000).Wait();
  },
  cancellationToken.Token);
}

private async void bt_start_Click(object sender, EventArgs e) {
  cancellationToken = new CancellationTokenSource();
  await method2(123);
}

private async void bt_stop_Click(object sender, EventArgs e) {
  if (cancellationToken != null) {
    cancellationToken.Cancel();
  }
}

Something like this:

// Cancellation is a cooperative process in .net,
// So we should pass token...
private async Task method2(int parameter, CancellationToken token = default) {
  await Task.Run(async () => {
    //TODO: you may want to pass token to method1 as well
    method1(parameter);

    // ... and cancel using this token
    await Task.Delay(1000, token);
  });
}

Then

private CancellationTokenSource cancellationToken;

private async void bt_start_Click(object sender, EventArgs e) {
  // Note, that CancellationTokenSource is IDisposable and thus should be disposed
  try {
    using (cancellationToken = new CancellationTokenSource()) {
      await method2(123, cancellationToken.Token);
    }
  }
  catch (TaskCanceledException) {
    // method2 has been cancelled
  }
  finally {
    // We can't use disposed CancellationTokenSource; we should re-create it
    cancellationToken = null;
  }
}

// No await here, so async is not necessary 
private void bt_stop_Click(object sender, EventArgs e) {
  // Cancel if we can do it 
  if (cancellationToken != null) {
    cancellationToken.Cancel();
  }
}

.Net tasks and threads can't be stopped without their cooperation if they're already running.

Your code correctly creates the cancellation token and correctly gives it to the Task.Run method. If you call cancellationToken.Cancel() before the task can get scheduled and starts running, it will go straight to cancelled state without even starting execution.

But once the task starts executing, there is nothing in your code doing any subsequent cancellation checks. This means that if the task started executing, it will execute until it is done, without cancellation.

Most often, my own code doesn't really do that much, it only calls other long-running methods. Those methods usually accept a cancellationToken argument so all I need to do is give it to them. They will check the token and throw an OperationCanceledException if it gets canceled. In your case, you already call one of those methods, Task.Delay, so you just need to pass it a token.

Sometimes, my own code is doing the long-running work. In that case, you yourself must periodically call cancellationToken.ThrowIfCancellationRequested(), which will throw if the token got canceled and do nothing otherwise. How often you check for cancellation like this is up to you -- use your own judgement. Calling it once per tight loop which just adds some numbers is too often, calling it once every minute is probably not often enough.

Here's some modifications to your code as an example.

private CancellationTokenSource cancellationTokenSource;

// Always use async Task. async void is only for UI event handlers.
private async Task method1(int parameter, CancellationToken cancellationToken) {
  //do something

  //own code which is slow and could be improved by cancellation
  for (var i = 0; i < 100; i++) {
    //checking for cancellation in the outer loop
    cancellationToken.ThrowIfCancellationRequested();
    for (var j = 0; j < 10_000; j++) {
      //some tight inner loop code, not checking here
    }
  }

  for (var i = 0; i < 100; i++) {
    //when calling long-running library code, just passing on the token
    await someObject.SomeLongMethod(cancellationToken);
    await someObject.SomeOtherMethod(cancellationToken);
  }
}

// standard practice is to take cancellationToken as the last argument
private async Task method2(int parameter, CancellationToken cancellationToken) {
  await Task.Run(async () =>{
    // don't forget await!
    await method1(parameter, cancellationToken);
    await Task.Delay(1000, cancellationToken);
  },
  cancellationToken);
}

private async void bt_start_Click(object sender, EventArgs e) {
  // canceling old operation, if still running
  CancelAndClear();
  
  cancellationTokenSource = new CancellationTokenSource();
  await method2(123, cancellationTokenSource.Token);
  ClearCts();
}

// no need for async here
private void bt_stop_Click(object sender, EventArgs e) {
  CancelAndClear();
}

private void CancelAndClear() {
  if (cancellationTokenSource != null) {
    cancellationTokenSource.Cancel();
    ClearCts();
  }
}

private void ClearCts() {
  if (cancellationTokenSource != null) {
    // CTS must be disposed after it won't get canceled anymore
    cancellationTokenSource.Dispose();
    cancellationTokenSource = null;
  }
}