Introduction:

Sorting arrays of objects is a common task in programming, especially when dealing with complex data structures. In C#, there are multiple ways to sort an array of objects based on a specific property, such as sorting a list of employees by their salaries or ordering a collection of products by their prices.

In this blog post, we will explore different methods to effectively sort an array of objects in C# based on a property. We will provide detailed explanations, code examples, and the corresponding output for each method. By the end, you will have a clear understanding of these techniques and be able to choose the most appropriate approach for your sorting requirements.

Method 1: IComparable Interface

The IComparable interface allows objects to define their own custom comparison logic. By implementing this interface, we can utilize the built-in Array.Sort() method to sort our array of objects. Let's consider an example where we have a list of students and want to sort them based on their names.

using System;

public class Student : IComparable<Student>
{
    public string Name { get; set; }
    public int Age { get; set; }

    public int CompareTo(Student other)
    {
        return string.Compare(Name, other.Name);
    }
}

public class Program
{
    public static void Main()
    {
        Student[] students = new Student[]
        {
            new Student { Name = "John", Age = 20 },
            new Student { Name = "Alice", Age = 22 },
            new Student { Name = "Bob", Age = 21 }
        };

        Array.Sort(students);

        foreach (Student student in students)
        {
            Console.WriteLine(student.Name);
        }
    }
}

Output:

Alice
Bob
John

In this example, we define a Student class that implements the IComparable<Student> interface. The CompareTo method is overridden to compare the names of two students using the string.Compare method. Finally, we create an array of Student objects, call Array.Sort(), and iterate over the sorted array to display the names in ascending order.

Method 2: Comparison Delegate

C# provides the Comparison<T> delegate, which allows us to define custom comparison logic as a separate method. By using this delegate, we can sort our array of objects using the Array.Sort() method and passing our custom comparison method as a parameter. Let's see an example where we sort a list of products based on their prices.

using System;

public class Product
{
    public string Name { get; set; }
    public decimal Price { get; set; }
}

public class Program
{
    public static void Main()
    {
        Product[] products = new Product[]
        {
            new Product { Name = "Laptop", Price = 1200 },
            new Product { Name = "Phone", Price = 800 },
            new Product { Name = "Tablet", Price = 500 }
        };

        Array.Sort(products, CompareByPrice);

        foreach (Product product in products)
        {
            Console.WriteLine(product.Name);
        }
    }

    public static int CompareByPrice(Product product1, Product product2)
    {
        return product1.Price.CompareTo(product2.Price);
    }
}

Output:

Tablet
Phone
Laptop

In this example, we have a Product class with a Name and Price property. We define a separate CompareByPrice method that compares two products based on their prices using the CompareTo method. The Array.Sort() method is called, passing the array of products and the CompareByPrice method as parameters. Finally, we iterate over the sorted array and display the product names in ascending order of prices.

Method 3: Lambda Expressions

Lambda expressions provide a concise and expressive way to define custom comparison logic inline. We can utilize lambda expressions with the Array.Sort() method to sort our array of objects based on a property. Let's consider an example where we sort a list of employees based on their salaries.

using System;

public class Employee
{
    public string Name { get; set; }
    public decimal Salary { get; set; }
}

public class Program
{
    public static void Main()
    {
        Employee[] employees = new Employee[]
        {
            new Employee { Name = "John", Salary = 50000 },
            new Employee { Name = "Alice", Salary = 60000 },
            new Employee { Name = "Bob", Salary = 55000 }
        };

        Array.Sort(employees, (emp1, emp2) => emp1.Salary.CompareTo(emp2.Salary));

        foreach (Employee employee in employees)
        {
            Console.WriteLine(employee.Name);
        }
    }
}

Output:

John
Bob
Alice

In this example, we define an Employee class with a Name and Salary property. We use a lambda expression as the comparison logic, sorting the employees based on their salaries in ascending order. The lambda expression (emp1, emp2) => emp1.Salary.CompareTo(emp2.Salary) compares two employees based on their salaries. Finally, we iterate over the sorted array and display the employee names.

Conclusion:

In this blog post, we explored different methods to sort an array of objects based on a property in C#. We covered the usage of the IComparable interface, Comparison delegates, and lambda expressions, demonstrating their respective advantages and applications. By understanding these techniques, you can effectively sort arrays of objects in C# according to your specific requirements.