c# - 在字典中使用指针作为键

Question

我有一组(完全)有序的 OrderedObject 类对象

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

他们有一个字段 ord类型 int这对于每个对象都是唯一的，代表它们的序号。尽管如此ord的值(value)可以因每个对象而异。我想将对象存储在 Dictionary<int*, OrderedObject> 中这样键(星号代表指向 int 的指针，不确定如何使用 C# 实现它，但这不是我的问题)指向值对象的序号并随后者自动更改。 这有可能吗？

对于那些认为我的 promise 毫无意义的人:背景是目前序数是一个用整数表示的自然数，但以后会被另一个OrderedObject代替。其中排序与排序自然数略有不同。

Answer 1

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

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;
        }
    }