C# - IList<T>

IList<T> is an interface in the System.Collections.Generic namespace that represents a collection of objects that can be individually accessed by index. It extends the ICollection<T> interface, which means that it inherits properties and methods of the ICollection<T> interface.

IList<T> has the functionality of ICollection<T>, but in addition, it also supports indexing, adding, removing, and finding items.

Characteristics:

1. Items can be accessed by index.
2. Provides methods to search for elements.
3. Supports adding and removing items.
4. Can determine the index of an item.

Example:

using System;
using System.Collections.Generic;

public class Program
{
    public static void Main()
    {
        IList<string> fruits = new List<string>();

        // Adding elements
        fruits.Add("Apple");
        fruits.Add("Banana");
        fruits.Add("Cherry");

        Console.WriteLine("Fruits List:");
        foreach (var fruit in fruits)
        {
            Console.WriteLine(fruit);
        }

        // Accessing element by index
        Console.WriteLine($"\nFruit at index 1: {fruits[1]}");

        // Removing element by index
        fruits.RemoveAt(1);
        Console.WriteLine("\nAfter removing Banana:");
        foreach (var fruit in fruits)
        {
            Console.WriteLine(fruit);
        }

        // Inserting at specific index
        fruits.Insert(1, "Grape");
        Console.WriteLine("\nAfter inserting Grape at index 1:");
        foreach (var fruit in fruits)
        {
            Console.WriteLine(fruit);
        }
    }
}

Output:

Fruits List:
Apple
Banana
Cherry

Fruit at index 1: Banana

After removing Banana:
Apple
Cherry

After inserting Grape at index 1:
Apple
Grape
Cherry

IList<T> Methods and Properties

Pros of IList<T>:

• Flexibility: Since IList<T> is an interface, you can implement it in custom classes to offer list-like behaviors while still preserving other unique characteristics of the class.
• Indexed Access: You can directly access items by their index, which makes certain operations fast.
• Standardized API: Implementing IList<T> ensures that developers familiar with the .NET collection interfaces will instantly recognize and understand how to use your class.
• Extensibility: While classes like arrays are fixed in size, classes implementing IList<T> can be designed to grow or shrink as needed.
• Interoperability: Many built-in .NET Framework methods and LINQ extensions operate on IList<T>, meaning that classes implementing it can readily be used with those methods.

Cons of IList<T>:

• Performance Overhead: Depending on the specific implementation, certain operations (like inserting an element in the middle of the list or removing it) can be computationally expensive, especially for larger lists.
• Potential for Misuse: Direct indexed access can lead to out-of-range exceptions if not used with care. This is particularly true when the size of the list can change during operations.
• Lack of Specificity: Because it's a general-purpose interface, IList<T> doesn't offer specialized methods that might be present in more specialized collections (e.g., priority queues, linked lists).
• Mutable by Default: The interface provides methods for adding and removing elements, making it unsuitable for scenarios where immutability is desired. Although the list can be made read-only, it's not inherently immutable.
• Not Thread-Safe: Implementations of IList<T> are not guaranteed to be thread-safe. If multiple threads access an IList<T> instance concurrently, and at least one of the threads modifies the list, it must be synchronized externally.