Hey am

You could try communicating with the threads using a ManualRestEvent.
That way the threads could listen for your signal and then terminate
themselves.

Jan

The push away from Suspend and Abort are natural, as a thread suspending or
aborting can end creating a deadlock situation. My advice would be to learn
about Mutex and Monitor. When you use these classes, you can do what you
desire safely.

Thanks a lot to all!
Now I will post my solution. If you find something wrong tell me
please. Thanks a lot again.

class Engine
{

private ManualResetEvent mResetEvent = new ManualResetEvent( true );
private volatile bool mStopExecution;

protected bool StopExecution
{
    get { return mStopExecution; }
}

/// <summary>
/// Stops as soon as possible
/// </summary>
protected internal void Stop()
{
    mStopExecution = true;

    // restart thread in case it  was suspended before stop request
    Restart();
}

/// <summary>
/// Suspends thread
/// </summary>
protected internal void Suspend()
{
    // set the monitor to not segnaled if thread is not requested to stop
    if ( !StopExecution )
           mResetEvent.Reset();
}

/// <summary>
/// Restart suspended thread
/// </summary>
protected internal void Restart()
{
    // segnales monitor
    mResetEvent.Set();
}

/// <summary>
///  This is the function used as argument of new ThreadStart() in the
constractor of
/// new Thread
/// </summary>
protected internal void Start( )
{
    try
    {
        ExecControl();
    }
    catch ( Exception ecc )
    {
        mExitStatus = ExitStatusType.Errors;
        mError = ecc;
    }
    finally
    {
        Done();
    }
}

/// <summary>
/// Looks for suspend or stop requests.
/// </summary>
protected bool VerifySuspendStop()
{
    bool continueExecution = true;

    TimeSpan timeout = new TimeSpan( 3, 0, 0 );

    if ( !mResetEvent.WaitOne( timeout, false ) )
    {
        mResults = "Timeout occured.";
        continueExecution = false;
        mExitStatus = ExitStatusType.TimeoutSuspend;
    }
    else if ( StopExecution )
    {
        mResults = "Thread stopped by user";
        continueExecution = false;
        mExitStatus = ExitStatusType.Stopped;
    }

        return continueExecution;
}

/// <summary>
/// Here I do what I want.
/// </summary>
protected void ExecControl()
{
    while( VerifySuspendStop )
    {
        // quick code

        if ( !VerifySuspendStop )
        {
            return;
        }

        // time consuming code

        if ( !VerifySuspendStop )
        {
            return;
        }

        // time consuming code
    }
}

}

class ClassThatUsesEngine
{
    public ClassThatUsesEngine()
    {
        Engine engine = new Engine();

        Thread thread = new Thread( new ThreadStart( engine.Start ) );

        thread.Start();
   
        thread.Join();
    }
}