0 out of 7 rated this helpful - Rate this topic

IComparer<T> Interface

Updated: June 2010

Defines a method that a type implements to compare two objects.

Namespace:  System.Collections.Generic
Assembly:  mscorlib (in mscorlib.dll)
public interface IComparer<in T>

Type Parameters

in T

The type of objects to compare.

This type parameter is contravariant. That is, you can use either the type you specified or any type that is less derived. For more information about covariance and contravariance, see Covariance and Contravariance in Generics.

The IComparer<T> type exposes the following members.

  Name Description
Public method Supported by the XNA Framework Supported by Portable Class Library Compare Compares two objects and returns a value indicating whether one is less than, equal to, or greater than the other.
Top

This interface is used with the List<T>.Sort and List<T>.BinarySearch methods. It provides a way to customize the sort order of a collection. Classes that implement this interface include the SortedDictionary<TKey, TValue> and SortedList<TKey, TValue> generic classes.

The default implementation of this interface is the Comparer<T> class. The StringComparer class implements this interface for type String.

This interface supports ordering comparisons. That is, when the Compare method returns 0, it means that two objects sort the same. Implementation of exact equality comparisons is provided by the IEqualityComparer<T> generic interface.

We recommend that you derive from the Comparer<T> class instead of implementing the IComparer<T> interface, because the Comparer<T> class provides an explicit interface implementation of the IComparer.Compare method and the Default property that gets the default comparer for the object.

The following example implements the IComparer<T> interface to compare objects of type Box according to their dimensions. This example is part of a larger example provided for the Comparer<T> class.


// This class is not demonstrated in the Main method
// and is provided only to show how to implement
// the interface. It is recommended to derive
// from Comparer<T> instead of implementing IComparer<T>.
public class BoxComp : IComparer<Box>
{
    // Compares by Height, Length, and Width.
    public int Compare(Box x, Box y)
    {
        if (x.Height.CompareTo(y.Height) != 0)
        {
            return x.Height.CompareTo(y.Height);
        }
        else if (x.Length.CompareTo(y.Length) != 0)
        {
            return x.Length.CompareTo(y.Length);
        }
        else if (x.Width.CompareTo(y.Width) != 0)
        {
            return x.Width.CompareTo(y.Width);
        }
        else
        {
            return 0;
        }
    }
}


.NET Framework

Supported in: 4, 3.5, 3.0, 2.0

.NET Framework Client Profile

Supported in: 4, 3.5 SP1

Portable Class Library

Supported in: Portable Class Library

Windows 7, Windows Vista SP1 or later, Windows XP SP3, Windows XP SP2 x64 Edition, Windows Server 2008 (Server Core not supported), Windows Server 2008 R2 (Server Core supported with SP1 or later), Windows Server 2003 SP2

The .NET Framework does not support all versions of every platform. For a list of the supported versions, see .NET Framework System Requirements.

Date

History

Reason

June 2010

Updated remarks and added example.

Information enhancement.

Did you find this helpful?
(1500 characters remaining)
Community Content Add
Annotations FAQ
Techincal notes on the contract
The IComparer<T> contract also requires that the comparison provide a persistent total order of all T. This means the following:
  • The comparison between two values must always give the same result if tested repeatedly. The comparison must not fail with an exception for any legal values, including nulls.
  • Compare(a, a) must be 0, so that a = a,
  • if a = b, then b = a,
  • if a < b, then b > a,
  • if a = b and b = c, then a = c,
  • if a < b and b < c, then a < c, and
  • if a < b and b = c, then a < c.
If any single one of these conditions is not met, the built-in sorting algorithms are allowed to fail in undocumented ways. In particular:
  • you may not scramble a list by having Compare return random values,
  • a comparer must be immutable, order cannot change during the life time of a comparer (persistence), and
  • mathematically weak orders — such as partially ordered sets — cannot be implemented using this interface.