可观察的堆栈和队列

Question

我正在寻找 Stack 和 Queue 的 INotifyCollectionChanged 实现。我可以自己动手，但我不想重新发明轮子。

Answer 1

我遇到了同样的问题，想与其他人分享我的解决方案。希望这对某人有帮助。

public class ObservableStack<T> : Stack<T>, INotifyCollectionChanged, INotifyPropertyChanged
{
    public ObservableStack()
    {
    }

    public ObservableStack(IEnumerable<T> collection)
    {
        foreach (var item in collection)
            base.Push(item);
    }

    public ObservableStack(List<T> list)
    {
        foreach (var item in list)
            base.Push(item);
    }


    public new virtual void Clear()
    {
        base.Clear();
        this.OnCollectionChanged(new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Reset));
    }

    public new virtual T Pop()
    {
        var item = base.Pop();
        this.OnCollectionChanged(new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Remove, item));
        return item;
    }

    public new virtual void Push(T item)
    {
        base.Push(item);
        this.OnCollectionChanged(new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Add, item));
    }


    public virtual event NotifyCollectionChangedEventHandler CollectionChanged;


    protected virtual void OnCollectionChanged(NotifyCollectionChangedEventArgs e)
    {
        this.RaiseCollectionChanged(e);
    }

    protected virtual void OnPropertyChanged(PropertyChangedEventArgs e)
    {
        this.RaisePropertyChanged(e);
    }


    protected virtual event PropertyChangedEventHandler PropertyChanged;


    private void RaiseCollectionChanged(NotifyCollectionChangedEventArgs e)
    {
        if (this.CollectionChanged != null)
            this.CollectionChanged(this, e);
    }

    private void RaisePropertyChanged(PropertyChangedEventArgs e)
    {
        if (this.PropertyChanged != null)
            this.PropertyChanged(this, e);
    }


    event PropertyChangedEventHandler INotifyPropertyChanged.PropertyChanged
    {
        add { this.PropertyChanged += value; }
        remove { this.PropertyChanged -= value; }
    }
}

Answer 2

使用堆栈和队列（几乎根据定义），您只能访问堆栈顶部或队列头部。这就是它们与 List 的区别。 （所以，这就是为什么你还没有找到一个）

要回答，尽管你可以编写自己的，我会通过从 ObservableCollection 派生来完成，然后在实现 的堆栈的情况下Push 作为 Insert 在偏移量 0 处（并弹出作为返回索引 0，然后返回 RemoveAt 索引 0）；或者使用队列，您可以将Add添加到列表末尾以Enqueue，然后抓取并删除第一个项目，就像堆栈一样，用于Dequeue。将在基础 ObservableCollection 上调用 Insert、Add 和 RemoveAt 操作，从而导致 CollectionChanged 事件被触发。

---

您也可能会说，您只是想在您应该有权访问的一项发生更改时进行绑定或收到通知。您可以再次创建自己的类（从 Stack 或 Queue 派生），并在以下情况下手动触发 CollectionChanged 事件：

• 某些内容被推入堆栈或从堆栈中弹出
• 某些内容从队列中出列
• 当队列先前为空时，某些内容在队列中排队

Answer 3

我意识到已经有一些答案，但我想我会回馈一些我的答案。我将帖子和评论中提到的所有内容放在一起。有几件事促使我这样做：

• 当Push、Pop或ClearCount code> 被调用，如其中一篇文章中提到的。
• 对于Clear，操作应为Reset，并且集合更改事件的索引应设置为-1（如果不是，它将默认为设置以便其他帖子也有该设置）： .NET docs
• 对于 Push/Pop，操作应为 Add/Remove 并且集合的索引已更改对于堆栈来说，事件应该是0，因为它始终是并且只是第一个可以操作的项目（想想stack.GetEnumerator().MoveNext()）。
• 公开了 Stack 中可用的所有 3 个构造函数并使用 base() 调用，因为没有理由重写逻辑。

结果：

public class ObservableStack<T> : Stack<T>, INotifyCollectionChanged, INotifyPropertyChanged
{
    #region Constructors
    
    public ObservableStack() : base() { }

    public ObservableStack(IEnumerable<T> collection) : base(collection) { }

    public ObservableStack(int capacity) : base(capacity) { }

    #endregion
    
    #region Overrides

    public virtual new T Pop()
    {
        var item = base.Pop();
        OnCollectionChanged(NotifyCollectionChangedAction.Remove, item);

        return item;
    }

    public virtual new void Push(T item)
    {
        base.Push(item);
        OnCollectionChanged(NotifyCollectionChangedAction.Add, item);
    }

    public virtual new void Clear()
    {
        base.Clear();
        OnCollectionChanged(NotifyCollectionChangedAction.Reset, default);
    }

    #endregion

    #region CollectionChanged

    public virtual event NotifyCollectionChangedEventHandler CollectionChanged;

    protected virtual void OnCollectionChanged(NotifyCollectionChangedAction action, T item)
    {
        CollectionChanged?.Invoke(this, new NotifyCollectionChangedEventArgs(
            action
            , item
            , item == null ? -1 : 0)
        );

        OnPropertyChanged(nameof(Count));
    }

    #endregion

    #region PropertyChanged

    public virtual event PropertyChangedEventHandler PropertyChanged;

    protected virtual void OnPropertyChanged(string propertyName)
    {
        PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName));
    }

    #endregion
}

Answer 4

与上面的类非常相似，但有一些例外：

1. Publish 属性更改为 Count
2. Override TrimExcess() b/c 的集合更改，这可能会影响 Count
3. Made 事件公开，因此我不必强制转换到接口
4. 将索引传递给 collectionchanged合适的

    public class ObservableStack : Stack, INotifyPropertyChanged, INotifyCollectionChanged
    {
      public ObservableStack(IEnumerable collection) : base(collection) {}
      public ObservableStack() { } 

      public event PropertyChangedEventHandler PropertyChanged = delegate { };
      public event NotifyCollectionChangedEventHandler CollectionChanged = delegate { };

      protected virtual void OnCollectionChanged(NotifyCollectionChangedAction action, List items, int? index = null)
      {
        if (index.HasValue)
        {
            CollectionChanged(this, new NotifyCollectionChangedEventArgs(action, items, index.Value));
        }
        else
        {
            CollectionChanged(this, new NotifyCollectionChangedEventArgs(action, items));
        }
         OnPropertyChanged(GetPropertyName(() => Count));
      }

      protected virtual void OnPropertyChanged(string propName)
      {
        PropertyChanged(this, new PropertyChangedEventArgs(propName));
      }

      public new virtual void Clear()
      {
        base.Clear();
        OnCollectionChanged(NotifyCollectionChangedAction.Reset, null);
      }

      public new virtual T Pop()
      {
        var result = base.Pop();
        OnCollectionChanged(NotifyCollectionChangedAction.Remove, new List() { result }, base.Count);
        return result;
      }

      public new virtual void Push(T item)
      {
        base.Push(item);
        OnCollectionChanged(NotifyCollectionChangedAction.Add, new List() { item }, base.Count - 1);
      }   

      public new virtual void TrimExcess()
      {
        base.TrimExcess();
        OnPropertyChanged(GetPropertyName(() => Count));
      }

String GetPropertyName(Expression> propertyId)
{
   return ((MemberExpression)propertyId.Body).Member.Name;
}

    }