How to sort an Array in C# | Array.Sort() Method Set – 2

Last Updated : 11 Jul, 2025

Array.Sort Method is used to sort elements in a one-dimensional array. There are 17 methods in the overload list of this method. Here we will discuss the following methods:

Sort(Array, Int32, Int32, IComparer) Method

Sort(Array, Array, Int32, Int32, IComparer) Method

Sort(Array, Int32, Int32) Method

Sort(Array, Array, Int32, Int32) Method

Sort(Array, Int32, Int32, IComparer) Method

This method sorts the elements in a range in a one-dimensional array using a specified IComparer.

Syntax: public static void Sort (Array arr, int start, int len, IComparer comparer); Parameters: "arr" :It is the one-dimensional array to sort. "start" : It is the starting index of the range to sort. "len" : It is the number of elements in the range to sort. "comparer" : It is the IComparer implementation to use when comparing elements or null to use the IComparable implementation of each element.

Exceptions:

ArgumentNullException: If the array is null.
RankException: If the array is multidimensional.
ArgumentOutOfRangeException if the start index is less than the lower bound of array or len is less than zero.
ArgumentException: If the start index and len does not specify a valid range in array or if the implementation of comparer caused an error during the sort.
InvalidOperationException: If comparer is null, and one or more elements in array do not implement the IComparable interface.

Example:

csharp

// C# program to demonstrate the use 
// of  Array.Sort(Array, Int32, Int32, 
// IComparer) method
using System;
using System.Collections;

class comparer : IComparer {

    // Call CaseInsensitiveComparer.Compare
    public int Compare(Object x, Object y)
    {
        return (new CaseInsensitiveComparer()).Compare(x, y);
    }
}

class GFG {

    // Main Method
    public static void Main()
    {
        // initialize a array.
        string[] arr = {"ABC", "GHI", "JKL",
                       "DEF", "MNO", "XYZ"};

        // Instantiate the reverse comparer.
        IComparer g = new comparer();

        // Display original values of the array.
        Console.WriteLine("The original order of "+
                          "elements in the array:");
        Display(arr);

        // Sort a section of the array
        // using the IComparer object
        // sorting happens in the range
        // of index 1 to 4
        // "g" is IComparer object
        Array.Sort(arr, 1, 4, g);
        
        Console.WriteLine("\nAfter sorting in a range of"+
             " index 1 to 4 using the IComparer object:");

        Display(arr);
    }

    // Display function
    public static void Display(string[] arr)
    {
        for (int i = arr.GetLowerBound(0); 
        i <= arr.GetUpperBound(0); i++) {

            Console.WriteLine(arr[i]);
        }
    }
}

Output:

The original order of elements in the array:
ABC
GHI
JKL
DEF
MNO
XYZ

After sorting in a range of index 1 to 4 using the IComparer object:
ABC
DEF
GHI
JKL
MNO
XYZ

Sort(Array, Array, Int32, Int32, IComparer) Method

This method sorts a range of elements in a pair of one-dimensional array objects based on the keys in the first Array using the specified IComparer. Here the objects contain the keys and the corresponding items.

Syntax: public static void Sort (Array key, Array items, int start, int len, IComparer comparer); Parameters: key: It is the one-dimensional array which contains the keys to sort. items: It is the one-dimensional array which contains the items that correspond to each of the keys in the keysArray(previous array). start: It is the starting index of the range to sort. len: It is the number of elements in the range to sort. comparer: It is the IComparer implementation to use when comparing elements or null to use the IComparable implementation of each element.

Exceptions:

ArgumentNullException: If the key is null.
RankException: If the keysArray is multidimensional.
ArgumentOutOfRangeException: If the start index is less than the lower bound of keys or len is less than zero.
ArgumentException:
- If the items is not null, and the lower bound of keys does not match the lower bound of items or
- If the items is not null, and the len of keys is greater than the length of items
- If the start index and len do not specify a valid range in the keysArray.
- If the items is not null, and start index and len do not specify a valid range in the itemsArray.
- If the implementation of comparer caused an error during the sort.
InvalidOperationException: If the comparer is null.

Example:

csharp

// C# program to demonstrate the use 
// of Array.Sort(Array, Array, Int32,
// Int32, IComparer) Method
using System;
using System.Collections;

class comparer : IComparer {

    // Call CaseInsensitiveComparer.Compare
    public int Compare(Object x, Object y)
    {
        return (new CaseInsensitiveComparer()).Compare(y, x);
    }
}

// Driver Class
class GFG {

    // Main Method
    public static void Main()
    {
        // initialize two Arrays
        String[] arr1 = {"H", "J", "K",
                   "L", "I", "N", "M"};

        String[] arr2 = {"A", "E", "D",
                   "C", "F", "B", "G"};

        // Instantiate the reverse comparer.
        IComparer g = new comparer();

        // Display original values of the array.
        Console.WriteLine("The original order of "+
                         "elements in the array:");

        Display(arr1, arr2);

        // Sort a section of the array 
        // using the IComparer object
        // sorting happens in the range
        // of index 1 to 4
        // "g" is IComparer object
        Array.Sort(arr1, arr2, 1, 4, g);
        
        Console.WriteLine("\nAfter sorting in a "+
                       "range of index 1 to 4 :");

        Display(arr1, arr2);
    }

    // Display function
    public static void Display(String[] arr1, String[] arr2)
    {
        for (int i = 0; i < arr1.Length; i++) 
        {
            Console.WriteLine(arr1[i] + " : " + arr2[i]);
        }
    }
}

Output:

The original order of elements in the array:
H : A
J : E
K : D
L : C
I : F
N : B
M : G

After sorting in a range of index 1 to 4 :
H : A
L : C
K : D
J : E
I : F
N : B
M : G

Sort(Array, Int32, Int32) Method

This method sorts the elements in a range in a one-dimensional array using the IComparable implementation of each element of the Array.

Syntax: public static void Sort (Array arr, int start, int len); Parameters: arr: It is the one-dimensional array to sort. start: It is the starting index of the range to sort. len: It is the number of elements in the range to sort.

Exceptions:

ArgumentNullException: If the array is null.
RankException: If the array is multidimensional.
ArgumentOutOfRangeException: If the start index is less than the lower bound of array or len is less than zero.
ArgumentException: If the start index and len does not specify a valid range in array.
InvalidOperationException: If the one or more elements in array do not implement the IComparable interface.

Example:

csharp

// C# program to demonstrate the use of
// Array.Sort(Array, Int32, Int32) method
using System;
using System.Collections;

class GFG {

    // Main Method
    public static void Main()
    {
        // initialize a array.
        string[] arr = {"ABC", "GHI", "JKL",
                       "DEF", "MNO", "XYZ"};

        // Display original values of the array.
        Console.WriteLine("The original order of"+
                       " elements in the array:");

        Display(arr);

        // sorting happens in the
        // range of index 1 to 4
        Array.Sort(arr, 1, 4);

        Console.WriteLine("\nAfter sorting in a range of "+
               "index 1 to 4 using the IComparer object:");

        Display(arr);
    }

    // Display function
    public static void Display(string[] arr)
    {
        for (int i = arr.GetLowerBound(0); 
        i <= arr.GetUpperBound(0); i++) {

            Console.WriteLine(arr[i]);
        }
    }
}

Output:

The original order of elements in the array:
ABC
GHI
JKL
DEF
MNO
XYZ

After sorting in a range of index 1 to 4 using the IComparer object:
ABC
DEF
GHI
JKL
MNO
XYZ

Sort(Array, Array, Int32, Int32) Method

This method sorts a range of elements in a pair of one-dimensional Array objects based on the keys in the first Array using the specified IComparer. Here the objects contain the keys and the corresponding items.

Syntax: public static void Sort (Array keys, Array items, int start, int len); Parameters: key: It is the one-dimensional array which contains the keys to sort. items: It is the one-dimensional array which contains the items that correspond to each of the keys in the keysArray(previous array). start: It is the starting index of the range to sort. len: It is the number of elements in the range to sort.

Exceptions:

ArgumentNullException: If the key is null.
RankException: If the keysArray is multidimensional or the itemsArray is multidimensional.
ArgumentOutOfRangeException: If the start index is less than the lower bound of keys or len is less than zero.
ArgumentException:
- If the items is not null, and the len of keys is greater than the length of items.
- If the start index and len do not specify a valid range in the keysArray.
- If the items is not null, and start index and len do not specify a valid range in the itemsArray.
- If the implementation of comparer caused an error during the sort.
InvalidOperationException: If one or more elements in the keysArray do not implement the IComparable interface.

Example:

csharp

// C# program to demonstrate the use of
// Array.Sort(Array, Int32, Int32, 
// IComparer) method
using System;
using System.Collections;

class comparer : IComparer {

    // Call CaseInsensitiveComparer.Compare
    public int Compare(Object x, Object y)
    {
        return (new CaseInsensitiveComparer()).Compare(y, x);
    }
}

// Driver Class
class GFG {

    // Main Method
    public static void Main()
    {
        // initialize two arrays
        String[] arr1 = {"H", "J", "K", 
                   "L", "I", "N", "M"};

        String[] arr2 = {"A", "E", "D",
                   "C", "F", "B", "G"};

        // Display original values of the array.
        Console.WriteLine("The original order of elements in the array:");
        Display(arr1, arr2);

        // sorting happens in the range of index 1 to 4
        Array.Sort(arr1, arr2, 1, 4);

        Console.WriteLine("\nAfter sorting in a "+
                       "range of index 1 to 4 :");

        Display(arr1, arr2);
    }

    // Display function
    public static void Display(String[] arr1, String[] arr2)
    {
        for (int i = 0; i < arr1.Length; i++) 
        {
            Console.WriteLine(arr1[i] + " : " + arr2[i]);
        }
    }
}

Output:

The original order of elements in the array:
H : A
J : E
K : D
L : C
I : F
N : B
M : G

After sorting in a range of index 1 to 4 :
H : A
I : F
J : E
K : D
L : C
N : B
M : G

Reference:

https://learn.microsoft.com/en-us/dotnet/api/system.array.sort?view=netframework-4.7.2

Introduction to .NET Framework

SoumikMondal

Improve

Article Tags :

How to sort an Array in C# | Array.Sort() Method Set – 2

Sort(Array, Int32, Int32, IComparer) Method

Sort(Array, Array, Int32, Int32, IComparer) Method

Sort(Array, Int32, Int32) Method

Sort(Array, Array, Int32, Int32) Method

Similar Reads

Introduction

Fundamentals

Control Statements

OOP Concepts

Methods

Arrays

ArrayList

String

Tuple

Indexers

Thank You!

What kind of Experience do you want to share?