Comparison<T> Délégué

Définition

Espace de noms:

System

Assembly:

System.Runtime.dll

Assembly:

mscorlib.dll

Assembly:

netstandard.dll

Représente la méthode qui compare deux objets du même type.

C#

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

C#

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

Paramètres de type

T

Type des objets à comparer.

Ce paramètre de type est contravariant. Cela signifie que vous pouvez utiliser le type spécifié ou tout type moins dérivé. Pour plus d’informations sur la covariance et la contravariance, consultez Covariance et contravariance dans les génériques.

Paramètres

x

T

Premier objet à comparer.

y

T

Deuxième objet à comparer.

Valeur renvoyée

Int32

Entier signé qui indique les valeurs relatives de x et y, comme indiqué dans le tableau suivant.

Value	Signification
Inférieure à 0	x est inférieur à y.
0	x est égal à y.
Supérieure à 0	x est supérieur à y.

Exemples

L’exemple de code suivant illustre l’utilisation du Comparison<T> délégué avec la Sort(Comparison<T>) surcharge de méthode.

L’exemple de code définit une autre méthode de comparaison pour les chaînes nommées CompareDinosByLength. Cette méthode fonctionne comme suit : Tout d’abord, les comparands sont testés pour null, et une référence null est traitée comme inférieure à une valeur non Null. Deuxièmement, les longueurs de chaîne sont comparées et la chaîne la plus longue est considérée comme supérieure. Troisièmement, si les longueurs sont égales, la comparaison de chaînes ordinaires est utilisée.

Une List<T> des chaînes est créée et remplie avec quatre chaînes, sans ordre particulier. La liste inclut également une chaîne vide et une référence null. La liste s’affiche, triée à l’aide d’un Comparison<T> délégué générique représentant la CompareDinosByLength méthode, puis affichée à nouveau.

C#

using System;
using System.Collections.Generic;

public class Example
{
    private static int CompareDinosByLength(string x, string y)
    {
        if (x == null)
        {
            if (y == null)
            {
                // If x is null and y is null, they're
                // equal.
                return 0;
            }
            else
            {
                // If x is null and y is not null, y
                // is greater.
                return -1;
            }
        }
        else
        {
            // If x is not null...
            //
            if (y == null)
                // ...and y is null, x is greater.
            {
                return 1;
            }
            else
            {
                // ...and y is not null, compare the
                // lengths of the two strings.
                //
                int retval = x.Length.CompareTo(y.Length);

                if (retval != 0)
                {
                    // If the strings are not of equal length,
                    // the longer string is greater.
                    //
                    return retval;
                }
                else
                {
                    // If the strings are of equal length,
                    // sort them with ordinary string comparison.
                    //
                    return x.CompareTo(y);
                }
            }
        }
    }

    public static void Main()
    {
        List<string> dinosaurs = new List<string>();
        dinosaurs.Add("Pachycephalosaurus");
        dinosaurs.Add("Amargasaurus");
        dinosaurs.Add("");
        dinosaurs.Add(null);
        dinosaurs.Add("Mamenchisaurus");
        dinosaurs.Add("Deinonychus");
        Display(dinosaurs);

        Console.WriteLine("\nSort with generic Comparison<string> delegate:");
        dinosaurs.Sort(CompareDinosByLength);
        Display(dinosaurs);
    }

    private static void Display(List<string> list)
    {
        Console.WriteLine();
        foreach( string s in list )
        {
            if (s == null)
                Console.WriteLine("(null)");
            else
                Console.WriteLine("\"{0}\"", s);
        }
    }
}

/* This code example produces the following output:

"Pachycephalosaurus"
"Amargasaurus"
""
(null)
"Mamenchisaurus"
"Deinonychus"

Sort with generic Comparison<string> delegate:

(null)
""
"Deinonychus"
"Amargasaurus"
"Mamenchisaurus"
"Pachycephalosaurus"
 */

L’exemple suivant utilise le Comparison<T> délégué pour trier les éléments d’une collection d’objets CityInfo . CityInfo est une classe définie par l’application qui contient des informations sur une ville et sa population. L’exemple définit trois méthodes, CompareByName, CompareByPopulationet CompareByNames, qui offrent trois façons différentes de classer les CityInfo objets. Chaque méthode est affectée à l’argument comparison de la Array.Sort<T>(T[], Comparison<T>) méthode.

C#

using System;

public class CityInfo
{
   string cityName;
   string countryName;
   int pop2010;

   public CityInfo(string name, string country, int pop2010)
   {
      this.cityName = name;
      this.countryName = country;
      this.pop2010 = pop2010;
   }

   public string City
   { get { return this.cityName; } }

   public string Country
   { get { return this.countryName; } }

   public int Population
   { get { return this.pop2010; } }

   public static int CompareByName(CityInfo city1, CityInfo city2)
   {
      return String.Compare(city1.City, city2.City);
   }

   public static int CompareByPopulation(CityInfo city1, CityInfo city2)
   {
      return city1.Population.CompareTo(city2.Population);
   }

   public static int CompareByNames(CityInfo city1, CityInfo city2)
   {
      return String.Compare(city1.Country + city1.City, city2.Country + city2.City);
   }
}

public class Example
{
   public static void Main()
   {
      CityInfo NYC = new CityInfo("New York City", "United States of America", 8175133 );
      CityInfo Det = new CityInfo("Detroit", "United States of America", 713777);
      CityInfo Paris = new CityInfo("Paris", "France",  2193031);
      CityInfo[] cities = { NYC, Det, Paris };
      // Display ordered array.
      DisplayArray(cities);

      // Sort array by city name.
      Array.Sort(cities, CityInfo.CompareByName);
      DisplayArray(cities);

      // Sort array by population.
      Array.Sort(cities, CityInfo.CompareByPopulation);
      DisplayArray(cities);

      // Sort array by country + city name.
      Array.Sort(cities, CityInfo.CompareByNames);
      DisplayArray(cities);
   }

   private static void DisplayArray(CityInfo[] cities)
   {
      Console.WriteLine("{0,-20} {1,-25} {2,10}", "City", "Country", "Population");
      foreach (var city in cities)
         Console.WriteLine("{0,-20} {1,-25} {2,10:N0}", city.City,
                           city.Country, city.Population);

      Console.WriteLine();
   }
}
// The example displays the following output:
//     City                 Country                   Population
//     New York City        United States of America   8,175,133
//     Detroit              United States of America     713,777
//     Paris                France                     2,193,031
//
//     City                 Country                   Population
//     Detroit              United States of America     713,777
//     New York City        United States of America   8,175,133
//     Paris                France                     2,193,031
//
//     City                 Country                   Population
//     Detroit              United States of America     713,777
//     Paris                France                     2,193,031
//     New York City        United States of America   8,175,133
//
//     City                 Country                   Population
//     Paris                France                     2,193,031
//     Detroit              United States of America     713,777
//     New York City        United States of America   8,175,133

Remarques

Ce délégué est utilisé par la surcharge de méthode Sort<T>(T[], Comparison<T>) de la Array classe et la Sort(Comparison<T>) surcharge de méthode de la List<T> classe pour trier les éléments d’un tableau ou d’une liste.

Méthodes d’extension

GetMethodInfo(Delegate)

Obtient un objet qui représente la méthode représentée par le délégué spécifié.

S’applique à

Voir aussi

• Sort<T>(T[], Comparison<T>)
• Sort(Comparison<T>)