How to sort an Array in C# | Array.Sort() Method Set - 1 - GeeksforGeeks

10 May, 2019
Array.Sort Method is used to sort elements in a one-dimensional array. There are 17 methods in the overload list of this method as follows:
Sort<T>(T[]) MethodSort<T>(T[], IComparer<T>) MethodSort<T>(T[], Int32, Int32) MethodSort<T>(T[], Comparison<T>) MethodSort(Array, Int32, Int32, IComparer) MethodSort(Array, Array, Int32, Int32, IComparer) MethodSort(Array, Int32, Int32) MethodSort(Array, Array, Int32, Int32) MethodSort(Array, IComparer) MethodSort(Array, Array, IComparer) MethodSort(Array, Array) MethodSort(Array) MethodSort<T>(T[], Int32, Int32, IComparer<T>) MethodSort<TKey,TValue>(TKey[], TValue[]) MethodSort<TKey,TValue>(TKey[], TValue[], IComparer<TKey>) MethodSort<TKey,TValue>(TKey[], TValue[], Int32, Int32) MethodSort<TKey,TValue>(TKey[], TValue[], Int32, Int32, IComparer<TKey>) Method
Sort<T>(T[]) Method
Sort<T>(T[], IComparer<T>) Method
Sort<T>(T[], Int32, Int32) Method
Sort<T>(T[], Comparison<T>) Method
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, IComparer) Method
Sort(Array, Array, IComparer) Method
Sort(Array, Array) Method
Sort(Array) Method
Sort<T>(T[], Int32, Int32, IComparer<T>) Method
Sort<TKey,TValue>(TKey[], TValue[]) Method
Sort<TKey,TValue>(TKey[], TValue[], IComparer<TKey>) Method
Sort<TKey,TValue>(TKey[], TValue[], Int32, Int32) Method
Sort<TKey,TValue>(TKey[], TValue[], Int32, Int32, IComparer<TKey>) Method
Here we will discuss the first 4 methods.
This method sorts the elements in an Array using the IComparable<T> generic interface implementation of each element of the Array.
Syntax: public static void Sort<T> (T[] array);
Parameter:array: It is the one dimensional, zero-based Array which is to be sorted.
Exceptions:
ArgumentNullException: If the array is null.
InvalidOperationException: If one or more elements in the array do not implement the IComparable<T> generic interface.
Example:
// C# Program to illustrate the use // of the Array.Sort<T>(T[]) Methodusing System;using System.Collections.Generic;  class GFG {      // Main Method    public static void Main()    {        // array elements        string[] arr = new string[5] { "A",                       "D", "X", "G", "M" };          foreach(string g in arr)        {            Console.WriteLine(g);            // display original array        }          Console.WriteLine("\nAfter Sort:");        Array.Sort(arr);          foreach(string g in arr)        {            Console.WriteLine(g);            // display sorted array        }          Console.WriteLine("\nB sorts between :");          // binary Search for "B"        int index = Array.BinarySearch(arr, "B");          // call "sortT" function        // which is the Sort<T>(T[]) function        sortT(arr, index);                  Console.WriteLine("\nF sorts between :");        index = Array.BinarySearch(arr, "F");        sortT(arr, index);    }      public static void sortT<T>(T[] arr, int index)    {          // If the index is negative,         // it represents the bitwise        // complement of the next larger         // element in the array.        if (index < 0) {                          index = ~index;              if (index == 0)                Console.Write("beginning of array");            else                Console.Write("{0} and ", arr[index - 1]);              if (index == arr.Length)                Console.WriteLine("end of array.");            else                Console.WriteLine("{0}", arr[index]);        }    }}
A
D
X
G
M

After Sort:
A
D
G
M
X

B sorts between :
A and D

F sorts between :
D and G

This method Sorts the elements in an Array using the specified IComparer<T> generic interface.
Syntax: public static void Sort<T> (T[] array, System.Collections.Generic.IComparer<T> comparer);
Parameters:
T : It is the type of the elements of the array.
array : It is the one-dimensional Array which is to be sorted.
comparer : It is the IComparer<T> generic interface implementation to use when comparing elements or null to use the IComparable<T> generic interface implementation of each element.
Exceptions:
ArgumentNullException: If the array is null.
InvalidOperationException: If the comparer is null and there is no implementation of the IComparable<T> generic interface.
ArgumentException:If the implementation of comparer caused an error during the sort.
If the implementation of comparer caused an error during the sort.
Example:
// C# program to demonstrate the use of the // Array.Sort<T>(T[], IComparer<T>) methodusing System;using System.Collections.Generic;  public class GeeK : IComparer<string> {      public int Compare(string x, string y)    {        // Compare x and y in reverse order.        return x.CompareTo(y);    }}  class GFG {      // Main Method    public static void Main()    {        // array elements        string[] arr = new string[5] {"A",                      "D", "X", "G", "M" };          foreach(string g in arr)        {              // display original array            Console.WriteLine(g);        }          Console.WriteLine("\nAfter Sort: ");        GeeK gg = new GeeK();          // Sort<T>(T[], IComparer<T>) method        Array.Sort(arr, gg);                  foreach(string g in arr)        {            // display sorted array            Console.WriteLine(g);        }          Console.WriteLine("\nD Sorts between :");          // binary Search for "D"        int index = Array.BinarySearch(arr, "D");                   // call "sortT" function        sortT(arr, index);                 Console.WriteLine("\nF Sorts between :");        index = Array.BinarySearch(arr, "F");        sortT(arr, index);    }      public static void sortT<T>(T[]arr, int index)    {        if (index < 0)        {                          // If the index is negative,             // it represents the bitwise            // complement of the next             // larger element in the array.            index = ~index;              Console.Write("Not found. Sorts between: ");              if (index == 0)                Console.Write("Beginning of array and ");            else                Console.Write("{0} and ", arr[index-1]);              if (index == arr.Length)                Console.WriteLine("end of array.");            else                Console.WriteLine("{0}.", arr[index]);        }        else        {            Console.WriteLine("Found at index {0}.", index);        }    }}
A
D
X
G
M

After Sort: 
A
D
G
M
X

D Sorts between :
Found at index 1.

F Sorts between :
Not found. Sorts between: D and G.

This method sorts the elements in a range of in an Array using the IComparable<T> generic interface implementation of each element of the Array.
Syntax: public static void Sort<T> (T[] array, int index, int length);
Parameters:
array: It is the one-dimensional, zero-based Array to sort.
index: It is the starting index of the range to sort.
length: It is the number of elements in the range to sort.
Exceptions:
ArgumentNullException: If the array is null.
ArgumentOutOfRangeException: If the index is less than the lower bound of array or length is less than zero.
ArgumentException: If the index and length do not specify a valid range in the array.
InvalidOperationException: If one or more elements in the array do not implement the IComparable<T> generic interface.
Example:
// C# program to demonstrate the use of// Array.Sort<T>(T[], Int32, Int32) methodusing System;using System.Collections.Generic;  public class Geek : IComparer<string> {      public int Compare(string x, string y)    {        // Compare y and x in reverse order.        return y.CompareTo(x);    }}  public class Example {      // Main Method    public static void Main()    {        // Array elements        string[] arr = {"AB", "CD",            "GH", "EF", "MN", "IJ"};                     Console.WriteLine("Original Array :");                  Display(arr);          Console.WriteLine("\nSort the array between "+                                      "index 1 to 4");                  // Array.Sort(T[], Int32, Int32) method        // sort will happen in between        // index 1 to 4        Array.Sort(arr, 1, 4);        Display(arr);          Console.WriteLine("\nSort the array reversely"+                           " in between index 1 to 4");                  // sort will happen in between        // index 1 to 4 reversely                  Array.Sort(arr, 1, 4, new Geek());              Display(arr);    }      public static void Display(string[] arr)    {        foreach(string g in arr)        {            Console.WriteLine(g);        }    }}
Original Array :
AB
CD
GH
EF
MN
IJ

Sort the array between index 1 to 4
AB
CD
EF
GH
MN
IJ

Sort the array reversely in between index 1 to 4
AB
MN
GH
EF
CD
IJ

This method sorts the elements in an Array using the specified Comparison<T>.
Syntax: public static void Sort<T> (T[] array, Comparison<T> comparison);
Parameters:
array: It is the one-dimensional zero-based Array which is to be sorted.
comparison: It is the comparison<T> to used when comparing elements.
Exceptions:
ArgumentNullException: If the array is null or comparison is null.
ArgumentException: If the implementation of comparison caused an error during the sort.
Example:
// C# program to demonstrate the use of the // Array.Sort<T>(T[ ], Comparison<T>) Methodusing System;using System.Collections.Generic;  class GFG {          private static int CompareComp(string x, string y)    {        if (y == null && x == null) {                          // If x and y is null            // then x and y are same            return 0;        }        else {                          // If x is null but y is not             // null then y is greater.            return -1;        }    }      // Main method    public static void Main()    {        string[] arr = {"Java", "C++", "Scala",                        "C", "Ruby", "Python"};                Console.WriteLine("Original Array: ");                  // display original array        Display(arr);                  Console.WriteLine("\nSort with Comparison: ");          // Array.Sort<T>(T[], Comparison<T>)        // Method        Array.Sort(arr, CompareComp);                  // display sorted array        Display(arr);              }      // Display function    public static void Display(string[] arr)    {        foreach(string g in arr)        {            Console.WriteLine(g);        }    }}
Original Array: 
Java
C++
Scala
C
Ruby
Python

Sort with Comparison: 
Python
Ruby
C
Scala
C++
Java

Reference:
https://docs.microsoft.com/en-us/dotnet/api/system.array.sort?view=netframework-4.7.2
shubham_singh
CSharp-Arrays
CSharp-method
C#
Technical Scripter
Writing code in comment?
Please use ide.geeksforgeeks.org,
generate link and share the link here.
Difference between Abstract Class and Interface in C#
String.Split() Method in C# with Examples
C# | How to check whether a List contains a specified element
C# | IsNullOrEmpty() Method
C# | Arrays of Strings
C# | Delegates
C# | Abstract Classes
C# | Replace() Method
Extension Method in C#
C# | String.IndexOf( ) Method | Set - 1