Hi Susan,

(sorry about the bad spelling... its late, and I am not a native
english speaker ;) )

Fact of the matter is this: You are now doing multithreaded
programming. The best way to go about it is to embrace the fact and now
be aware of the issues inherent in the paradigm.

what you should do (for some undefined value of "should") is keep 2
booleans around that keeps track of whether the async process should
stop or not, and whether it is running or not.

These 2 bools should both be locked in the standard way. Here I will
show you how:

private readonly object mSomeBooleanLock = new object();
private bool mLockedSomeBool = false; // some sane default value here

private bool SomeBoolValue()
{
  bool result;
  lock(mSomeBooleanLock)
  {
     result = mLockedSomeBool;
  }
  return result;
}

private void SetSomeBoolValue(bool pNewValue)
{
  lock(mSomeBooleanLock)
  {
     mLockedSomeBool = pNewValue;
  }
}

btw - put all of this in a new class that will "host" your background
process. Then make a new instance for every new search.

Now: In this class, have methods StartBackgroundJob() and EndJob().

Startjob should look something like this:
private void StartBackgroundActual(object[] pParams)
{
  SetMustStop(false);
  SetIsRunning(true);

  bool workIsFinished = false;

  while(!MustStop() || workIsFinished)
  {
     // do some quantum of work here
     // use the pParams here to tune your search
     // sowe workIsFinished = true sometime
  }

  if(workIsFinished)
  {
     // provide feedback with the results in some way
     // remember this will call on a thread different from your main
ui thread
     // handle with care
  }

  SetIsRunning(false);
}

delegate void VoidMethod();
public void StartBackgroundJob(object[] pParams)
{
  VoidMethod asyncCall = delegate()
  {
     StartBackgroundActual(pParams);
  };
  asyncCall.BeginInvoke(
     1,
     delegate(IAsyncResult pAsyncResult)
     {
        asyncCall.EndInvoke(pAsyncResult);
     },
     null);
}

public void Endjob(bool pMustBlock)
{
  SetMustStop(true);
  if (pMustBlock)
  {
     while(IsRunning())
     {
        Thread.Sleep(350); // some random value... don't set it to
some power of 2. cannot remember why exactly anymore
     }
  }
}

Everytime that your user changes his search parameters, set the old
background job (of which you kept a handle around) to stop. Then
instantiate a new instance, set it to start running with the new
parameters received from the user.

I would seriously suggest that you read this piece:
http://www.yoda.arachsys.com/csharp/threads/index.shtml

It is the canonical work on multi-threading (free and available online)

The other piece of advice that helped me when i learned to thread was
this: investigate anonymous methods with the aim of using them for
closures. The technique helps THIIIIIIIIIIS much when you are coding to
different threads.

Regards,
Pieter

Hi Susan,
I see what you're asking now... I was thrown off when you said you were
starting a 'process' asynchronously.  :)

I agree with what the others have posted -- have the long-running
operation periodically check to see if it should stop.  This can done
by a shared boolean flag, signalling an event, etc...

John

It's no easier using a Thread of your own than doing work in a method
invoked by an async delegate. The reason it's no easier - you DON'T want to
use Thread.Abort() to kill your worker thread.  Rather, in either case (your
thread or async delegate), you need to send a "message" to your long-running
operation requesting that it stop.  That "message" is typically just a
shared bool variable (as the excellent response by Pieter Breed outlines),
but it could also be a window message, a post to a Win32 Event or Semaphore,
or whatever is appropriate for the task at hand.  Your long-running
operation then cooperatively stops when it's asked to, and sends a "message"
back to the requestor acknowledging the stop request.

-cd