Mengapa Melaksanakan Generic OrderedDictionary dalam C#?

Melaksanakan OrderedDictionary generik tidak begitu sukar, tetapi ia tidak semestinya memakan masa dan sejujurnya kelas ini merupakan kesilapan besar di pihak Microsoft. Terdapat pelbagai cara untuk melaksanakan ini, tetapi saya memilih untuk menggunakan KeyedCollection untuk storan dalaman saya. Saya juga memilih untuk melaksanakan pelbagai kaedah untuk menyusun cara yang Senarai lakukan kerana ini pada asasnya ialah IList hibrid dan IDictionary.

Ini antara mukanya. Perhatikan bahawa ia termasuk System.Collections.Specialized.IOrderedDictionary, iaitu versi bukan generik antara muka ini yang disediakan oleh Microsoft.

// https://choosealicense.com/licenses/unlicense
// atau https://choosealicense.com/licenses/mit/
menggunakan Sistem;
menggunakan System.Collections.Generik;
menggunakan System.Collections.Specialized;

namespace mattmc3.Common.Collections.Generik {

public interface IOrderedDictionary<tkey tvalue> : IDictionary<tkey tvalue>, IOrderedDictionary {
    new TValue this[int index] { get; set; }
    new TValue this[TKey key] { get; set; }
    new int Count { get; }
    new ICollection<tkey> Keys { get; }
    new ICollection<tvalue> Values { get; }
    new void Add(TKey key, TValue value);
    new void Clear();
    void Insert(int index, TKey key, TValue value);
    int IndexOf(TKey key);
    bool ContainsValue(TValue value);
    bool ContainsValue(TValue value, IEqualityComparer<tvalue> comparer);
    new bool ContainsKey(TKey key);
    new IEnumerator<keyvaluepair tvalue>> GetEnumerator();
    new bool Remove(TKey key);
    new void RemoveAt(int index);
    new bool TryGetValue(TKey key, out TValue value);
    TValue GetValue(TKey key);
    void SetValue(TKey key, TValue value);
    KeyValuePair<tkey tvalue> GetItem(int index);
    void SetItem(int index, TValue value);
}
</tkey></keyvaluepair></tvalue></tvalue></tkey></tkey></tkey>

}
Berikut ialah pelaksanaan bersama pembantu kelas:

// http://unlicense.org
menggunakan Sistem;
menggunakan System.Collections.ObjectModel;
menggunakan System.Diagnostics;
menggunakan System.Collections;
menggunakan System.Collections.Specialized;
menggunakan System.Collections.Generik;
menggunakan System.Linq;

ruang nama mattmc3.Common.Collections.Generik {

/// <summary>
/// A dictionary object that allows rapid hash lookups using keys, but also
/// maintains the key insertion order so that values can be retrieved by
/// key index.
/// </summary>
public class OrderedDictionary<tkey tvalue> : IOrderedDictionary<tkey tvalue> {

    #region Fields/Properties

    private KeyedCollection2<tkey keyvaluepair tvalue>> _keyedCollection;

    /// <summary>
    /// Gets or sets the value associated with the specified key.
    /// </summary>
    /// <param name='"key"'>The key associated with the value to get or set.
    public TValue this[TKey key] {
        get {
            return GetValue(key);
        }
        set {
            SetValue(key, value);
        }
    }

    /// <summary>
    /// Gets or sets the value at the specified index.
    /// </summary>
    /// <param name='"index"'>The index of the value to get or set.
    public TValue this[int index] {
        get {
            return GetItem(index).Value;
        }
        set {
            SetItem(index, value);
        }
    }

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

    public ICollection<tkey> Keys {
        get {
            return _keyedCollection.Select(x => x.Key).ToList();
        }
    }

    public ICollection<tvalue> Values {
        get {
            return _keyedCollection.Select(x => x.Value).ToList();
        }
    }

    public IEqualityComparer<tkey> Comparer {
        get;
        private set;
    }

    #endregion

    #region Constructors

    public OrderedDictionary() {
        Initialize();
    }

    public OrderedDictionary(IEqualityComparer<tkey> comparer) {
        Initialize(comparer);
    }

    public OrderedDictionary(IOrderedDictionary<tkey tvalue> dictionary) {
        Initialize();
        foreach (KeyValuePair<tkey tvalue> pair in dictionary) {
            _keyedCollection.Add(pair);
        }
    }

    public OrderedDictionary(IOrderedDictionary<tkey tvalue> dictionary, IEqualityComparer<tkey> comparer) {
        Initialize(comparer);
        foreach (KeyValuePair<tkey tvalue> pair in dictionary) {
            _keyedCollection.Add(pair);
        }
    }

    #endregion

    #region Methods

    private void Initialize(IEqualityComparer<tkey> comparer = null) {
        this.Comparer = comparer;
        if (comparer != null) {
            _keyedCollection = new KeyedCollection2<tkey keyvaluepair tvalue>>(x => x.Key, comparer);
        }
        else {
            _keyedCollection = new KeyedCollection2<tkey keyvaluepair tvalue>>(x => x.Key);
        }
    }

    public void Add(TKey key, TValue value) {
        _keyedCollection.Add(new KeyValuePair<tkey tvalue>(key, value));
    }

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

    public void Insert(int index, TKey key, TValue value) {
        _keyedCollection.Insert(index, new KeyValuePair<tkey tvalue>(key, value));
    }

    public int IndexOf(TKey key) {
        if (_keyedCollection.Contains(key)) {
            return _keyedCollection.IndexOf(_keyedCollection[key]);
        }
        else {
            return -1;
        }
    }

    public bool ContainsValue(TValue value) {
        return this.Values.Contains(value);
    }

    public bool ContainsValue(TValue value, IEqualityComparer<tvalue> comparer) {
        return this.Values.Contains(value, comparer);
    }

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

    public KeyValuePair<tkey tvalue> GetItem(int index) {
        if (index = _keyedCollection.Count) {
            throw new ArgumentException(String.Format("The index was outside the bounds of the dictionary: {0}", index));
        }
        return _keyedCollection[index];
    }

    /// <summary>
    /// Sets the value at the index specified.
    /// </summary>
    /// <param name='"index"'>The index of the value desired
    /// <param name='"value"'>The value to set
    /// <exception cref='"ArgumentOutOfRangeException"'>
    /// Thrown when the index specified does not refer to a KeyValuePair in this object
    /// </exception>
    public void SetItem(int index, TValue value) {
        if (index = _keyedCollection.Count) {
            throw new ArgumentException("The index is outside the bounds of the dictionary: {0}".FormatWith(index));
        }
        var kvp = new KeyValuePair<tkey tvalue>(_keyedCollection[index].Key, value);
        _keyedCollection[index] = kvp;
    }

    public IEnumerator<keyvaluepair tvalue>> GetEnumerator() {
        return _keyedCollection.GetEnumerator();
    }

    public bool Remove(TKey key) {
        return _keyedCollection.Remove(key);
    }

    public void RemoveAt(int index</keyvaluepair></tkey></tkey></tvalue></tkey></tkey></tkey></tkey></tkey></tkey></tkey></tkey></tkey></tkey></tkey></tkey></tvalue></tkey></tkey></tkey></tkey>

Atas ialah kandungan terperinci Mengapa Melaksanakan Generic OrderedDictionary dalam C#?. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!