可观察链表

Question

在我的 WPF 应用程序中，我有一个 ItemsControl，其项目值取决于显示的上一个项目。

ViewModel 是一个音频文件，分为可变长度的部分，我需要以这种方式显示它，右侧显示日期时间，这就是我需要计算的内容（我只知道每个部分的长度，我需要计算它开始和结束的实际时间以及 ItemsControl 上的位置）。

--
  ----
      ------------
                  --
                    --------------------

我的第一个方法是使用 ObservableCollection 但很快就发生了一些可怕的事情：

5 路多重绑定，其中 IMultiValueConverter 我会计算要返回的值并设置一个DataContext 的属性更改为该值，因为我在运行时只知道前一个元素。

前一个元素是使用 Relativesource.PreviousData 上的绑定发送的。

现在我的问题是，在从转换器设置一个值（这显然是一件坏事）并实际让它工作之后，常规集合在其元素中没有顺序的概念，所以当进一步前进时我想在其余部分的中间添加一个音频部分，显示混乱了。

此外，当我要实现更多业务逻辑时，我可能需要访问在此转换器中计算的音频部分的开始和结束，如果尚未显示怎么办......？

所以这种方法在几个层面上都是错误的。

这就是我开始谷歌搜索并发现LinkedList的地方。现在我正在尝试创建一个基本上是 Observable LinkedList 的类（我不需要它是通用的）：

public class ObservableSegmentLinkedList : LinkedList<MyViewModel>, INotifyCollectionChanged
    {
        //Overrides ???

        #region INotifyCollectionChanged Members

        public event NotifyCollectionChangedEventHandler CollectionChanged;
        public void OnNotifyCollectionChanged(NotifyCollectionChangedEventArgs e)
        {
            if (CollectionChanged != null)
            {
                CollectionChanged(this, e);
            }
        }

        #endregion
    }

问题的核心是我无法重写修改集合的方法（Addfirst、AddLast等），所以我无法正确调用 OnNotifyCollectionChanged...

所以我想我可以为这些方法中的每一个进行重载，但这听起来很讨厌...

简而言之：我需要某种集合每个项目都知道前一个的详细信息，以便计算其自身的属性之一。

有任何线索吗？这是一个好的解决方案吗？

谢谢！

附录，ViewModel 看起来像：

public class MyViewModel : INotifyPropertyChanged
    {
        private DateTime m_SegmentLength;
        public DateTime SegmentLength
        {
            get { return m_SegmentLength; }
            set
            {
                m_SegmentLength = value;
                NotifyPropertyChanged("SegmentLength");
            }
        }

        private DateTime m_SegmentAdvert;
        public DateTime SegmentAdvert
        {
            get { return m_SegmentAdvert; }
            set
            {
                m_SegmentAdvert = value;
                NotifyPropertyChanged("SegmentAdvert");
            }
        }

        #region INotifyPropertyChanged Members

        public event PropertyChangedEventHandler PropertyChanged;
        private void NotifyPropertyChanged(String prop)
        {
            this.PropertyChanged(this, new PropertyChangedEventArgs(prop));
        }

        #endregion
    }

编辑：我想我会尝试结合托马斯和威尔的答案：我将使用组合（即我在自定义对象中保留 LinkedList 的实例而不是从中继承）并重新定义意味着的方法要使用的（AddAfter、AddFirst 等），我将在调用实际的 LinkedList 方法后调用 OnNotifyPropertychanged。这是一项工作，但我想我的问题不会有任何优雅的解决方案......

Answer 1

现在，我创建了一个支持 IEnumerable 的自定义泛型类，并且将其用作 LinkedList，唯一的区别是 WPF 会收到更改通知。

请注意，此解决方案仅适用于相当小的集合，我最多只需管理大约 30 个元素，所以这对我来说很好，但每次修改此集合时，它都被视为“重置”。

解决方案如下：

    /// <summary>
    /// This class is a LinkedList that can be used in a WPF MVVM scenario. Composition was used instead of inheritance,
    /// because inheriting from LinkedList does not allow overriding its methods.
    /// </summary>
    /// <typeparam name="T"></typeparam>
    public class ObservableLinkedList<T> : INotifyCollectionChanged, IEnumerable
    {
        private LinkedList<T> m_UnderLyingLinkedList;

        #region Variables accessors
        public int Count
        {
            get { return m_UnderLyingLinkedList.Count; }
        }

        public LinkedListNode<T> First
        {
            get { return m_UnderLyingLinkedList.First; }
        }

        public LinkedListNode<T> Last
        {
            get { return m_UnderLyingLinkedList.Last; }
        }
        #endregion

        #region Constructors
        public ObservableLinkedList()
        {
            m_UnderLyingLinkedList = new LinkedList<T>();
        }

        public ObservableLinkedList(IEnumerable<T> collection)
        {
            m_UnderLyingLinkedList = new LinkedList<T>(collection);
        }
        #endregion

        #region LinkedList<T> Composition
        public LinkedListNode<T> AddAfter(LinkedListNode<T> prevNode, T value)
        {
            LinkedListNode<T> ret = m_UnderLyingLinkedList.AddAfter(prevNode, value);
            OnNotifyCollectionChanged();
            return ret;
        }

        public void AddAfter(LinkedListNode<T> node, LinkedListNode<T> newNode)
        {
            m_UnderLyingLinkedList.AddAfter(node, newNode);
            OnNotifyCollectionChanged();
        }

        public LinkedListNode<T> AddBefore(LinkedListNode<T> node, T value)
        {
            LinkedListNode<T> ret = m_UnderLyingLinkedList.AddBefore(node, value);
            OnNotifyCollectionChanged();
            return ret;
        }

        public void AddBefore(LinkedListNode<T> node, LinkedListNode<T> newNode)
        {
            m_UnderLyingLinkedList.AddBefore(node, newNode);
            OnNotifyCollectionChanged();
        }

        public LinkedListNode<T> AddFirst(T value)
        {
            LinkedListNode<T> ret = m_UnderLyingLinkedList.AddFirst(value);
            OnNotifyCollectionChanged();
            return ret;
        }

        public void AddFirst(LinkedListNode<T> node)
        {
            m_UnderLyingLinkedList.AddFirst(node);
            OnNotifyCollectionChanged();
        }

        public LinkedListNode<T> AddLast(T value)
        {
            LinkedListNode<T> ret = m_UnderLyingLinkedList.AddLast(value);
            OnNotifyCollectionChanged();
            return ret;
        }

        public void AddLast(LinkedListNode<T> node)
        {
            m_UnderLyingLinkedList.AddLast(node);
            OnNotifyCollectionChanged();
        }

        public void Clear()
        {
            m_UnderLyingLinkedList.Clear();
            OnNotifyCollectionChanged();
        }

        public bool Contains(T value)
        {
            return m_UnderLyingLinkedList.Contains(value);
        }

        public void CopyTo(T[] array, int index)
        {
            m_UnderLyingLinkedList.CopyTo(array, index);
        }

        public bool LinkedListEquals(object obj)
        {
            return m_UnderLyingLinkedList.Equals(obj);
        }

        public LinkedListNode<T> Find(T value)
        {
            return m_UnderLyingLinkedList.Find(value);
        }

        public LinkedListNode<T> FindLast(T value)
        {
            return m_UnderLyingLinkedList.FindLast(value);
        }

        public Type GetLinkedListType()
        {
            return m_UnderLyingLinkedList.GetType();
        }

        public bool Remove(T value)
        {
            bool ret = m_UnderLyingLinkedList.Remove(value);
            OnNotifyCollectionChanged();
            return ret;
        }

        public void Remove(LinkedListNode<T> node)
        {
            m_UnderLyingLinkedList.Remove(node);
            OnNotifyCollectionChanged();
        }

        public void RemoveFirst()
        {
            m_UnderLyingLinkedList.RemoveFirst();
            OnNotifyCollectionChanged();
        }

        public void RemoveLast()
        {
            m_UnderLyingLinkedList.RemoveLast();
            OnNotifyCollectionChanged();
        }
        #endregion

        #region INotifyCollectionChanged Members

        public event NotifyCollectionChangedEventHandler CollectionChanged;
        public void OnNotifyCollectionChanged()
        {
            if (CollectionChanged != null)
            {
                CollectionChanged(this, new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Reset));
            }
        }

        #endregion

        #region IEnumerable Members

        IEnumerator IEnumerable.GetEnumerator()
        {
            return (m_UnderLyingLinkedList as IEnumerable).GetEnumerator();
        }

        #endregion
    }

正如 @AndrewS 在评论中提到的，LinkedListNode 应该替换为从其 List 属性返回 ObservableLinkedList 的自定义类。

Answer 2

LinkedList 不是为继承而设计的：它的大多数方法都不是虚拟的，因此无需重写任何内容。如果您想重用其实现并实现 INotifyCollectionChanged，请使用组合，而不是继承。

但无论如何，实现一个可观察的链表是没有意义的，因为链表不支持通过索引进行随机访问，并且 CollectionChanged 通知仅在您指定索引时才有用（除非您只引发 NotifyCollectionChangedAction.Reset 通知，但效率不高）

Answer 3

这是一个很好的解决方案，您只需创建自己的 LinkedList 实现即可。

LinkedList 不实现任何链接列表接口，因此您需要自行决定方法/属性。我认为一个好的指南是复制 LinkedList 的公共方法和属性。这将允许您使用集合的实际实例作为后备存储。

Answer 4

我认为最终更简单的解决方案是预先计算开始和结束时间并将它们添加为 ViewModel 上的属性。特别是因为您说您的业务逻辑中可能需要这个值。

Answer 5

在我看来，你有两个不同的问题。一个是管理要显示的项目列表，另一个是允许项目访问其前面和后面的项目。

这就是我的处理方法：将 Previous 和 Next 属性添加到项目类中，在最初填充集合时设置它们，然后在插入和删除项目时更新它们从列表中。

如果您真的想疯狂地制定一个通用解决方案，您可以实现一个 ILinkedListNode 接口，然后将 ObservableCollection子类化。其中 T ：ILinkedListNode，重写各种插入和删除方法以更新项目的 Previous 和 Next 属性。如果我需要可重复使用的解决方案，我就会这么做。

但如果没有，我只需创建一个视图模型类来包装该集合，将其公开为 Items 属性，然后实现 UI 可以绑定到的插入和删除命令。

Answer 6

如果你的类是这样的：

public class ObservableSegmentLinkedList<T> : LinkedList<T>, INotifyCollectionChanged 
{
...
public new void AddFirst(T value)
{
.. do something to make it your own - you can still call the base method so in effect you override it with the new keyword.
}
}

用 new 关键字覆盖方法就不会有任何问题。
请注意，类本身有一个与您的链接列表类型相匹配的类型说明符。

我在这里将其设为通用，但您可以在这些 < 之间放置任何您想要的内容。我的类型 > 。
通用只是意味着你可以在比 1 更多的地方使用这个东西，包括未来的项目。