List <> eigene comparer

Question

Ich habe eine Liste, wo Element ist:

struct element { 
       double priority; 
       int value; 
       } 

Wie kann ich meine eigenen comparer implementieren, die mich Liste sortieren nach Priorität zulassen? Ich versuche, mit SortredList ... aber es nicht zulassen, dass douplicated Schlüssel :(

Vielen Dank für die Hilfe

Answer 1

Wenn Sie nicht verlassen können C# 3 Erweiterungen oder Lambdas dann können Sie Ihre Struktur die IComparable-Schnittstelle implementieren, etwa so:

struct element : IComparable 
{ 
    double priority; 
    int value; 
    public element(int val, double prio) 
    { 
     priority = prio; 
     value = val; 
    } 
    #region IComparable Members 

    public int CompareTo(object obj) 
    { 
     // throws exception if type is wrong 
     element other = (element)obj; 
     return priority.CompareTo(other.priority); 
    } 

    #endregion 
} 

Es gibt auch eine typesafe version dieser Schnittstelle, aber das Prinzip ist das gleiche

Nachdem Sie die Schnittstelle auf Ihrer Struktur oder Klasse implementiert haben, auf List<> die Sort Methode aufrufen wird „funktionieren“

static void Main(string[] args) 
{ 
    Random r = new Random(); 
    List<element> myList = new List<element>(); 
    for (int i = 0; i < 10; i++) 
     myList.Add(new element(r.Next(), r.NextDouble())); 
    // List is now unsorted 
    myList.Sort(); 
    // List is now sorted by priority 
    Console.ReadLine(); 
} 

Answer 2

Unter der Annahme, C# 3 oder höher:

var sorted = MyList.OrderBy(e => e.priority); 

Answer 3

Wenn Sie die Liste sortieren möchten ohne selbst eine neue Instanz zu erstellen, können Sie IComparer implementieren, rufen Sie dann List.Sort mit einer Instanz der Implementierung

public class ElementComparer : IComparer<element> 
{ 
    public int Compare(element x, element y) 
    { 
     throw new NotImplementedException(); 
    } 
} 

Answer 4

Sie können eine direkte Art durchführen, indem Sie die Sort overload, die eine Comparison<T> Delegierte nimmt:

yourList.Sort((x, y) => x.priority.CompareTo(y.priority)); 

Für ältere Versionen von C# müssen Sie die Lambda für Old-School-Delegat Syntax auszulagern:

yourList.Sort(
    delegate(element x, element y) { return x.priority.CompareTo(y.priority); }); 

Answer 5

Dies, wenn Sie hängt davon ab, möchte die Liste selbst sortieren oder die Werte in sortierter Reihenfolge abrufen (ohne die Liste zu ändern).

Um die Liste zu sortieren selbst (vorausgesetzt Sie haben eine List<element> genannt elements):

elements.Sort((x, y) => x.priority.CompareTo(y.priority)); 
// now elements is sorted 

.NET 2.0-Äquivalent:

elements.Sort(
    delegate(element x, element y) { 
     return x.priority.CompareTo(y.priority); 
    } 
); 

Um die Werte in sortierter Reihenfolge zu erhalten:

var orderedElements = elements.OrderBy(x => x.priority); 
// elements remains the same, but orderedElements will retrieve them in order 

Es gibt keine LINQ-Entsprechung in .NET 2.0, aber Sie können Ihre eigenen schreiben:

public static IEnumerable<T> OrderBy<T>(IEnumerable<T> source, Comparison<T> comparison) { 
    List<T> copy = new List<T>(source); 
    copy.Sort(comparison); 

    foreach (T item in copy) 
     yield return item; 
} 

Verbrauch:

Comparison<element> compareByPriority = delegate(element x, element y) { 
    return x.priority.CompareTo(y.priority); 
}; 

// unfortunately .NET 2.0 doesn't support extension methods, so this has to be 
// expressed as a regular static method 
IEnumerable<element> orderedElements = OrderBy(elements, compareByPriority);