如何实现WaitHandle的子类化？

Question

这是可能的(以有意义的方式)吗？

例如，假设我想实现一个可等待队列，如下所示：

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

需要记住的重要一点是，必须设置SafeWaitHandle属性。

来自MSDN：

从WaitHandle派生时，使用SafeWaitHandle属性存储本机句柄操作系统句柄。除非使用其他非托管资源，否则不需要重写受保护的Dispose方法。

这就是我要做的事情。

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;
        }
    }
}

采用这种方式时，Enqueue的行为类似于Set方法，而Dequeue的行为类似于Reset方法。因此，基本上这就像一个计数事件，其中非零被通知，而零被取消通知。在这种情况下，队列正在进行计数，它只是碰巧也保存了数据。

我知道您问的是关于WaitHandle子类化的一般问题，但是这个特定的数据结构不仅仅是一个练习。在某些情况下，它可能会很有用。但是，我不会将其称为可等待队列，因为这意味着，至少对我而言，当队列为空时，Dequeue操作将阻塞。显然，在这个特定的实现中不会发生这种情况。

Answer 2

我会创建一个聚合了Queue和WaitHandle的类，所以：

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 3

我认为这不是继承的好用法。您的对象是一个队列，它使用等待句柄来提供线程安全性，因此您不应该从WaitHandle派生。