System.Comparison <T> compréhension

Question

List<T>.Sort() La méthode comporte 3 surcharges.

L'un d'eux est le suivant

System.Collections.Generic.List<T>.Sort(System.Comparison<T>) 

En voyant Comparison<T>, je pensais que ce devrait être une classe qui est dérivée de Comparison<T> classe. (Une interprétation habituelle sur les paramètres)

Mais ce qui suit fonctionne très bien et dit d'utiliser la surcharge ci-dessus.

 public static void Main(string[] args) 
     { 
      List<Int32> collection = new List<Int32>(); 

      collection.Add(20); 
      collection.Add(270); 
      collection.Add(30); 
      collection.Add(90); 
      collection.Add(40); 
      collection.Add(18); 
      collection.Add(100); 

      collection.Sort(MyComparer.CompareWithCase); 

      foreach (Int32 s in collection) 
       Console.WriteLine(s); 
     } 

     public static int CompareWithCase(int i1, int i2) 
     { 
      return i1.ToString().CompareTo(i2.ToString()); 
     } 

Je donne un délégué a fait à une méthode statique à la place de Comparison<T>. Comment ça marche?

Answer 1

System.Comparison<T> est défini comme suit:

public delegate int Comparison<in T>(T x, T y); 

Cela signifie que c'est delegate , pas une classe. Une méthode acceptant un délégué en tant que paramètre accepte réellement une méthode, pas une instance d'une classe de comparaison.

Ce code peut être réécrite comme suit avec une expression lambda:

collection.Sort((i1, i2) => i1.ToString().CompareTo(i2.ToString())); 

L'extrait suivant pourrait mieux expliquer ce qui se passe:

public static class TestClass { 

    public static void Main(string[] args){ 
     Comparison<Int32> comparisonDelegate = CompareWithCase; 
     //We now can use comparisonDelegate as though it is a method; 
     int result = comparisonDelegate(1,2); 
    } 

    public static int CompareWithCase(int i1, int i2) 
    { 
    return i1.ToString().CompareTo(i2.ToString()); 
    } 
} 

Answer 2

System.Comparison<T>est un délégué.

public delegate int Comparison<in T>(
    T x, 
    T y 
) 

La signature de votre méthode CompareWithCase fait parfaitement assignable à Comparison<int>.

Notez que sans type inférences, votre Sort appel aurait dû être écrit:

collection.Sort(new Comparison<int>(MyComparer.CompareWithCase)); 

Pour votre information, les 2 autres surcharges de List<T>.Sort attendent IComparer<T> implémentations