List <> proprio operatore di confronto

Question

Ho una lista in cui elemento è:

struct element { 
       double priority; 
       int value; 
       } 

Come posso implementare il mio operatore di confronto che mi permetterà Ordina lista per priorità? Provo con SortredList ... ma non permetto chiavi douplicated :(

Un grande grazie per l'aiuto

Answer 1

Se non è possibile fare affidamento su C# 3 estensioni o lambda allora si può avere la struct implementi l'interfaccia IComparable, in questo modo:

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 
} 

ci sono anche un typesafe version di questa interfaccia, ma il principio è lo stesso

Dopo aver che interfaccia implementata sul vostro struct o classe, chiamando il metodo Sort su List<> sarà "solo lavoro"

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

Supponendo C# 3 o versione successiva:!

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

Answer 3

Se si desidera ordinare l'elenco per sé senza creare una nuova istanza, è possibile implementare IComparer, quindi chiamare list.sort con un'istanza dell'implementazione

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

Answer 4

È possibile eseguire una sorta sul posto utilizzando la Sort overload che prende un Comparison<T> delegato:

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

Per le versioni precedenti di C# avrete bisogno di scambiare la lambda per la vecchia scuola delegato sintassi:

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

Answer 5

Questo dipende se si desidera ordinare l'elenco stesso o recuperare i valori in ordine (senza modificare l'elenco).

Per ordinare l'elenco stesso (supponendo di avere un List<element> chiamato elements):

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

NET 2.0 equivalenti:

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

per ottenere i valori in modo ordinato:

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

Non c'è un equivalente LINQ in .NET 2.0, ma è possibile scrivere il proprio:

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; 
} 

Usage:

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);