Extension Methods Exemplified: Sorting Index-based Generic Lists

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;


namespace Extensions
{
    /// <summary>
    /// Provides extension methods for sorting index-based generic lists.
    /// </summary>
    public static class SortingExtensionProvider
    {

        /// <summary>
        /// Applies the Bubble Sort algorithm to the list.
        /// </summary>
        /// <typeparam name="T">Type of the list elements which implements <c>IComparable</c>.</typeparam>
        /// <param name="list">An index-based generic list.</param>
        public static void Sort<T>(this IList<T> list) where T : IComparable
        {
            Sort(list, 0, list.Count - 1);
        }


        /// <summary>
        /// Applies the Bubble Sort algorithm to a range of elements of the list.
        /// </summary>
        /// <typeparam name="T">Type of the list elements which implements <c>IComparable</c>.</typeparam>
        /// <param name="list">An index-based generic list.</param>
        /// <param name="startIndex">Index of the first element of the range.</param>
        /// <param name="endIndex">Index of the last element of the range.</param>
        public static void Sort<T>(this IList<T> list, int startIndex, int endIndex) where T : IComparable
        {
            //Bubble Sort
            for (int i = startIndex; i < endIndex; i++)
                for (int j = endIndex; j > i; j--)
                    if (list[j].IsLesserThan(list[j - 1]))
                        list.Exchange(j, j - 1);
        }


        /// <summary>
        /// Exchanges two elements of the list.
        /// </summary>
        /// <typeparam name="T">Type of the list elements which implements <c>IComparable</c>.</typeparam>
        /// <param name="list">An index-based generic list.</param>
        /// <param name="index1">Index of the first element to be exchanged.</param>
        /// <param name="index2">Index of the second element to be exchanged.</param>
        private static void Exchange<T>(this IList<T> list, int index1, int index2)
        {
            T tmp = list[index1];
            list[index1] = list[index2];
            list[index2] = tmp;
        }


        /// <summary>
        /// Returns whether the value of an <c>IComparable</c> is lesser than the value of another.
        /// </summary>
        /// <param name="value">An object of a type that implements <c>IComparable</c>.</param>
        /// <param name="item">An object of a type that implements <c>IComparable</c>.</param>
        /// <returns></returns>
        private static bool IsLesserThan(this IComparable value, IComparable item)
        {
            return value.CompareTo(item) < 0;
        }
    }
}