How can I improve this wrapper for Thread?
<p>Consider the following abstract class:</p>

<pre><code>public abstract class Worker {
    protected bool shutdown;
    protected Thread t;

    /// &lt;summary&gt;
    /// defines that we have an auto unpause scheduled
    /// &lt;/summary&gt;
    private bool _unpauseScheduled;

    /// &lt;summary&gt;
    /// when paused; schedule an automatic unpause when we
    /// reach this datetime
    /// &lt;/summary&gt;
    private DateTime pauseUntil;


    private bool _isStopped = true;
    public bool IsStopped {
        get {
            return t.ThreadState == ThreadState.Stopped;
        }
    }

    private bool _isPaused = false;
    public bool IsPaused {
        get {
            return _isPaused;
        }
    }

    private string stringRepresentation;

    public Worker() {  
        t = new Thread(ThreadFunction);
        stringRepresentation = "Thread id:" + t.ManagedThreadId;
        t.Name = stringRepresentation;
    }

    public Worker(string name) {   
        t = new Thread(ThreadFunction);
        stringRepresentation = name;
        t.Name = stringRepresentation;
    }


    public void Start() {
        OnBeforeThreadStart();
        t.Start();
    }

    public void ScheduleStop() {
        shutdown = true;
    }

    public void SchedulePause() {
        OnPauseRequest();
        _isPaused = true;
    }

    public void SchedulePause(int seconds) {
        _unpauseScheduled = true;
        pauseUntil = DateTime.Now.AddSeconds(seconds);
        SchedulePause();
    }

    public void Unpause() {
        _isPaused = false;
        _unpauseScheduled = false;            
    }

    public void ForceStop() {
        t.Abort();
    }


    /// &lt;summary&gt;
    /// The main thread loop.
    /// &lt;/summary&gt;
    private void ThreadFunction() {
        OnThreadStart();
        while (!shutdown) {
            OnBeforeLoop();
            if (!IsPaused) {
                if (!OnLoop()) {
                    break;
                }
            } else {
                // check for auto-unpause;
                if (_unpauseScheduled &amp;&amp; pauseUntil &lt; DateTime.Now) {
                    Unpause();
                }
            }
            OnAfterLoop();
            Thread.Sleep(1000);
        }
        OnShutdown();           
    }


    public abstract void OnBeforeThreadStart();
    public abstract void OnThreadStart();
    public abstract void OnBeforeLoop();
    public abstract bool OnLoop();
    public abstract void OnAfterLoop();
    public abstract void OnShutdown();
    public abstract void OnPauseRequest();


    public override string ToString() {
        return stringRepresentation;
    }
}  
</code></pre>

<p>I use this class to create Threads that are designed to run for the lifetime of the application, but also with the ability to pause and stop the threads as needed.</p>

<p>I can't help but shake the feeling that my implementation is naive though. My use of Thread.Sleep() gives me pause. I am still learning the ins and outs of threads, and I am looking to see what others might do instead.</p>

<p>The Worker derived objects need to be able to do the following:</p>

<ol>
<li>Run for the lifetime of the application (or as long as needed)</li>
<li>Be able to stop safely (finish what is was doing in OnLoop())</li>
<li>Be able to stop unsafely (disregard what is happening in OnLoop())</li>
<li>Be able to pause execution for a certain amount of time (or indefinitly)</li>
</ol>

<p>Now, my implementation works, but that is not good enough for me. I want to use good practice, and I could use some review of this to help me with that. </p>