How to Use IComparer in C#: Simple Guide with Example

In C#, IComparer is an interface used to define custom sorting logic by implementing its Compare method. You create a class that implements IComparer, then pass an instance of this class to sorting methods like Array.Sort or List.Sort to control how items are ordered.

Syntax

The IComparer interface requires implementing the Compare method, which takes two objects and returns an integer indicating their order.

• int Compare(object x, object y): Returns a negative number if x is less than y, zero if they are equal, and a positive number if x is greater than y.

csharp

public class MyComparer : IComparer
{
    public int Compare(object x, object y)
    {
        // return negative if x < y
        // return zero if x == y
        // return positive if x > y
        return 0; // placeholder implementation
    }
}

Example

This example shows how to sort an array of integers in descending order by implementing IComparer and passing it to Array.Sort.

csharp

using System;
using System.Collections;

public class DescendingComparer : IComparer
{
    public int Compare(object x, object y)
    {
        int a = (int)x;
        int b = (int)y;
        // Reverse order: return positive if a < b
        if (a < b) return 1;
        if (a > b) return -1;
        return 0;
    }
}

class Program
{
    static void Main()
    {
        int[] numbers = { 5, 2, 8, 3, 1 };
        Array.Sort(numbers, new DescendingComparer());
        foreach (int num in numbers)
        {
            Console.Write(num + " ");
        }
    }
}

Output

8 5 3 2 1 

Common Pitfalls

Common mistakes when using IComparer include:

• Not casting objects to the correct type inside Compare, causing runtime errors.
• Returning incorrect values from Compare (e.g., always returning 1 or -1), which breaks sorting logic.
• Not handling null values, which can cause exceptions.

Always ensure your Compare method returns negative, zero, or positive correctly and safely casts inputs.

csharp

public class WrongComparer : IComparer
{
    public int Compare(object x, object y)
    {
        // Wrong: always returns 1, breaks sorting
        return 1;
    }
}

public class CorrectComparer : IComparer
{
    public int Compare(object x, object y)
    {
        int a = (int)x;
        int b = (int)y;
        return a.CompareTo(b); // Correct usage
    }
}

Quick Reference

IComparer Interface Quick Tips:

• Implement int Compare(object x, object y).
• Return <0 if x < y, 0 if equal, >0 if x > y.
• Use with Array.Sort or List.Sort to customize sorting.
• Handle nulls and type casting carefully.

Key Takeaways

Implement IComparer by defining the Compare method to control sorting order.

Compare must return negative, zero, or positive to indicate order correctly.

Pass your IComparer instance to sorting methods like Array.Sort or List.Sort.

Always cast objects safely and handle null values in Compare.

Incorrect Compare implementations can break sorting and cause runtime errors.