List.AddRange是否调用List.Add？

Question

I have a custom class derived from List with an Add method that adds only if a certain condition is satisfied.

Do I also need to override* AddRange, or does AddRange simply call Add on each element of the given range?

*: Yes, new is hiding and not overriding in the context of C#.

Answer 1

If you want to create custom collection. Don't derive it from List<T> but from Collection<T> or directly implement IList<T> or ICollection<T> . Indeed, the Add method in the List<T> class is not virtual.

Note: List<T>.AddRange uses Array.Copy .

UPDATE

When inheriting Collection you just have to override 2 methods!

public class MyCollection : Collection<string>
{
    private bool IsValidItem(string item)
    {
        return; // Your condition : true if valid; false, otherwise.
    }

    // This method will be called when you call MyCollection.Add or MyCollection.Insert
    protected override void InsertItem(int index, string item)
    {
        if(IsValidItem(item))
            base.InsertItem(index, item);
    }

    // This method will be called when you call MyCollection[index] = newItem
    protected override void SetItem(int index, string item)
    {
        if(IsValidItem(item))
            base.SetItem(index, item);
    }
}

If your items to validate are not string replace string in the code above by the correct type.

Answer 2

Don't use hiding that changes the semantics of the method. That's really bad design.

Create a new class that implements IList<T> . The easiest way to do that is inheriting from Collection<T> . Collection<T> implements IList<T> and has four extension points in the form of protected virtual methods:

InsertItem
SetItem
RemoveItem
ClearItems

Since you only needs to validate items that get added and not those that get removed, you only need to override InsertItem and SetItem .

class MyCollection:Collection<T>
{
    private void ValidateItem(T item)
    {
       if(item is invalid)
         throw new ArgumentException("Item is invalid");
    }

    protected override InsertItem(int index, T item)
    {
        ValidateItem(item);
        base.InsertItem(index, item);
    }

    protected override SetItem(int index, T item)
    {
        ValidateItem(item);
        base.SetItem(index, item);
    }
}

Answer 3

If you need a collection that behaves exactly like a List<T> , except for adding only valid objects, I wouldn't create a custom collection.

Use Extensions instead and call them AddIfValid(T value) and AddRangeIfValid(IEnumerable<T>) or whatever you like, as long as it's clear what the Extension is doing.

Here's an example:

public static void AddIfValid(this List<T> list, T value)
{
    if (/* check if value is valid here */)
        list.Add(value);
}

Once you have defined your Extension, use it like this:

myList.AddIfValid(myValue);