Comparison<T> 委托

定义

命名空间:

System

程序集:

System.Runtime.dll

程序集:

mscorlib.dll

程序集:

netstandard.dll

表示比较同一类型的两个对象的方法。

C#

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

C#

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

类型参数

T

要比较的对象的类型。

这是逆变类型参数。 即，可以使用指定的类型，也可以使用派生程度较低的任何类型。 有关协变和逆变的详细信息，请参阅泛型中的协变和逆变。

参数

x

T

要比较的第一个对象。

y

T

要比较的第二个对象。

返回值

Int32

一个有符号整数，指示 x 和 y 的相对值，如下表所示。

值	含义
小于 0	x 小于 y。
0	x 等于 y。
大于 0	x 大于 y。

示例

下面的代码示例演示如何将委托与Sort(Comparison<T>)方法重载配合使用Comparison<T>。

The code example defines an alternative comparison method for strings, named CompareDinosByLength. 此方法的工作原理如下：首先，比较器经过 null测试，并且 null 引用被视为小于非 null。 其次，比较字符串长度，较长的字符串被视为更大。 第三，如果长度相等，则使用普通字符串比较。

创建字符串并填充了四个 List<T> 字符串，没有特定顺序。 该列表还包括一个空字符串和一个 null 引用。 将显示列表，使用 Comparison<T> 表示 CompareDinosByLength 方法的泛型委托进行排序，并再次显示。

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"
 */

以下示例使用 Comparison<T> 委托对对象集合的 CityInfo 元素进行排序。 CityInfo 是一个应用程序定义的类，其中包含有关城市及其人口的信息。 该示例定义三种方法，CompareByName``CompareByPopulation以及CompareByNames三种不同方式对对象进行CityInfo排序。 每个方法都分配给 comparison 方法的参数 Array.Sort<T>(T[], Comparison<T>) 。

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

注解

此委托由 Sort<T>(T[], Comparison<T>) 类的方法重载 Array 和 Sort(Comparison<T>) 类的方法重载 List<T> 用于对数组或列表的元素进行排序。

扩展方法

GetMethodInfo(Delegate)

获取指示指定委托表示的方法的对象。

适用于

另请参阅

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