Threads and an objects lifetime

[Kep]

Hi all,

I have a problem with a class I've wrote. Basically the class opens a windows resource and runs a thread that handles events of that resource by calling methods on the object.

The problem I have is that although the object can be explicitly closed to free the resources and end the thread, I've included code in the destructor for this purpose just in case the user forgets (a sort of failsafe). Unfortunately the thread keeps the object alive.

Has anyone else had this problem and is there a way round it?

Basic code sample:

public class MyClass : IDisposable
{
    private Thread eventThread;
    // thread routine
    private void EventHandler()
    {
        try
        {
            while(true)
            {
                // check for events
                WhenSomething();

                // **** this loop keeps the object alive ****
            }
        }
        catch(ThreadAbortException)
        {
            // do nothing (exit normally)
        }
        catch
        {
            // expose exception to main thread
        }
    }
    private void Start()
    {
        eventThread = new Thread(new ThreadStart(EventHandler));
        eventThread.Priority = ThreadPriority.AboveNormal;
        eventThread.Start();
    }
    ~MyClass()
    {
        // just in-case IDisposable.Dispose() is not called
        Dispose(true);
    }
    protected void Dispose(bool fromDestructor)
    {
        // free unmanaged resources
        if(eventThread != null)
        {
            // abort the event thread
            eventThread.Abort();
            eventThread.Join();
            eventThread = null;
        }
    }
    protected void WhenSomething()
    {
        // call event handler if there is one
    }
    public static MyClass Open()
    {
        MyClass result = new MyClass();
        result.Start();
        return result;
    }
    public void Dispose()
    {
        Dispose(false);
        Gc.SuppressFinalize(this);
    }
}
// IN ANOTHER FILE
public class TestMyClass
{
    public static void Main(string[] args)
    {
        MyClass test = Open();

        // run some tests

        // **** when this method ends I thought the 'test' object
        // would go out of scope and be destroyed but the thread
        // keeps it alive ****
    }
}

Thanks, I hope it's not too long winded.
Kep.

[janeprime2001]

Hi,
Just make sure that the condition changes to false otherwise your loop (in EventHandler) will keep on creating the object. Because I can't see where you change it to false. Hope this helps

while(true)
{
   // check for events
      WhenSomething();

  // **** this loop keeps the object alive ****
}

Jan

dude_in_africa

[Kep]

Thanks for the response.

I terminate the Thread by calling

Thread.Abort()

from the class destructor. I thought this would throw a ThreadAbortException in the thread method. But the class destructor does not get called.

I've also tried messing around with

Thread.IsBackground = true

to try and get the application to terminate but this doesn't seem to work either.

[Kep]

I've just worked it out.

You need to set the thread to a background thread with

MyThread.IsBackground = true

and make sure that the ThreadStart delegate is non-static.

private void EventHandler()
{
    while(true)
    {
        // do some work!
    }
}