维护列表顺序删除和添加元素

Question

我无法想出这个问题的逻辑。我有一个窗口中显示的项目列表。如果项目在列表中，则显示该项目。我无法改变这一点。我通过我可以编辑的继承类访问列表。我无法以任何方式编辑基类的源代码（包含列表的类）。我正在编辑的类是插入列表的类。它还可以访问该列表。

我需要能够从列表中删除项目并插入它们，同时保持相同的顺序。

示例如果我的列表是：

1,2,3,4,5

我删除2,3,4然后我

1,5

然后我按顺序添加了4,3,2。它必须显示

1,2,3,4,5 

再次而不是

1,4,3,2,5

它们必须按照原始顺序删除。这只是一个例子，这些值无法排序。它们按照它们被添加的顺序排列。

所以问题是，如何删除元素并将其添加到列表中并确保保留订单？

我试过了：

插入空值而不是从列表中删除元素。这不起作用，因为显示空白点。我也试过记住它们被删除的索引，但是当我将它们插回到列表中时，可能会在索引0处插入多个项目并因为列表缩小而丢失排序。

我使用的是ObservableCollection http://msdn.microsoft.com/en-us/library/ms668604(v=vs.110).aspx

我希望这篇文章在我想要实现的目标中是明确的。

Answer 1

这是给你的一个想法。我已经实现了我自己的IList<T>课程，可以做你想做的事情（我想。）

首先我从这开始：

public class RememberOrderList<T> : IList<T>
{
}

然后我创建了_inner T的{​​{1}}列表，并通过传递到_inner实现了大部分必需的方法。

public class RememberOrderList<T> : IList<T>
{
    private List<T> _inner = new List<T>();
    public int IndexOf(T item) { return _inner.IndexOf(item); }
    public void RemoveAt(int index) { _inner.RemoveAt(index); }
    public T this[int index] { get { return _inner[index]; } set { _inner[index] = value; } }
    public void Clear() { _inner.Clear(); }
    public bool Contains(T item) { return _inner.Contains(item); }
    public void CopyTo(T[] array, int arrayIndex) { _inner.CopyTo(array, arrayIndex); }
    public int Count { get { return _inner.Count; } }
    public bool IsReadOnly { get { return ((ICollection<T>)_inner).IsReadOnly; } }
    public bool Remove(T item) { return _inner.Remove(item); }
    public IEnumerator<T> GetEnumerator() { return _inner.GetEnumerator(); }
    IEnumerator IEnumerable.GetEnumerator() { return _inner.GetEnumerator(); }

现在，有两种方法可以将项目添加到列表中 - Insert＆amp; Add。

Insert是一个问题，因为它指定了索引而我们不想要这样 - 因此会抛出NotSupportedException。

    public void Insert(int index, T item)
    {
        throw new NotSupportedException();
    }

Add只需记住添加项目的顺序，并在退出前进行排序。这需要更多的工作。

使用Dictionary<T, int>跟踪项目的顺序。

    private readonly Dictionary<T, int> _order = new Dictionary<T, int>();

要对List<T>进行排序，您需要IComparer<T>。

    private class OrderComparer : IComparer<T>
    {
        private readonly Dictionary<T, int> _order;
        public OrderComparer(Dictionary<T, int> order)
        {
            _order = order;
        }

        public int Compare(T x, T y)
        {
            return _order[x].CompareTo(_order[y]);
        }
    }

现在Add很简单。

    public void Add(T item)
    {
        if (!_order.ContainsKey(item))
        {
            _order[item] = _order.Count;
        }
        _inner.Add(item);
        _inner.Sort(new OrderComparer(_order));
    }

将所有这些放在一起可以让我这样做：

var rol = new RememberOrderList<int>();

rol.Add(1);
rol.Add(2);
rol.Add(3);
rol.Add(4);
rol.Add(5);

rol.Remove(2);
rol.Remove(3);
rol.Remove(4);

rol.Add(4);
rol.Add(3);
rol.Add(2);

我从中获得此列表：

现在，为了避免任何混淆，我使用20代替2再次运行此代码并获得结果{ 1, 20, 3, 4, 5 }，以便按所需行为进行排序。