IComparable, IComparer And IEquatable Interfaces In C#

public class Car  
{  
   public string Name { get; set; }  
   public int MaxSpeed { get; set; }  
}

public class Car: IComparable  
{  
    public string Name  
    {  
        get;  
        set;  
    }  
    public int MaxSpeed  
    {  
        get;  
        set;  
    }  
    public int CompareTo(object obj)  
    {  
        if (!(obj is Car))  
        {  
            throw new ArgumentException("Compared Object is not of car");  
        }  
        Car car = obj as Car;  
        return Name.CompareTo(car.Name);  
    }  
}

private static void Main(string[] args)  
{  
    Car[] cars = new Car[]  
    {  
        new Car()  
        {  
            Name = "Zinco"  
        }, new Car()  
        {  
            Name = "VW"  
        }, new Car()  
        {  
            Name = "BMW"  
        }  
    };  
    Array.Sort(cars);  
    Array.ForEach(cars, x => Console.WriteLine(x.Name));  
}

Output

IComparer interface

The CompareTo method from IComparable interface can sort on only one field at a time, so sorting on different properties with it is not possible. IComparer interface provides Compare method that Compares two objects and returns a value indicating whether one is less than, equal to, or greater than the other.

A class that implements the IComparer interface must provide a Compare method that compares two objects.

For example, you could create a CarComparer class that implements IComparer and that has a Compare method that com¬pares Car objects by Name. You could then pass a CarComparer object to the Array.Sort method, and it can use that object to sort an array of Car objects.

public class CarComparer: IComparer < Car >  
{  
    public enum SortBy  
    {  
        Name,  
        MaxSpeed  
    }  
    private SortBy compareField = SortBy.Name;  
    public int Compare(Car x, Car y)  
    {  
        switch (compareField)  
        {  
            case SortBy.Name:  
                return x.Name.CompareTo(y.Name);  
                break;  
            case SortBy.MaxSpeed:  
                return x.MaxSpeed.CompareTo(y.MaxSpeed);  
                break;  
            default:  
                break;  
        }  
        return x.Name.CompareTo(y.Name);  
    }  
}

At client side

private static void Main(string[] args)  
{  
    Car[] cars = new Car[]  
    {  
        new Car()  
        {  
            Name = "Zinco"  
        }, new Car()  
        {  
            Name = "VW"  
        }, new Car()  
        {  
            Name = "BMW"  
        }  
    };  
    var carComparer = new CarComparer();  
    carComparer.compareField = CarComparer.SortBy.MaxSpeed;  
    Array.Sort(cars, carComparer);  
}

Output

IEquatable Interface

If a class implements the IComparable interface, it provides a CompareTo method that enables you to determine how two objects should be ordered. Sometimes, you may not need to know how two objects should be ordered, but you need to know instead whether the objects are equal. The IEquatable interface provides that capability by requiring a class to provide an Equals method.

class Employee: IEquatable < Person >  
{  
    public string FirstName  
    {  
        get;  
        set;  
    }  
    public string LastName  
    {  
        get;  
        set;  
    }  
    public bool Equals(Employee other)  
    {  
        return ((FirstName == other.FirstName) && (LastName == other.LastName));  
    }  
}

At client

// The List of Persons.  
private List < Employee > Employees = new List < Employee > ();  
// Add a Person to the List.  
// Make the new Person.  
Employee emp = new Employee()  
{  
    FirstName = “James”  
    LastName = “Moore”  
};  
if (Employees.Contains(emp))  
{  
    MessageBox.Show("The list already contains this employee.");  
}