How can I subclass WaitHandle?

Question

Is it possible (in a meaningful way) ?

For example, say I'd like to implement a waitable queue as follows:

public class WaitableQueue : WaitHandle {
    public WaitableQueue() {
      q = new Queue();
    }

    public void Enqueue(Object Arg) {
      lock(this) {
        q.Enqueue(Arg);
        // set the waithandle here (how?)
      }
    }

    public Type Dequeue() {
      lock(this) {
        if(q.Count == 1)
        // reset the waithandle here (how?)
        return q.Dequeue();
      }
    }

    Queue q;
  }

Answer 1

The important thing to remember is that you must set the SafeWaitHandle property.

From MSDN:

When you derive from WaitHandle, use the SafeWaitHandle property to store your native handle operating system handle. You do not need to override the protected Dispose method unless you use additional unmanaged resources.

Here is how I would do this.

public class QueueWaitHandle<T> : WaitHandle
{
    private Queue<T> queue = new Queue<T>();
    private ManualResetEvent signal = new ManualResetEvent(false);

    public QueueWaitHandle()
    {
        base.SafeWaitHandle = signal.SafeWaitHandle;
    }

    public void Enqueue(T item)
    {
        lock (queue)
        {
            queue.Enqueue(item);
            signal.Set();
        }
    }

    public T Dequeue()
    {
        lock (queue)
        {
            T item = queue.Dequeue();
            if (queue.Count == 0)
            {
                signal.Reset();
            }
            return item;
        }
    }
}

When done this way Enqueue acts like the Set method and Dequeue acts like the Reset method. So basically this works like a counting event where non-zero is signaled and zero is unsignaled. The queue is doing the counting in this case and it just happens to also hold data.

I know you were asking about subclassing WaitHandle in general, but this specific data structure is more than just an exercise. It can be useful in some scenarios. I would not, however, call it a waitable queue because that implies, at least to me anyway, that the Dequeue operation will block when the queue is empty. Clearly that is not what will happen in this particular implemenation.

Answer 2

The EventWaitHandle class has a Set and Reset method, so you could inherit from that instead of WaitHandle.

However, I would say that for the example provided, I don't think this would be a good implementation, because the SafeWaitableQueue class now has two different roles: a queue and a wait handle.

But, if you have something else in mind where you need to implement your own kind of wait handle, I'd suggest trying to inherit from EventWaitHandle.

It's not a great solution, because the Set and Reset methods are publicly exposed, meaning that consumers of your SafeWaitableQueue class could also call Set and Reset, probably resulting in some decidedly unsafe behavior.

Answer 3

I'd create a class which aggregates both Queue AND WaitHandle, so:

public class WaitableQueue<T>
{
    private Queue<T> _queue;
    private WaitHandle _waitHandle;

    public WaitableQueue()
    {
        _queue = new Queue<T>();
        _waitHandle = new WaitHandle();
    }

    public void Enqueue(T Arg) {
      lock(this) {
        _queue.Enqueue(Arg);
        _waitHandle.Set();
      }
    }
    ...
}

Answer 4

I think that is not a good use of inheritance. Your object is a queue and uses a wait handle to provide thread safety, so you shouldn't be derived from WaitHandle.