AddRange() is not working when adding list items to a Collection

Question

Recently I got a task to work on one of the FxCop warning - Do not expose generic lists. So I tried changing the List<T> to ICollection<T>. But later point of time, while doing the unit testing I found that the AddRange() is not working properly as expected. It is not adding the collection of elements to the collection object.

Here is the sample code

gc.ToList().AddRange(sampleList);

And I have two questions to ask

1. Why it is not adding the items to the collection. Below is the code:

   public class GenericClass
   {
       public int Id;
       public string Name;
   }  
   
   
   class Program
   {
        static void Main(string[] args)
        {
   
         ICollection<GenericClass> gc = new  List<GenericClass>();
   
       var sampleList = new List<GenericClass>()
                            {
                                new GenericClass {Id = 1, Name = "ASD"},
                                new GenericClass {Id = 2, Name = "QWER"},
                                new GenericClass {Id = 3, Name = "BNMV"},
                            };
   
       Console.WriteLine(gc.GetType()); // gc is of type
   
       gc.ToList().AddRange(sampleList); // sampleList items are not getting added to gc.
       Console.ReadKey();
   }
   

   }

2. List<T> inherits from ICollection<T> and List<T> has AddRange(), etc functions. When I tried to cast to parent reference (ICollection<T>) to child class object (List<T>), why doesn't Intellisense suggest AddRange(). Instead I need to do .ToList() and then it shows AddRange().

I searched a lot for this. But couldn't find a reason that satisfied me. So please help me with the understanding. It will be a great help.

Answer 1

The AddRange() method is working fine. The problem is, you didn't read the documentation for the ToList() extension method closely, and so don't realize that the ToList() method returns an entirely new object.

From the documentation:

Creates a List<T> from an IEnumerable<T>.

Since the object you're calling AddRange() with is not in fact the original collection, the original collection remains unchanged.

In a sense, your question is the List<T> equivalent to the very common question "why isn't string.Replace() working?"

In the example you give, there is not really a much better solution than simply not hiding the List<T> in the first place. You can, since you are using the generic ICollection<T> interface, write your own AddRange() as an extension method:

public static void AddRange<T>(this ICollection<T> collection, IEnumerable<T> range)
{
    foreach (T t in range)
    {
        collection.Add(t);
    }
}

But I'm not convinced this is really all that much better than just leaving the type as List<T>, if the goal is to be able to modify the object and use an AddRange() method.

Casting an ICollection<T> reference back to its underlying List<T> (as another answerer proposes) is pointless, as doing so would negate any value in using the ICollection<T> interface in the first place.

Just leave the reference as List<T>, at least in any context where you actually need to modify the collection. (It's fine, and even possibly beneficial, to expose that list in other contexts using only ICollection<T>, but that's an entirely different discussion.)

As long as I'm answering, I will mention that I am skeptical that you've correctly understood the intent of the FxCop warning, as exposing generic lists is not in and of itself inherently harmful.

Answer 2

ToList() returns a new instance, which is why you are not able to see the result of AddRange in "gc". If you really want to use AddRange, you can do the following.

((List<GenericClass>)gc).AddRange(sampleList);