What is the proper method for cleaning up EventWaitHandle?

Question

Hi all,
I'm working on inter-process communication between applications running on the same machine. More specifically I have a primary application that is connected to multiple industrial machines collecting data from each.
I want to create secondary applications that consume this data. I intend on using MemoryMappedFile to share the information. I've tested the MMF part and it works fine.
I'm at the point where I want to notify the client applications when new data is available by using an EventWaitHandle. I create the handle as follows.
handle = new EventWaitHandle(false, EventResetMode.AutoReset, ClientName);
In the client application I use WaitOne inside a thread for the event notification. This too works well.
private void MonitorForSignal()
running = true;
bool signaled;
while (running)
signaled = handle.WaitOne();
if (signaled)
if (!handle.SafeWaitHandle.IsClosed)
//Do something
I create the thread as follows:
monitor = new Thread(MonitorForSignal);
monitor.IsBackground = true;
running = true;
monitor.Start();
My concern is that I may be creating an orphaned thread or a memory leak when I close the client application. So I implemented IDisposable in my client class and do the following.
protected virtual void Dispose(bool disposing)
if (disposing)
// free managed resources
// free native resources here if there are any
running = false;
handle.Close();
handle.Dispose();
monitor.Abort();
I believe this does indeed free the resources, but I've read that Thread.Abort is "bad". Before I implemented IDisposable I did some testing in a couple of WinForm applications, one acting as the host and one as the client. I noticed that I could
close the client and subsequently Set the EventWaitHandle in the host application and this line of code in the client would fire in the debugger.
signaled = handle.WaitOne();
This made me worry that I wasn't properly cleaning up my thread objects.
Below is the entire client for reference. What I'm really asking is how do I properly clean up the MonitorForSignal thread and the EventWaitHandle in the client?
public class ClientA : IDisposable
bool running;
string clientName;
EventWaitHandle handle;
Thread monitor;
private void MonitorForSignal()
running = true;
bool signaled;
while (running)
signaled = handle.WaitOne();
if (signaled)
if (!handle.SafeWaitHandle.IsClosed)
//Do something
private void ProcessData()
//Do Something
public ClientA(string ClientName)
if (ClientName == null || ClientName == string.Empty)
throw new ArgumentException("Cannot be null or empty.", "ClientName");
clientName = ClientName;
handle = new EventWaitHandle(false, EventResetMode.AutoReset, ClientName);
monitor = new Thread(MonitorForSignal);
monitor.IsBackground = true;
running = true;
monitor.Start();
#region IDispose
~ClientA()
Dispose(false);
public void Dispose()
Dispose(true);
GC.SuppressFinalize(this);
protected virtual void Dispose(bool disposing)
if (disposing)
// free managed resources
// free native resources here if there are any
running = false;
handle.Close();
handle.Dispose();
monitor.Abort();
#endregion
Regards,

Answer 1

Hi Michael,
Does this code cause the thread to spin?
while (!handle.WaitOne())
//TODO: Do work
Thread.Sleep(1000);
I was hoping not to spin thus the EventWaitHandle. As for the named handle, I am building multiple applications that need to have inter-process communication, all running on the same machine.
I think I can update my class to use your recommendation for the dispose method, specifically using handle.Set
However, I would update the MonitorForSignal as follows:
bool _closing = false;
private void MonitorForSignal()
running = true;
bool signaled;
while (running)
signaled = handle.WaitOne();
if (signaled && !_closing )
if (!handle.SafeWaitHandle.IsClosed)
if (NewData != null)
NewData();
And the dispose as follows:
protected virtual void Dispose(bool disposing)
if (disposing && handle!=null)
running = false;
_closing = true;
handle.Set();
if (!monitor.Join(5000))
monitor.Abort();
monitor = null;
handle.Dispose();
handle = null;
// free managed resources
// free native resources here if there are any
This allows me to skip over the "Do Work" part which should only be done when Signaled from another application. Your suggestion to use handle.Set() in the dispose method coupled with adding the bool _closing allows me to get past the EventWaitHandle
and also skip the work when closing.
Also by setting "running" to false in the dispose, the thread will naturally end after the wait handle has been set.
Thanks for suggesting the Thread.Join, that does seem allot more graceful. When I tested these changes it was blazing fast. In the previous code when I called monitor.Abort the application would hang for about a second. 
Do you think the changes capture the intent of your suggestions?
Regards,