0

私はC＃にまったく慣れていないので、誰かが別の方法を提案できない限り、自分のバージョンのOrderedDictionaryで恐ろしい試みをしようとしています。

追加された順序を維持しながら、配列インデックスで要素にアクセスできる必要があります。また、キーを使用して個々の要素を頻繁に更新します。

  1. 電話でこれを可能にするコレクションはありますか？

  2. リストと辞書を保持している場合、それらは両方とも同じアイテムを指しているのでしょうか、それとも私がしなければならないある種のポインターのことはありますか？：

    Item i = new Item();
list.Add(i);
dict.Add("key", i);
4

3 に答える 3

1

これが私の実装です（オープンソースのOpenNETCF Extensionsライブラリから来ています）：

public class OrderedDictionary<TKey, TValue> : IEnumerable<KeyValuePair<TKey, TValue>>
{
    private Dictionary<TKey, TValue> m_dictionary;
    private List<TValue> m_list = new List<TValue>();
    private object m_syncRoot = new object();

    public OrderedDictionary()
    {
        m_dictionary = new Dictionary<TKey, TValue>();
    }

    public OrderedDictionary(IEqualityComparer<TKey> comparer)
    {
        m_dictionary = new Dictionary<TKey, TValue>(comparer);
    }

    public void Add(TKey key, TValue value)
    {
        lock (m_syncRoot)
        {
            m_dictionary.Add(key, value);
            m_list.Add(value);
        }
    }

    public TValue this[int index]
    {
        get { return m_list[index]; }
    }

    public TValue this[TKey key]
    {
        get { return m_dictionary[key]; }
    }

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

    public Dictionary<TKey, TValue>.KeyCollection Keys 
    {
        get { return m_dictionary.Keys; } 
    }

    public Dictionary<TKey, TValue>.ValueCollection Values 
    {
        get { return m_dictionary.Values; } 
    }

    public void Clear()
    {
        lock (m_syncRoot)
        {
            m_dictionary.Clear();
            m_list.Clear();
        }
    }

    public bool ContainsKey(TKey key)
    {
        return m_dictionary.ContainsKey(key);
    }

    public bool ContainsValue(TValue value)
    {
        return m_dictionary.ContainsValue(value);
    }

    public void Insert(int index, TKey key, TValue value)
    {
        lock (m_syncRoot)
        {
            m_list.Insert(index, value);
            m_dictionary.Add(key, value);
        }
    }

    public void Remove(TKey key)
    {
        lock (m_syncRoot)
        {
            if (ContainsKey(key))
            {
                var existing = m_dictionary[key];
                m_list.Remove(existing);
                m_dictionary.Remove(key);
            }
        }
    }

    public IEnumerator<KeyValuePair<TKey, TValue>> GetEnumerator()
    {
        return m_dictionary.GetEnumerator();
    }

    IEnumerator IEnumerable.GetEnumerator()
    {
        return GetEnumerator();
    }
}
于 2012-09-08T17:09:15.340 に答える
0

リストとディクショナリを使用することは、実際にはおそらく良いオプションです。あなたが話している「ポインターのこと」は、.NET のオブジェクト (任意のクラスおよび/または構造) に対してデフォルトで発生します。.NET のすべてのオブジェクトは参照によって渡されます。

したがって、次を使用する場合：

Item i = new Item();
list.Add(i);
dict.Add("key",i);
Console.WriteLine(list.Last() == dict["key"]);

出力は「true」になります。

頑張ってください！

于 2012-09-08T01:27:46.653 に答える
0

OrderedDictionary は一般的なコンテナーではないため、使用することはお勧めしません。

ただし、いつものように使いたいだけなら。Mono のバージョンの OrderedDictionary を移植できます。

https://github.com/mono/mono/blob/master/mcs/class/System/System.Collections.Specialized/OrderedDictionary.cs

これを移植する場合のヒントを次に示します。

  1. 使用できないインターフェイスを削除します
  2. シリアライゼーション関連のコードを削除
  3. ArrayList を次のように置き換えますList<object>
  4. ハッシュテーブルを次のものに置き換えますDictionary<object, object>
于 2012-09-08T10:20:05.650 に答える