Używanie programu IComparer do sortowania

Question

Próbuję posortować listę punktów za pomocą IComparer. Oto klasa IComparer:

public class CoordinatesBasedComparer : IComparer 
{ 
    public int Compare(Object q, Object r) 
    { 
     Point a = (p)q; 
     Point b = (p)r; 
     if ((a.x == b.x) && (a.y == b.y)) 
      return 0; 
     if ((a.x < b.x) || ((a.x == b.x) && (a.y < b.y))) 
      return -1; 

     return 1; 
    } 
} 

W kodzie klienta, staram się korzystania z tej klasy do sortowania listę punktów p (typu List<Point>):

CoordinatesBasedComparer c = new CoordinatesBasedComparer(); 
Points.Sort(c); 

błędów kodu na zewnątrz. Wygląda na to, że oczekuje się, że metoda sortowania będzie miała postać IComparer<Point>.
Co muszę zrobić, aby to naprawić?

Answer 1

Należy zaimplementować interfejs typu mocno (MSDN).

public class CoordinatesBasedComparer : IComparer<Point> 
{ 
    public int Compare(Point a, Point b) 
    { 
     if ((a.x == b.x) && (a.y == b.y)) 
      return 0; 
     if ((a.x < b.x) || ((a.x == b.x) && (a.y < b.y))) 
      return -1; 

     return 1; 
    } 
} 

BTW, myślę, że używasz zbyt wiele nawiasów klamrowych, uważam, że powinny być używane tylko wtedy, gdy przyczyniają się do kompilatora. To jest moja wersja:

if (a.x == b.x && a.y == b.y) 
    return 0; 
if (a.x < b.x || (a.x == b.x && a.y < b.y)) 
    return -1; 

Tak jak nie lubię ludzi używających return (0).

---

Zauważ, że jeśli kierować .Net 3.5 + aplikacji można użyć LINQ, który jest łatwiejszy i jeszcze szybciej z sortowania.

LINQ Vesion może być coś takiego:

var orderedList = Points.OrderBy(point => point.x) 
         .ThenBy(point => point.y) 
         .ToList(); 

Answer 2

public class CoordinatesBasedComparer : IComparer, IComparer<Point> 
{ 
    public int Compare(Point a, Point b) 
    { 
     if ((a.x == b.x) && (a.y == b.y)) 
      return 0; 
     if ((a.x < b.x) || ((a.x == b.x) && (a.y < b.y))) 
      return -1; 

     return 1; 
    } 
    int IComparer.Compare(Object q, Object r) 
    { 
     return Compare((Point)q, (Point)r);    
    } 
} 

Answer 3

ja otrzymuję błąd InvalidOperation dodając obiekt typu MyClass do SortedList<MyClass>. Niepoprawnie implementowałem interfejs IComparer. To, co musiałem wdrożyć, było porównywalne z metodą CompareTo (MyClass other), zamiast z ICompare.Compare (MyClass x, MyClass y). Ten uproszczony przykład:

SortedList<MyClass> sortedList = new SortedList<MyClass>(); 
MyClass a=new MyClass(), b=new MyClass(); 
sortedList.Add(a); 
sortedList.Add(b); // Note, sort only happens once second element is added 

Ten poprawiony:

public class MyClass : IComparable<MyClass> 
{ 
    int IComparable<MyClass>.CompareTo(MyClass other) 
    { 
     // DoCompareFunction(this, other); and return -1,0,1 
    } 
} 

ten był uszkodzony (nie należy tego dokonać przy dodawaniu do SortedList<MyClass>):

public class MyClass : IComparer<MyClass> 
{ 
    int IComparable<MyClass>.Compare(MyClass x, MyClass y) 
    { 
     // DoCompareFunction(x, y); and return -1,0,1 
    } 
} 

To był błąd:

Failed to compare two elements in the array.
at System.Collections.Generic.ArraySortHelper`1.BinarySearch(T[] array, Int32 index, Int32 length, T value, IComparer`1 comparer)
at System.Array.BinarySearch[T](T[] array, Int32 index, Int32 length, T value, IComparer`1 comparer)
at System.Collections.Generic.SortedList`2.Add(TKey key, TValue value)

Answer 4

Jeśli jesteś powolny jak ja, wartości -1 i 1 mogą być trudne do zrozumienia, gdy używasz IComparer. Sposób myślenia o tym, kiedy x powinien iść pierwszy, zwraca -1. Gdy y powinien pójść pierwszy, zwróć 1.

Może nadal być mylące, jeśli masz dużo pól do sortowania. Możesz użyć wartości Enum, aby logika porównania stała się bardziej czytelna niż 1 i -1, a następnie rzuć wynik.

W tym przykładzie umieszcza się obiekty z najmniejszą liczbą pustych pól z przodu.

public class NullishObjectsToTheBackOfTheLine: IComparer<ClassToCompare> 
{ 
    private enum Xy 
    { 
     X = -1, 
     Both = 0, 
     Y = 1 
    }; 

    //the IComparer implementation wraps your readable code in an int cast. 
    public int Compare(ClassToCompare x, ClassToCompare y) 
    { 
     return (int) CompareXy(x, y); 
    } 

    private static Xy CompareXy(ClassToCompare x, ClassToCompare y) 
    { 
     if (x == null && y == null) return Xy.Both; 

     //put any nulls at the end of the list 
     if (x == null) return Xy.Y; 
     if (y == null) return Xy.X; 

     if (x.Country == y.Country && x.ProductId == y.ProductId) return Xy.Both; 

     //put the least amount of at the front 
     if (x.ProductId == null && x.Country == null) return Xy.Y; 
     if (y.ProductId == null && y.Country == null) return Xy.X; 

     //put the country values that are not nulls in front 
     if (x.Country != y.Country) return x.Country != null ? Xy.X : Xy.Y; 

     //if we got this far, one of these has a null product id and the other doesn't 
     return x.ProductId != null ? Xy.X : Xy.Y; 
    } 

} 

public class ClassToCompare 
{ 
    public string Country { get; set; } 
    public string ProductId { get; set; } 
}