C# .NET: Comparaison décroissante d'un SortedDictionary?

Question

Je veux un IDictionary<float, foo> qui retourne les grandes valeurs de la clé en premier.

private IDictionary<float, foo> layers = new SortedDictionary<float, foo>(new DescendingComparer<float>()); 

class DescendingComparer<T> : IComparer<T> where T : IComparable<T> 
{ 
    public int Compare(T x, T y) 
    { 
     return -y.CompareTo(x); 
    } 
} 

Cependant, ceci renvoie des valeurs dans l'ordre du plus petit premier. J'ai l'impression de faire une erreur stupide ici.

Juste pour voir ce qui se passerait, je l'ai enlevé le signe - du comparateur:

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

Mais j'ai eu le même résultat. Cela renforce mon intuition que je fais une erreur stupide.

C'est le code qui accède au dictionnaire:

foreach (KeyValuePair<float, foo> kv in sortedLayers) 
{ 
    // ... 
} 

MISE À JOUR: Cela fonctionne, mais il est trop lent à appeler aussi souvent que je dois appeler cette méthode:

IOrderedEnumerable<KeyValuePair<float, foo>> sortedLayers = layers.OrderByDescending(kv => kv.Key); 
foreach (KeyValuePair<float, ICollection<IGameObjectController>> kv in sortedLayers) { 
    // ... 
} 

MISE À JOUR: Je mets un point de rupture dans le comparateur qui ne sera jamais atteint car j'ajoute et retire des paires de kv du dictionnaire. Qu'est-ce que cela pourrait signifier?

Answer 1

Pour ordre décroissant (valeurs les plus élevées en premier), vous feriez -x.CompareTo(y)

Answer 2

essayer:

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

Answer 3

Dans cette ligne, le commutateur x et y:

return -y.CompareTo(x); 

Make it

return -x.CompareTo(y);