Collections Study Portal

IList — Indexed Access Collections

"Use IList when you need random access by index, or when Insert/RemoveAt operations are required."

❌ Bad example:

public IEnumerable<Trade> GetRecentTrades()
{
    return _trades.OrderByDescending(t => t.Timestamp).Take(10);
}

// Caller
public void DisplayLastTrade(IEnumerable<Trade> trades)
{
    var lastTrade = trades.Last(); // enumerates entire sequence
    Console.WriteLine(lastTrade.Symbol);
}

Using .Last() on IEnumerable requires full enumeration—inefficient.

✅ Good example:

public IList<Trade> GetRecentTrades()
{
    return _trades.OrderByDescending(t => t.Timestamp).Take(10).ToList();
}

// Caller
public void DisplayLastTrade(IList<Trade> trades)
{
    var lastTrade = trades[trades.Count - 1]; // O(1) indexed access
    Console.WriteLine(lastTrade.Symbol);
}

👉 IList enables O(1) random access via indexer, avoiding enumeration.

🔥 When Insert/RemoveAt matters:

public class OrderBook
{
    public IList<Order> BuyOrders { get; } = new List<Order>();

    public void InsertOrderAtPrice(Order order)
    {
        // Binary search to find insertion point
        int index = BuyOrders.BinarySearch(order, new PriceComparer());
        if (index < 0) index = ~index;

        BuyOrders.Insert(index, order); // insert at specific position
    }
}

👉 IList supports Insert() and RemoveAt() for positional mutations.

🔥 Avoiding unnecessary copies:

// ❌ Bad: forces caller to know concrete type
public List<decimal> CalculatePrices(List<decimal> basePrices)
{
    for (int i = 0; i < basePrices.Count; i++)
        basePrices[i] *= 1.05m;
    return basePrices;
}

// ✅ Good: accepts interface, returns interface
public IList<decimal> CalculatePrices(IList<decimal> basePrices)
{
    for (int i = 0; i < basePrices.Count; i++)
        basePrices[i] *= 1.05m;
    return basePrices;
}

👉 Accepting IList allows arrays or lists without forcing specific types.

💡 In trading systems:

• Use IList for order books where indexed access is critical for price levels.
• Enable efficient batch processing with index-based loops (faster than foreach for large arrays).
• Prefer IEnumerable unless random access is genuinely needed—narrower contract.

Questions & Answers