5

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

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

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

我的第一种方法是使用一个ObservableCollection<MyviewModel>但很快就发生了一些恐怖事件：

5-way multibinding 在其中IMultiValueConverter我将计算要返回的值并将 DataContext 的属性设置为该值，因为我只知道运行时的前一个元素。

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

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

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

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

那是我开始谷歌搜索并发现的地方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
    }

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

4

6 回答 6

6

好的，现在，我创建了一个自定义泛型类，它支持IEnumerable并像它一样使用LinkedList<T>，唯一的区别是 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 的自定义类。

于 2011-08-09T15:40:10.183 回答
3

LinkedList<T>不是为继承而设计的：它的大多数方法都不是虚拟的，所以没有什么可以覆盖的。如果您想重用它的 implementation 和 implement INotifyCollectionChanged，请使用组合，而不是继承。

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

于 2011-08-09T12:58:46.130 回答
1

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

LinkedList<T>不实现任何链接列表接口，因此您可以自行决定方法/属性。我想一个好的指南是复制LinkedList<T>. 这将允许您使用集合的实际实例作为后备存储。

于 2011-08-09T12:59:33.450 回答
0

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

于 2011-08-09T13:20:33.393 回答
0

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

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

如果您真的想发疯并制定通用解决方案，您可以实现一个ILinkedListNode接口，然后实现子类ObservableCollection<T> where T : ILinkedListNode，覆盖各种插入和删除方法来更新项目Previous和Next属性。如果我需要可重复使用的解决方案，我会这样做。

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

于 2011-08-09T13:25:20.877 回答
0

如果你的课程是这样的：

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 关键字覆盖方法应该没有任何问题。
请注意，类本身有一个与您的链接列表类型匹配的类型说明符。

我在这里使它通用，但是您可以在< MyType >之间放置任何您想要的东西。通用只是意味着您可以在比 1 更多的地方使用这个东西，包括未来的项目。

于 2015-08-27T15:14:09.110 回答