Given order rows, return one summary per customer with total order count and total amount.

• Null input returns an empty list.
• Use decimal for money-like totals.
• Order by total descending, then customer id ascending.
• Do not mutate the input collection.

I would group by customer id, then project each group into a summary with Count() and Sum(). I would call out that this is in-memory LINQ over an IEnumerable; in EF Core, I would be more careful about translation and the generated SQL. The deterministic ordering is part of the contract, not a cosmetic detail.

public sealed record Order(string CustomerId, decimal Amount);
public sealed record CustomerSummary(string CustomerId, int OrderCount, decimal TotalAmount);

public static IReadOnlyList<CustomerSummary> SummarizeOrders(IEnumerable<Order>? orders)
{
    if (orders is null)
    {
        return Array.Empty<CustomerSummary>();
    }

    return orders
        .Where(order => !string.IsNullOrWhiteSpace(order.CustomerId))
        .GroupBy(order => order.CustomerId, StringComparer.Ordinal)
        .Select(group => new CustomerSummary(
            group.Key,
            group.Count(),
            group.Sum(order => order.Amount)))
        .OrderByDescending(summary => summary.TotalAmount)
        .ThenBy(summary => summary.CustomerId, StringComparer.Ordinal)
        .ToList();
}

Time is O(n + k log k): one pass to group n orders, then sorting k customer summaries. Space is O(k) for the grouped summaries, plus LINQ grouping storage.

• Null input.
• No orders.
• Duplicate customers.
• Ties in total amount.
• Rows with blank customer ids if the method chooses to ignore invalid rows.

• Use ties to verify the secondary sort.
• Use negative or zero amounts if refunds are possible in the domain.
• Use many rows for one customer to verify aggregation, not only grouping.

• Using double for money-like values.
• Returning groups in whatever order LINQ produces.
• Forgetting null or invalid customer ids.
• Assuming in-memory LINQ behavior is always the same as EF Core translation.