Was ist der Unterschied zwischen SortedList und SortedDictionary?

Ja - Ihre Leistungsmerkmale unterscheiden sich deutlich. Es wäre wahrscheinlich besser, Sie zu nennen SortedList und SortedTree wie spiegelt sich die Umsetzung genauer an.

Blick auf die MSDN-Dokumentation für jede von Ihnen (SortedListSortedDictionary) für die details der Leistung, die für verschiedene Operationen in unterschiedlichen situtations. Hier ist eine schöne Zusammenfassung (aus der SortedDictionary docs):

Den SortedDictionary<TKey, TValue> generic
Klasse ist ein binärer Suchbaum mit
O(log n) abrufen, wobei n die
Anzahl der Elemente in der Wörterbuch.
In diesem ist es ähnlich wie die
SortedList<TKey, TValue> generic
Klasse. Die beiden Klassen haben ähnliche
Objekt-Modelle, und beide haben O(log n)
- Abruf. Wo der zwei Klassen
Sie unterscheiden sich jedoch in der Speichernutzung und der Geschwindigkeit der
einsetzen und entfernen:

• SortedList<TKey, TValue> weniger
  Speicher als SortedDictionary<TKey,
TValue>.

• SortedDictionary<TKey, TValue> hat
  schneller einführen und entfernen
  Operationen für unsortierte Daten, O(log n)
  im Gegensatz zu O(n) für
  SortedList<TKey, TValue>.

• Wenn die Liste gefüllt ist, alle auf einmal
  von sortierten Daten, SortedList<TKey,
TValue> ist schneller als
  SortedDictionary<TKey, TValue>.

(SortedList tatsächlich unterhält ein sortiertes array, anstatt mit einem Baum. Es verwendet immer noch die binäre Suche zum finden von Elementen.)

InformationsquelleAutor der Antwort Jon Skeet

Ich geknackt öffnen Sie den Reflektor, um einen Blick auf diese, wie es scheint ein wenig Verwirrung über SortedList. Es ist in der Tat nicht eine binäre Suchbaum, es ist eine sortiert werden (nach Schlüssel) array von Schlüssel-Wert-Paare. Es gibt auch eine TKey[] keys variable sortiert ist in sync mit den Schlüssel-Wert-Paare und verwendet, um die binäre Suche.

Hier ist eine Quelle (targeting .NET 4.5) zur Sicherung meiner Ansprüche.

Private Mitglieder

//Fields
private const int _defaultCapacity = 4;
private int _size;
[NonSerialized]
private object _syncRoot;
private IComparer<TKey> comparer;
private static TKey[] emptyKeys;
private static TValue[] emptyValues;
private KeyList<TKey, TValue> keyList;
private TKey[] keys;
private const int MaxArrayLength = 0x7fefffff;
private ValueList<TKey, TValue> valueList;
private TValue[] values;
private int version;

SortedList.ctor(IDictionary, IComparer)

public SortedList(IDictionary<TKey, TValue> dictionary, IComparer<TKey> comparer) : this((dictionary != null) ? dictionary.Count : 0, comparer)
{
    if (dictionary == null)
    {
        ThrowHelper.ThrowArgumentNullException(ExceptionArgument.dictionary);
    }
    dictionary.Keys.CopyTo(this.keys, 0);
    dictionary.Values.CopyTo(this.values, 0);
    Array.Sort<TKey, TValue>(this.keys, this.values, comparer);
    this._size = dictionary.Count;
}

SortedList.Add(TKey, TValue) : void

public void Add(TKey key, TValue value)
{
    if (key == null)
    {
        ThrowHelper.ThrowArgumentNullException(ExceptionArgument.key);
    }
    int num = Array.BinarySearch<TKey>(this.keys, 0, this._size, key, this.comparer);
    if (num >= 0)
    {
        ThrowHelper.ThrowArgumentException(ExceptionResource.Argument_AddingDuplicate);
    }
    this.Insert(~num, key, value);
}

SortedList.RemoveAt(int) : void

public void RemoveAt(int index)
{
    if ((index < 0) || (index >= this._size))
    {
        ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.index, ExceptionResource.ArgumentOutOfRange_Index);
    }
    this._size--;
    if (index < this._size)
    {
        Array.Copy(this.keys, index + 1, this.keys, index, this._size - index);
        Array.Copy(this.values, index + 1, this.values, index, this._size - index);
    }
    this.keys[this._size] = default(TKey);
    this.values[this._size] = default(TValue);
    this.version++;
}

InformationsquelleAutor der Antwort Daniel Imms

Ist die visuelle Darstellung, wie Leistungen miteinander vergleichen.

InformationsquelleAutor der Antwort Lev

Index-Zugriff (hier erwähnten) ist der praktische Unterschied.
Wenn Sie brauchen, um den Zugriff auf die Nachfolger oder Vorgänger, müssen Sie SortedList. SortedDictionary nicht tun, also Sie sind ziemlich begrenzt wie Sie können die Sortierung (erste /foreach).

InformationsquelleAutor der Antwort Guy