Warum ein generisches OrderedDictionary in C# implementieren?

Ein generisches OrderedDictionary zu implementieren ist nicht besonders schwierig, aber es ist unnötig zeitaufwändig und ehrlich gesagt ist diese Klasse ein großes Versehen von Microsoft. Es gibt mehrere Möglichkeiten, dies zu implementieren, aber ich habe mich für die Verwendung einer KeyedCollection für meinen internen Speicher entschieden. Ich habe mich auch dafür entschieden, verschiedene Methoden zum Sortieren zu implementieren, damit List Dies ist der Fall, da es sich im Wesentlichen um eine Mischung aus IList und IDictionary handelt.

Hier ist die Schnittstelle. Beachten Sie, dass es System.Collections.Specialized.IOrderedDictionary enthält, die nicht generische Version dieser Schnittstelle, die von Microsoft bereitgestellt wurde.

// https://choosealicense.com/licenses/unlicense
// oder https://choosealicense.com/licenses/mit/
using System;
using System.Collections.Generic;
unter Verwendung von System.Collections.Specialized;

Namespace mattmc3.Common.Collections.Generic {

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>

}
Hier ist die Implementierung zusammen mit dem Hilfsprogramm Klassen:

// http://unlicense.org
using System;
mit System.Collections.ObjectModel;
mit System.Diagnostics;
mit System.Collections;
mit System.Collections.Specialized;
mit System.Collections.Generic;
Verwenden des System.Linq;

Namespace mattmc3.Common.Collections.Generic {

/// <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>

Das obige ist der detaillierte Inhalt vonWarum ein generisches OrderedDictionary in C# implementieren?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!