This article discusses both the IComparable and IComparer interfaces, for two reasons. These two interfaces are often used together. Although interfaces are similar and have similar names, they have different uses.
original:Use the IComparable and IComparer interfaces in Visual CSharp
This article describes how to use IComparer and IComparable interfaces in Visual C#.
summary
This article discusses both the IComparable and IComparer interfaces, for two reasons. These two interfaces are often used together. Although interfaces are similar and have similar names, they have different uses.
If you have an array of types that support IComparer (such as strings or integers), you can sort it without providing any explicit references to IComparer (translation notes: means passing an IComparer implementation class as a parameter to the sort method). In this case, the array element is converted to the default implementation of IComparer(). However, if you want to provide sorting or comparison capabilities for custom objects, you must implement one or both of these two interfaces.
This article references the Microsoft .NET Framework class library namespace.
IComparable interface
The function of the IComparable interface is to provide a method to compare two objects of a specific type. If you want to provide any sorting ability for your objects, then this is a must. IComparable can be considered as providing the default sorting order for your objects. For example, if you have an array of object type and then you call the Sort method on that array, the object comparison during sorting is provided by IComparable. When you implement the IComparable interface, you must implement the CompareTo method as follows:
// CompareTo method of IComparable provides default sorting.int (object obj)
{
Car c=(Car)obj;
return (,);
}How to compare in the CompareTo method depends on the data type of the value being compared. In this example, the method is used because the attribute selected for comparison is a string.
IComparer interface
The function of the IComparer interface is to provide more comparison mechanisms. For example, you might want to use multiple fields or attributes on the sort of your class, provide ascending and descending order on the same field, or both. (Translator's note, you must use the IComparer interface at this time.)
Using IComparer is a two-step process. First, declare a class that implements IComparer, and then implement the Compare method:
private class SortYearAscendingHelper : IComparer
{
int (object a, object b)
{
Car c1=(Car)a;
Car c2=(Car)b;
if ( > )
return 1;
if ( < )
return -1;
else
return 0;
}
}Notice:
The method requires a three-dimensional comparison. Returns 1, 0, or -1 based on whether one of the values is greater, equal to or less than the other. The sort order (ascending or descending) can be changed by toggling the logical operators in this method.
The second step is to declare a method that returns an instance of the IComparer object:
public static IComparer SortYearAscending()
{
return (IComparer) new SortYearAscendingHelper();
}In this example, the object is used as an overloaded method to which the second parameter is passed to accept the IComparer instance. The use of IComparer is not limited to arrays. It is accepted as a parameter by many different collections and control classes.
Step by step example:
The following example demonstrates how to use these interfaces. To demonstrate IComparer and IComparable, we created a class called Car that has two properties: Make and Year. Through the IComparable interface, ascending sorting is enabled for Make fields; through the IComparer interface, descending sorting is enabled for Make fields. By using IComparer, the Year attribute is provided with ascending and descending sorting.
1. Create a new Console Application project in Visual Studio and name it ConsoleEnum.
2. Rename it and replace the original code with the following code.
using System;
namespace ConsoleEnum
{
class host
{
[STAThread]
static void Main(string[] args)
{
// Create an array 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.
("Array - Unsorted\n");
foreach(Car c in arrayOfCars)
( + "\t\t" + );
// Demo IComparable by sorting array with "default" sort order.
(arrayOfCars);
("\nArray - Sorted by Make (Ascending - IComparable)\n");
foreach(Car c in arrayOfCars)
( + "\t\t" + );
// Demo ascending sort of numeric value with IComparer.
(arrayOfCars,());
("\nArray - Sorted by Year (Ascending - IComparer)\n");
foreach(Car c in arrayOfCars)
( + "\t\t" + );
// Demo descending sort of string value with IComparer.
(arrayOfCars,());
("\nArray - Sorted by Make (Descending - IComparer)\n");
foreach(Car c in arrayOfCars)
( + "\t\t" + );
// Demo descending sort of numeric value using IComparer.
(arrayOfCars,());
("\nArray - Sorted by Year (Descending - IComparer)\n");
foreach(Car c in arrayOfCars)
( + "\t\t" + );
();
}
}
}3. Add a new class to the project, named Car.
4. Replace the code in the following code.
using System;
using ;
namespace ConsoleEnum
{
public class Car : IComparable
{
// Beginning of nested classes.
// Nested class to do ascending sort on year property.
private class SortYearAscendingHelper: IComparer
{
int (object a, object b)
{
Car c1=(Car)a;
Car c2=(Car)b;
if ( > )
return 1;
if ( < )
return -1;
else
return 0;
}
}
// Nested class to do descending sort on year property.
private class SortYearDescendingHelper: IComparer
{
int (object a, object b)
{
Car c1=(Car)a;
Car c2=(Car)b;
if ( < )
return 1;
if ( > )
return -1;
else
return 0;
}
}
// Nested class to do descending sort on make property.
private class SortMakeDescendingHelper: IComparer
{
int (object a, object b)
{
Car c1=(Car)a;
Car c2=(Car)b;
return (,);
}
}
// 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 (object obj)
{
Car c=(Car)obj;
return (,);
}
// 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. Run the project. The Console window is displayed as follows:
Array - Unsorted
Ford 1992
Fiat 1988
Buick 1932
Ford 1932
Dodge 1999
Honda 1977Array - Sorted by Make (Ascending - IComparable)
Buick 1932
Dodge 1999
Fiat 1988
Ford 1932
Ford 1992
Honda 1977Array - Sorted by Year (Ascending - IComparer)
Ford 1932
Buick 1932
Honda 1977
Fiat 1988
Ford 1992
Dodge 1999Array - Sorted by Make (Descending - IComparer)
Honda 1977
Ford 1932
Ford 1992
Fiat 1988
Dodge 1999
Buick 1932Array - Sorted by Year (Descending - IComparer)
Dodge 1999
Ford 1992
Fiat 1988
Honda 1977
Buick 1932
Ford 1932
This is the end of this article about using IComparable and IComparer interfaces in C#. For more related contents of IComparable and IComparer interfaces, please search for my previous articles or continue browsing the related articles below. I hope everyone will support me in the future!