C# 中的 Icompare 接口和 IComparable 接口有啥区别??

Posted 2023-03-31

还有 Icompare<T> 接口和 IComparable<K,V> 接口有什么区别??

高手请多多指教,
谢谢!!
我还想问：
ICompare 可以实现一个类的不同属性之间的分类比较，而且IComparable也可以实现呀？
难道他们只是带的参数不同而已吗？？

参考技术A 似乎MSDN上是不太推荐使用ICompare的。

1、ICompare可以带两个参数，可以通过自己写enum或者switch等来实现一个类的不同属性之间的分类比较，对用户来说可以进行选择。它使用的是：IComparer.Compare

// IComparer impl.
int IComparer.Compare(object o1, object o2)

Car t1 = (Car)o1;
Car t2 = (Car)o2;
return String.Compare(t1.PetName, t2.PetName);


2、IComparable是system.collection 中默认的方法；使用CompareTo方法：

// IComparable implementation.
int IComparable.CompareTo(object o)

Car temp = (Car)o;
if(this.CarID > temp.CarID)
return 1;
if(this.CarID < temp.CarID)
return -1;
else
return 0;


3、但是在public class Car : IComparable时，sort方法只能是对一个Car属性进行排序（这是sort的默认方法，它有三个override方法），比如car有id和petName两个属性，此时只能选择一个来排序。而ICompare则可以通过写enum等代码来实现带参数的排序（参数为enum类型），参数指定了以id排序或者以petName排序。

不清楚为什么微软要写两个接口，干吗整合呢？继续学习它……

你看明白了吗？希望对你有帮助呀

ICompare接口

using System;
using System.Collections;
namespace ConsoleEnum
{
    public class car : IComparable
    {
        //  嵌套类的开始。

        // 按年升序
        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;
            }
        }

        // 按年降序
        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;
            }
        }

        // 按制造商字母降序
        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);
            }
        }

        // 嵌套类结束

        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; }
        }

        // 实现IComparable接口来提供默认的排序顺序的对比。
       // 将当前实例与同一类型的另一个对象进行比较，并返回一个整数，该整数指示当前实例在排序顺序中的位置是位于另一个对象之前、之后还是与其位置相同。
        int IComparable.CompareTo(object obj)
        {
            car c = (car)obj;
            return String.Compare(this.make, c.make);
        }

        // 返回排序辅助IComparer对象的方法。
        public static IComparer sortYearAscending()
        {
            return (IComparer)new sortYearAscendingHelper();
        }

        // 返回排序辅助IComparer对象的方法。
        public static IComparer sortYearDescending()
        {
            return (IComparer)new sortYearDescendingHelper();
        }

        // 返回排序辅助IComparer对象的方法。
        public static IComparer sortMakeDescending()
        {
            return (IComparer)new sortMakeDescendingHelper();
        }

    }
}

　　

 

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

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)
            };


            Console.WriteLine("Array - Unsorted\n");

            foreach (car c in arrayOfCars)
                Console.WriteLine(c.Make + "\t\t" + c.Year);

            // 演示时用“默认”排序的数组排序。
            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();
        }
    }
}