Question

我有一组（完全）有序的OrderedObject

对象

public class OrderedObject {
    public int ord;        // ordinal number
}

他们有一个ord类型的字段int，它对每个对象都是唯一的，并代表它们的序号。尽管如此，ord的值可能因每个对象而异。我想将对象存储在Dictionary<int*, OrderedObject>中，使得密钥（星号代表指向int的指针，不知道如何用C＃实现，但这不是我的问题）指向序数值对象的编号，并随后者自动更改。 这有可能吗？

对于那些认为我的承诺毫无意义的人：背景是现在序数是一个由整数表示的自然数，但后来它将被另一个OrderedObject所取代，其中排序与订购自然数字。

Answer 1

请注意，任何字典中的键都必须是唯一的，因此您无法通过在另一个字符之后更改一个键来进行交换。在这种情况下，你必须以不同的方式实现它。但只要您始终拥有唯一的密钥，您就可以执行以下操作：

class ReorderingDictionary : IDictionary<int, OrderItem>
    {

        private SortedList<int, OrderItem> sortedList = new SortedList<int, OrderItem>();

        public void Add(int key, OrderItem value)
        {
            value.IneedToBeReordered += value_IneedToBeReordered;
            sortedList.Add(key, value);
        }

        void value_IneedToBeReordered(object sender, ReOrderMeEventArgs e)
        {
            sortedList.Remove(e.OldKey);
            OrderItem item = (OrderItem)sender;
            sortedList.Add(item.Ord, item);
        }

        public bool ContainsKey(int key)
        {
            return sortedList.ContainsKey(key);
        }

        public ICollection<int> Keys
        {
            get { return sortedList.Keys; }
        }

        public bool Remove(int key)
        {
            return sortedList.Remove(key);
        }

        public bool TryGetValue(int key, out OrderItem value)
        {
            return sortedList.TryGetValue(key, out value);
        }

        public ICollection<OrderItem> Values
        {
            get { return sortedList.Values; }
        }

        public OrderItem this[int key]
        {
            get
            {
                return sortedList[key];
            }
            set
            {
                sortedList[key] = value;
            }
        }

        public void Add(KeyValuePair<int, OrderItem> item)
        {
            item.Value.IneedToBeReordered += value_IneedToBeReordered;
            sortedList.Add(item.Key, item.Value);
        }

        public void Clear()
        {
            sortedList.Clear();
        }

        public bool Contains(KeyValuePair<int, OrderItem> item)
        {
            return sortedList.ContainsKey(item.Key) && sortedList[item.Key] == item.Value;
        }

        public void CopyTo(KeyValuePair<int, OrderItem>[] array, int arrayIndex)
        {
            throw new NotImplementedException();
        }

        public int Count
        {
            get { return sortedList.Count; }
        }

        public bool IsReadOnly
        {
            get { throw new NotImplementedException(); }
        }

        public bool Remove(KeyValuePair<int, OrderItem> item)
        {
            return sortedList.Remove(item.Key);
        }

        public IEnumerator<KeyValuePair<int, OrderItem>> GetEnumerator()
        {
            return sortedList.GetEnumerator();
        }

        System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator()
        {
            return sortedList.GetEnumerator();
        }
    }


    class OrderItem
    {
        private int ord;

        public int Ord
        {
            get { return ord; }
            set
            {
                int oldKey = ord;
                ord = value;
                if (IneedToBeReordered != null)
                {
                    IneedToBeReordered(this, new ReOrderMeEventArgs(oldKey));
                }
            }
        }

        public event EventHandler<ReOrderMeEventArgs> IneedToBeReordered;
    }

    class ReOrderMeEventArgs : EventArgs
    {
        public int OldKey { get; private set; }

        public ReOrderMeEventArgs(int oldKey)
        {
            this.OldKey = oldKey;
        }
    }

用指针作为词典中的关键词

1 个答案: