How to Implement Icomparable Interface

How to Implement IComparable interface?

You should not define IComparable yourself. It is already defined. Rather, you need to implement IComparable on your BankAccount class.

Where you defined the class BankAccount, make sure it implements the IComparable interface. Then write BankAccount.CompareTo to compare the balance amounts of the two objects.

public class BankAccount : IComparable<BankAccount>
{
    [...]

    public int CompareTo(BankAccount that)
    {
        if (this.Balance <  that.Balance) return -1;
        if (this.Balance == that.Balance) return 0;
        return 1;
    }
}

---

Edit to show Jeffrey L Whitledge's solution from comments:

public class BankAccount : IComparable<BankAccount>
{
    [...]

    public int CompareTo(BankAccount that)
    {
        return this.Balance.CompareTo(that.Balance);
    }
}

How to implement IComparable to all properties?

You need to add your own implementation to CompareTo(Match match) method
Something like:

public int CompareTo(object obj)
{
        Match match = obj as Match;
        if(match != null)
        {
            return (TeamHome == match.TeamHome
            && TeamAway == match.TeamAway
            && Result == match.Result
            && League.GetHashCode() == match.League.GetHashCode())
            ? 0 : -1;
        }
        return -1;   
}

And in your class declaration:
public class Match : IComparable
without the <Match>

But in this case i think it would make more sense to overload the Equals operator like this:

public override bool Equals(object other)
{
     Match match = other as Match;
     if(match != null)
     {
         return TeamHome == match.TeamHome
            && TeamAway == match.TeamAway
            && Result == match.Result
            && League.GetHashCode() == match.League.GetHashCode();
     }
     return false;
}

c# implement IComparable interface

You should not use exceptions as control flow mechanism in expected cases and because of that first option is better.

You should also consider implementing generic IComparable<Temperature> instead of non-generic IComparable:

public class Temperature : IComparable<Temperature>
{
    // The temperature value
    protected double temperatureF;

    public int CompareTo(Temperature otherTemperature) {
        if (otherTemperature == null) return 1;

        return this.temperatureF.CompareTo(otherTemperature.temperatureF);
    }

Implementing the IComparable Interface

You could implement IComparable implicitly, yes. But fundamentally you want to try to discourage users from comparing a Note with anything other than another Note. You may have legacy usages if IComparable, but if anything knows about the Note class directly, you don't want to allow:

Note note = new Note();
Other other = new Other();
int result = note.CompareTo(other);

You know that that's always going to throw an exception, so why allow it at all? Basically, regard the non-generic IComparable interface as "somewhat legacy" (there are valid uses, but...) and discourage anyone from using it by implementing it explicitly.

How do I use the IComparable interface?

Well, since you are using List<T> it would be a lot simpler to just use a Comparison<T>, for example:

List<Foo> data = ...
// sort by name descending
data.Sort((x,y) => -x.Name.CompareTo(y.Name));

Of course, with LINQ you could just use:

var ordered = data.OrderByDescending(x=>x.Name);

But you can re-introduce this in List<T> (for in-place re-ordering) quite easily; Here's an example that allows Sort on List<T> with lambda syntax:

using System;
using System.Collections.Generic;  

class Foo { // formatted for vertical space
    public string Bar{get;set;}
}
static class Program {
    static void Main() {
        List<Foo> data = new List<Foo> {
            new Foo {Bar = "abc"}, new Foo {Bar = "jkl"},
            new Foo {Bar = "def"}, new Foo {Bar = "ghi"}
        };
        data.SortDescending(x => x.Bar);
        foreach (var row in data) {
            Console.WriteLine(row.Bar);
        }
    }

    static void Sort<TSource, TValue>(this List<TSource> source,
            Func<TSource, TValue> selector) {
        var comparer = Comparer<TValue>.Default;
        source.Sort((x,y)=>comparer.Compare(selector(x),selector(y)));
    }
    static void SortDescending<TSource, TValue>(this List<TSource> source,
            Func<TSource, TValue> selector) {
        var comparer = Comparer<TValue>.Default;
        source.Sort((x,y)=>comparer.Compare(selector(y),selector(x)));
    }
}

How do I implement IComparable T ?

One way of achieving this, is to require the elements of your list to be comparable, i.e. have them implement the IComparable interface. You would express this using a generic type constraint on T, as in:

public class SortedSinglyLinkedList<T> : where T : IComparable 

A more general way of doing this, that also allows your list to contain elements that do not implement this IComparable interface, is to follow the strategy used in many of the c# BCL generic collection classes (e.g. SortedDictionary or SortedList): use an IComparer instance to perform the comparisons.

public class SortedSinglyLinkedList<T>
{
    private readonly IComparer<T> _comparer;

    // ...

    public SortedSinglyLinkedList()
    {
        _comparer = Comparer<T>.Default; // use the default.
        // ...
    }

    public SortedSinglyLinkedList(IComparer<T> comparer)
    {
        _comparer = comparer ?? Comparer<T>.Default;
        // ...
    }
}

And in your Sort method, use this comparer instance to perform the comparisons:

_comparer.Compare(get(i), get(j));

iComparable Interface Workings

The reason .NET could not "just" sort your Customer objects is because it has no way of guessing in what way you want to sort them: by salary, by first name, by last name, by the time they placed their first order, etc.

However, you can make it work without implementing IComparable in three different ways:

• Pass a separate IComparer<Customer> implementation - this lets you move comparison logic to a separate class, and apply different comparison logics based on a situation.
• Pass a Comparison<Customer> delegate - same as above, but now you don't need a separate class; this lets you provide comparison logic in a lambda.
• Use LINQ's OrderBy instead - Similar to above, but gives you additional capabilities (filtering, projecting, grouping, etc.)

Implementing IComparable T Interface for a generic class to compare type T

The reason why you are getting this error is that you cannot use inequality operators ("<", ">") with IComparable, unless you override them.

You can use CompareTo() instead.

public class Mystack<T> : IComparable<Mystack<T>> where T : IComparable
{
public T[] stack = new T[2];

public int CompareTo(Mystack<T> other)
{
    // If the current stack < other stack return -1
    // If the current stack > other stack return +1
    // If current stack entries == other stack entries return 0
    for (var current = 0; current < 2; current++)
    {
        if (stack[current].CompareTo(other.stack[current]) < 0)
        {
            return -1;
        }
        else if (stack[current].CompareTo(other.stack[current]) > 0)
        {
            return 1;
        }
    }
    return 0;
}

implementing the IComparable Interface on two string fields

Or you could sort a list like this:

myPersonList.Sort(delegate(Person p1, Person p2)
{
    int result = p1.Surname.CompareTo(p2.Surname);
    if (result == 0)
        result = p1.Forname.CompareTo(p2.Forname);
    return result;
});

Alternatively you could have Person implement IComparable<Person> with this method:

public int CompareTo(Person other)
{
    int result = this.Surname.CompareTo(other.Surname);
    if (result == 0)
        result = this.Forname.CompareTo(other.Forname);
    return result;
}

EDIT As Mark commented, you might decide you need to check for nulls. If so, you should decide whether nulls should be sorted to the top or bottom. Something like this:

if (p1==null && p2==null)
    return 0; // same
if (p1==null ^ p2==null)
    return p1==null ? 1 : -1; // reverse this to control ordering of nulls

---

Related Topics