如何使用 Visual C# 中和 IComparer IComparable 接口

来源：互联网发布：大连知润信息编辑：程序博客网时间：2024/05/16 10:41

概要

本文介绍使用两个接口： IComparer 和 IComparable 。同一项目中讨论这些接口有两个原因。这些接口常用一起, 和虽然接口很相似（并具有类似名称), 它们提供不同用途。

如果有数组类型（如字符串或整数）已经支持 IComparer , 则不提供任何显式引用到 IComparer 可排序该数组。数组的元素此时, 都转换为 IComparer ( Comparer.Default ) 的默认实现对。但是, 如果要提供排序或比较功能对于您自定义对象, 必须实现任一或两个这些接口。

本文中引用 .NETFrameworkClassLibrary 下列命名空间：

System.Collections

IComparable

角色是 IComparable 是以提供方法来比较两个特定类型的对象。这是必需如果要为您对象提供任何排序功能。提供默认排序次序对您对象看作是 IComparable 。例如, 如果有对象的您类型, 数组并调用该数组, 上排序方法 IComparable 提供对象比较期间排序。当实现 IComparable 接口, 您必须实现 CompareTo 方法, 如下所示：

// Implement IComparable CompareTo method - provide default sort order.
int IComparable.CompareTo(object obj)
{
car c=(car)obj;
return String.Compare(this.make,c.make);
}

方法中比较是取决于正在进行比较，值数据类型不同。此示例中使用 String.Compare 因为属性是用于比较选择是字符串。

IComparer

角色的 IComparer 旨在提供其他比较机制。例如, 您可能希望提供排序是按几个字段或属性, 类升序和降序对同一字段, 或两者

使用 IComparer 是一个两步过程。首先, 声明类实现 IComparer , 并然后实现 Compare 方法：

private class sortYearAscendingHelper : IComparer
{
int IComparer.Compare(object a, object b)
{
car c1=(car)a;
car c2=(car)b;
if (c1.year > c2.year)
return 1;
if (c1.year < c2.year)
return -1;
else
return 0;
}
}

注意 IComparer.Compare 方法要求第三级比较。 1, 0 或 - 1 是返回根据一个值是大于、, 等于或小于另一个。通过此方法中切换逻辑运算符更改排序次序（升序或降序）。

第二步是要返回您 IComparer 对象的一个实例方法声明：

public static IComparer sortYearAscending()
{
return (IComparer) new sortYearAscendingHelper();
}

当调用重载 Array.Sort 方法接受 IComparer 在本示例, 对象用作第二个参数。使用 IComparer 不仅限于数组。它被接受多种不同集合和控件类中以参数形式。

分步示例

以下示例演示使用这些接口。为了演示 IComparer 和 IComparable , 创建一个名为汽车类。汽车对象具有使和年属性。有关通过 IComparable 接口, 启用使字段和通过 IComparer 接口启用对使字段降序排序升序排序。为通过使用的 IComparer 年属性提供了升序和降序排序。 1.Visual C#, 中新建控制台应用程序项目。名称 ConsoleEnum 应用程序。 2.命名作为 Host.cs, Class，然后用以下代码替换代码。

注意重作为 Host.cs 入 Visual Studio 2005, 命名 Program.cs。

using System;
            namespace ConsoleEnum
            {
            class host
            {
            [STAThread]
            static void Main(string[] args)
            {
            // Create an arary of car objects.
            car[] arrayOfCars= new car[6]
            {
            new car("Ford",1992),
            new car("Fiat",1988),
            new car("Buick",1932),
            new car("Ford",1932),
            new car("Dodge",1999),
            new car("Honda",1977)
            };
            // Write out a header for the output.
            Console.WriteLine("Array - Unsorted/n");
            foreach(car c in arrayOfCars)
            Console.WriteLine(c.Make + "/t/t" + c.Year);
            // Demo IComparable by sorting array with "default" sort order.
            Array.Sort(arrayOfCars);
            Console.WriteLine("/nArray - Sorted by Make (Ascending - IComparable)/n");
            foreach(car c in arrayOfCars)
            Console.WriteLine(c.Make + "/t/t" + c.Year);
            // Demo ascending sort of numeric value with IComparer.
            Array.Sort(arrayOfCars,car.sortYearAscending());
            Console.WriteLine("/nArray - Sorted by Year (Ascending - IComparer)/n");
            foreach(car c in arrayOfCars)
            Console.WriteLine(c.Make + "/t/t" + c.Year);
            // Demo descending sort of string value with IComparer.
            Array.Sort(arrayOfCars,car.sortMakeDescending());
            Console.WriteLine("/nArray - Sorted by Make (Descending - IComparer)/n");
            foreach(car c in arrayOfCars)
            Console.WriteLine(c.Make + "/t/t" + c.Year);
            // Demo descending sort of numeric value using IComparer.
            Array.Sort(arrayOfCars,car.sortYearDescending());
            Console.WriteLine("/nArray - Sorted by Year (Descending - IComparer)/n");
            foreach(car c in arrayOfCars)
            Console.WriteLine(c.Make + "/t/t" + c.Year);
            Console.ReadLine();
            }
            }
            }

3.向项目添加类。命名类汽车。 4.用下列替换代码 Car.cs 中：

using System;
            using System.Collections;
            namespace ConsoleEnum
            {
            public class car : IComparable
            {
            // Beginning of nested classes.
            // Nested class to do ascending sort on year property.
            private class sortYearAscendingHelper: IComparer
            {
            int IComparer.Compare(object a, object b)
            {
            car c1=(car)a;
            car c2=(car)b;
            if (c1.year > c2.year)
            return 1;
            if (c1.year < c2.year)
            return -1;
            else
            return 0;
            }
            }
            // Nested class to do descending sort on year property.
            private class sortYearDescendingHelper: IComparer
            {
            int IComparer.Compare(object a, object b)
            {
            car c1=(car)a;
            car c2=(car)b;
            if (c1.year < c2.year)
            return 1;
            if (c1.year > c2.year)
            return -1;
            else
            return 0;
            }
            }
            // Nested class to do descending sort on make property.
            private class sortMakeDescendingHelper: IComparer
            {
            int IComparer.Compare(object a, object b)
            {
            car c1=(car)a;
            car c2=(car)b;
            return String.Compare(c2.make,c1.make);
            }
            }
            // End of nested classes.
            private int year;
            private string make;
            public car(string Make,int Year)
            {
            make=Make;
            year=Year;
            }
            public int Year
            {
            get  {return year;}
            set {year=value;}
            }
            public string Make
            {
            get {return make;}
            set {make=value;}
            }
            // Implement IComparable CompareTo to provide default sort order.
            int IComparable.CompareTo(object obj)
            {
            car c=(car)obj;
            return String.Compare(this.make,c.make);
            }
            // Method to return IComparer object for sort helper.
            public static IComparer sortYearAscending()
            {
            return (IComparer) new sortYearAscendingHelper();
            }
            // Method to return IComparer object for sort helper.
            public static IComparer sortYearDescending()
            {
            return (IComparer) new sortYearDescendingHelper();
            }
            // Method to return IComparer object for sort helper.
            public static IComparer sortMakeDescending()
            {
            return (IComparer) new sortMakeDescendingHelper();
            }
            }
            }

5.运行项目。以下输出出现在控制台窗口：

Array - Unsorted
            Ford            1992
            Fiat            1988
            Buick           1932
            Ford            1932
            Dodge           1999
            Honda           1977
            Array - Sorted by Make (Ascending - IComparable)
            Buick           1932
            Dodge           1999
            Fiat            1988
            Ford            1932
            Ford            1992
            Honda           1977
            Array - Sorted by Year (Ascending - IComparer)
            Ford            1932
            Buick           1932
            Honda           1977
            Fiat            1988
            Ford            1992
            Dodge           1999
            Array - Sorted by Make (Descending - IComparer)
            Honda           1977
            Ford            1932
            Ford            1992
            Fiat            1988
            Dodge           1999
            Buick           1932
            Array - Sorted by Year (Descending - IComparer)
            Dodge           1999
            Ford            1992
            Fiat            1988
            Honda           1977
            Buick           1932
            Ford            1932