C # Sortierbare Sammlung, die doppelte Schlüssel erlaubt

Verwenden Sie Ihre eigenen IComparer!

Wie schon in einigen anderen Antworten, Sie sollten Ihren eigenen comparer-Klasse. Für diesen Zweck verwende ich ein generisches IComparer-Klasse, das funktioniert mit allem, was implementiert IComparable:

///<summary>
///Comparer for comparing two keys, handling equality as beeing greater
///Use this Comparer e.g. with SortedLists or SortedDictionaries, that don't allow duplicate keys
///</summary>
///<typeparam name="TKey"></typeparam>
public class DuplicateKeyComparer<TKey>
                :
             IComparer<TKey> where TKey : IComparable
{
    #region IComparer<TKey> Members

    public int Compare(TKey x, TKey y)
    {
        int result = x.CompareTo(y);

        if (result == 0)
            return 1;   //Handle equality as beeing greater
        else
            return result;
    }

    #endregion
}

Sie verwenden, wenn die Instanziierung einer neuen SortedList, SortedDictionary etc:

SortedList<int, MyValueClass> slist = new SortedList<int, MyValueClass>(new DuplicateKeyComparer<int>());

Hier int der Schlüssel ist, werden doppelte.

InformationsquelleAutor der Antwort Knasterbax

Einfachste Lösung (im Vergleich zu all den oben genannten): SortedSet<T> es nimmt eine IComparer<SortableKey> Klasse, dann implementieren Sie die Methode Vergleichen so:

public int Compare(SomeClass x, SomeClass y)
{
    var compared = x.SomeSortableKeyTypeField.CompareTo(y.SomeSortableKeyTypeField);
    if (compared != 0)
        return compared;

    //to allow duplicates
    var hashCodeCompare = x.GetHashCode().CompareTo(y.GetHashCode());
    if (hashCodeCompare != 0)
        return hashCodeCompare;

    if (Object.ReferenceEquals(x, y))
        return 0;

    //for weird duplicate hashcode cases, throw as below or implement your last chance comparer
    throw new ComparisonFailureException();

}

InformationsquelleAutor der Antwort knocte

Das problem ist, dass die Daten-Struktur-design entsprechen nicht der Anforderungen: Es ist notwendig, zu speichern, mehrere Zeilen für die gleiche XPosition. Daher SortedList<XPos, value> sollte nicht haben einen Wert von Headeraber ein Wert von List<Header>. Es ist eine einfache und kleine Veränderung, aber es löst alle Probleme und vermeidet die Schaffung neuer Probleme wie die anderen vorgeschlagenen Lösungen (siehe Erläuterung unten):

using System;
using System.Collections.Generic;

namespace TrySortedList {
  class Program {

    class Header {
      public int XPos;
      public string Name;
    }

    static void Main(string[] args) {
      SortedList<int, List<Header>> sortedHeaders = new SortedList<int,List<Header>>();
      add(sortedHeaders, 1, "Header_1");
      add(sortedHeaders, 1, "Header_2");
      add(sortedHeaders, 2, "Header_3");
      foreach (var headersKvp in sortedHeaders) {
        foreach (Header header in headersKvp.Value) {
          Console.WriteLine(header.XPos + ": " + header.Name);
        }
      }
    }

    private static void add(SortedList<int, List<Header>> sortedHeaders, int xPos, string name) {
      List<Header> headers;
      if (!sortedHeaders.TryGetValue(xPos, out headers)){
        headers = new List<Header>();
        sortedHeaders[xPos] = headers;
      }
      headers.Add(new Header { XPos = xPos, Name = name });
    }
  }
}

Output:
1: Header_1
1: Header_2
2: Header_3

Bitte beachten Sie, dass das hinzufügen ein "lustiges" - Taste, wie das hinzufügen einer Zufallszahl oder vorgibt, dass 2 XPos mit dem gleichen Wert unterschiedlich sind, führen zu viele andere Probleme. Zum Beispiel wird es schwierig oder sogar unmöglich zu entfernen, die einen bestimmten Header.

Beachten Sie auch, dass die Sortier-Leistung ist viel besser, wenn nur wenige List<Header> werden sortiert als jeder Header. Beispiel: Wenn es 100 XPos und jeder hat 100 Header, 10000 Header müssen sortiert werden, im Gegensatz zu 100 List<Header>.

Natürlich, auch diese Lösung hat einen Nachteil: Wenn es viele XPos mit nur 1 Header, wie viele Listen erstellt werden müssen, ist ein gewisser Aufwand.

InformationsquelleAutor der Antwort Peter Huber

Dieser Sammlung Klasse halten Duplikaten und legen Sie die Sortierreihenfolge für das doppelte. Der trick: versehen Sie die Elemente mit einem eindeutigen Wert
Sie sind eingefügt, um eine stabile Sortierung um. Dann Verpacken wir es in eine
ICollection-Schnittstelle.

public class SuperSortedSet<TValue> : ICollection<TValue>
{
    private readonly SortedSet<Indexed<TValue>> _Container;
    private int _Index = 0;
    private IComparer<TValue> _Comparer;

    public SuperSortedSet(IComparer<TValue> comparer)
    {
        _Comparer = comparer;
        var c2 = new System.Linq.Comparer<Indexed<TValue>>((p0, p1) =>
        {
            var r = _Comparer.Compare(p0.Value, p1.Value);
            if (r == 0)
            {
                if (p0.Index == -1
                    || p1.Index == -1)
                    return 0;

                return p0.Index.CompareTo(p1.Index);

            }
            else return r;
        });
        _Container = new SortedSet<Indexed<TValue>>(c2);
    } 

    public IEnumerator<TValue> GetEnumerator() { return _Container.Select(p => p.Value).GetEnumerator(); }

    IEnumerator IEnumerable.GetEnumerator() { return GetEnumerator(); }

    public void Add(TValue item) { _Container.Add(Indexed.Create(_Index++, item)); }

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

    public bool Contains(TValue item) { return _Container.Contains(Indexed.Create(-1,item)); }

    public void CopyTo(TValue[] array, int arrayIndex)
    {
        foreach (var value in this)
        {
            if (arrayIndex >= array.Length)
            {
                throw new ArgumentException("Not enough space in array");
            }
            array[arrayIndex] = value;
            arrayIndex++;
        }
    }

    public bool Remove(TValue item) { return _Container.Remove(Indexed.Create(-1, item)); }

    public int Count {
        get { return _Container.Count; }
    }
    public bool IsReadOnly {
        get { return false; }
    }
}

einer test-Klasse

[Fact]
public void ShouldWorkWithSuperSortedSet()
{
    //Sort points according to X
    var set = new SuperSortedSet<Point2D>
        (new System.Linq.Comparer<Point2D>((p0, p1) => p0.X.CompareTo(p1.X)));

    set.Add(new Point2D(9,10));
    set.Add(new Point2D(1,25));
    set.Add(new Point2D(11,-10));
    set.Add(new Point2D(2,99));
    set.Add(new Point2D(5,55));
    set.Add(new Point2D(5,23));
    set.Add(new Point2D(11,11));
    set.Add(new Point2D(21,12));
    set.Add(new Point2D(-1,76));
    set.Add(new Point2D(16,21));

    var xs = set.Select(p=>p.X).ToList();
    xs.Should().BeInAscendingOrder();
    xs.Count.Should()
       .Be(10);
    xs.ShouldBeEquivalentTo(new[]{ -1,1,2,5,5,9,11,11,16,21});

    set.Remove(new Point2D(5,55));
    xs = set.Select(p=>p.X).ToList();
    xs.Count.Should()
       .Be(9);
    xs.ShouldBeEquivalentTo(new[]{ -1,1,2,5,9,11,11,16,21});

    set.Remove(new Point2D(5,23));
    xs = set.Select(p=>p.X).ToList();
    xs.Count.Should()
       .Be(8);
    xs.ShouldBeEquivalentTo(new[]{ -1,1,2,9,11,11,16,21});

    set.Contains(new Point2D(11, 11))
       .Should()
       .BeTrue();

    set.Contains(new Point2D(-1, 76))
        .Should().BeTrue();

    //Note that the custom compartor function ignores the Y value
    set.Contains(new Point2D(-1, 66))
        .Should().BeTrue();

    set.Contains(new Point2D(27, 66))
        .Should().BeFalse();

}

Die tagging-Struktur

public struct Indexed<T>
{
    public int Index { get; private set; }
    public T Value { get; private set; }
    public Indexed(int index, T value) : this()
    {
        Index = index;
        Value = value;
    }

    public override string ToString()
    {
        return "(Indexed: " + Index + ", " + Value.ToString () + " )";
    }
}

public class Indexed
{
    public static Indexed<T> Create<T>(int indexed, T value)
    {
        return new Indexed<T>(indexed, value);
    }
}

Lambda-comparer Helfer

public class Comparer<T> : IComparer<T>
{
    private readonly Func<T, T, int> _comparer;

    public Comparer(Func<T, T, int> comparer)
    {
        if (comparer == null)
            throw new ArgumentNullException("comparer");
        _comparer = comparer;
    }

    public int Compare(T x, T y)
    {
        return _comparer(x, y);
    }
}

InformationsquelleAutor der Antwort bradgonesurfing

Das problem ist, dass Sie so etwas wie der Schlüssel, der kein Schlüssel (Ursache es tritt mehrere Male).

Also, wenn Sie die realen Koordinaten sollten Sie vielleicht nehmen Sie die Punkt als Schlüssel für Ihre SortedList.

Oder erstellen Sie eine List<List<Header>> wo Sie Ihre erste Liste index legt die x-position und die innere-Liste-index der y-position (oder Umgekehrt, wenn Sie möchten).

InformationsquelleAutor der Antwort Oliver

Linq -.Lookup ist cool und alles, aber wenn Ihr Ziel ist es, einfach eine Schleife über die "keys", während so dass Sie dupliziert werden, können Sie diese Struktur verwenden:

List<KeyValuePair<String, String>> FieldPatterns = new List<KeyValuePair<string, string>>() {
   new KeyValuePair<String,String>("Address","CommonString"),
   new KeyValuePair<String,String>("Username","UsernamePattern"),
   new KeyValuePair<String,String>("Username","CommonString"),
};

Dann können Sie schreiben:

foreach (KeyValuePair<String,String> item in FieldPatterns)
{
   //use item.Key and item.Value
}

HTH

InformationsquelleAutor der Antwort michaelAngelo

Können Sie die SortedList ist, verwenden Sie Ihren Wert für die TKey, und int (count) für die TValue.

Hier ist ein Beispiel: Eine Funktion, sortiert die Buchstaben eines Wortes.

    private string sortLetters(string word)
    {
        var input = new System.Collections.Generic.SortedList<char, int>();

        foreach (var c in word.ToCharArray())
        {
            if (input.ContainsKey(c))
                input[c]++;
            else
                input.Add(c, 1);
        }

        var output = new StringBuilder();

        foreach (var kvp in input)
        {
            output.Append(kvp.Key, kvp.Value);
        }

        string s;

        return output.ToString();

    }

InformationsquelleAutor der Antwort Patrice Calvé