Delegate.BeginInvoke: How do you terminate the process without blocking?

Hi there Alex,

I'm looking into this thanks. What I can't readily see at the moment is how the caller of BeginInvoke can actually terminate the worker process. Say for example the worker process is manipulating hardware, it's not enough to return and ignore the process if the results are undesired - the activity has to stop punctually.

What I'm aiming for is how to abort the worker thread, and ideally be able to catch the ThreadAbortException in the worker thread.

Well, using ThreadAbortException is pretty simple, just use Thread.Abort and catch ThreadAbortException in the thread code. I don't like this solution, but it works.
Do you have some code to make this discussion more specific?

Sorry, not just at the moment, maybe later I can post something but in general the current situation without delegates is (simplified!):

class MyDevice
{

ProcessThread object runs the method Process()

public void ProcessAsync()
{
// starts the ProcessThread
}

public void CancelProcessAsync()
{
// aborts the ProcessThread
}

private void Process()
{

try
{
// do the work
// calls an event to return results
}
catch (ThreadAbortException threadAbortException)
{
// handle this condition
}

}

}//class MyDevice

With delegates, if I can still use Thread.Abort, I'm obviously accessing the worker thread - I cant see how I get to it from Delegate.BeginInvoke - it doesn't appear to return access to the worker thread. The older code that we have does actually work, but we have a mixture of styles for async calls and we want to homologate them.

I'm starting to wonder if its actually possible to do this using Delegate.BeginInvoke.

I can see that it could be done using some sort of state variable, but it means that the worker process would have to periodically check it, which I'm not too keen on, but perhaps it would be cleaner than Thread.Abort and catching the abort exception.

ie, an enum State with the values something like

Ready
Busy
AbortRequested


...whereby the CancelProcessAsync() method would set the state to AbortRequested.

Something urgent has come up work wise, so this is going on the back burner now for a while as far as the implementation goes, but I'm still interested to hear solutions other than the state based one I just mentioned (although I'm starting to prefer it to the abort - exception pattern already)...

The code you posted does not give much information. What is the problem if you call Delegate.BeginInvoke from the Process function?

Sorry, the class MyDevice would be used as such:

MyDevice device = new device();

device.ProcessAsync(); // runs the method Process() asynchronously. Results returned in an event. This method does not block.
.
.
// Some condition is detected whereby we need to halt the execution of the Process() function
// Therefore we call:
device.CancelProcessAsync();

mmm, we are also upgrading to .NET 2+ so that may well be an option - I have to read up on that as I'm pretty ignorant about it.
With the BackgroundWorker, can you handle the cancel condition so that you can clean up?

Just checked the documentation - its looking very promising... - similar to the pattern I was describing where I was going to check for the cancel signal, but cleaner.