我如何继承 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

EventWaitHandle 类有一个 Set 和 Reset 方法，因此您可以从该方法继承而不是 WaitHandle。

但是，对于提供的示例，我认为这不是一个好的实现，因为 SafeWaitableQueue 类现在有两个不同的角色：队列和等待句柄。

但是，如果您有其他想法需要实现自己的等待句柄，我建议您尝试从 EventWaitHandle 继承。

这不是一个很好的解决方案，因为 Set 和 Reset 方法是公开的，这意味着 SafeWaitableQueue 类的使用者也可以调用 Set 和 Reset，这可能会导致一些明显的un安全行为。

Answer 3

我会创建一个聚合 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 4

我认为这不是很好地使用继承。你的对象是一个队列并且使用一个等待句柄来提供线程安全，所以你不应该从WaitHandle派生。