Comparison(T) Délégué
TOC
Réduire la table des matières
Développer la table des matières
Cet article a fait l'objet d'une traduction automatique. Déplacez votre pointeur sur les phrases de l'article pour voir la version originale de ce texte. Informations supplémentaires.
Traduction
Source

Comparison<T>, délégué

 

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

Espace de noms:   System
Assembly:  mscorlib (dans mscorlib.dll)

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

Paramètres

x
Type: T

Premier objet à comparer.

y
Type: T

Second objet à comparer.

Valeur de retour

Type: System.Int32

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

Valeur

Signification

Inférieure à 0

x est inférieur à y.

0

x est égal à y.

Supérieure à 0

x est supérieur à y.

Paramètres de type

in T

Type des objets à comparer.

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

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

L'exemple de code définit une autre méthode de comparaison des chaînes, nommée CompareDinosByLength.Cette méthode fonctionne comme suit : en premier lieu, les comparateurs sont testés pour la valeur 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 plus longue chaîne est jugée supérieure.Troisièmement, si les longueurs sont égales, la comparaison de chaînes ordinaire est utilisée.

Un List<T> de chaînes est créé et rempli avec quatre chaînes, dans aucun ordre particulier.La liste inclut également une chaîne vide et une référence null.La liste est affichée, triée à l'aide d'un délégué générique Comparison<T> représentant la méthode CompareDinosByLength, puis de nouveau affichée.

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 délégué Comparison<T> 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, CompareByPopulation, CompareByNames, qui proposent trois moyens différents de classer les objets CityInfo.Chaque méthode est assignée à l'argument comparison de la méthode Array.Sort<T>(T[], Comparison<T>).

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

Universal Windows Platform
Disponible depuis 4.5
.NET Framework
Disponible depuis 2.0
Portable Class Library
Pris en charge dans : portable .NET platforms
Silverlight
Disponible depuis 2.0
Windows Phone Silverlight
Disponible depuis 7.0
Windows Phone
Disponible depuis 8.1
Retour au début
Afficher:
© 2016 Microsoft