C#: Inheritance Problem with List

Question

Let\'s assume this class in C#:

public class LimitedList : List
{
    private int _maxitems = 500;

    public void Add(T value) /* Adding          


        

Answer 1

No - don't use new here; that doesn't give you polymorphism. List<T> isn't intended for inheritance in this way; use Collection<T> and override the Add InsertItem method.

public class LimitedCollection<T> : Collection<T>
{
    private int _maxitems = 500;

    protected override void InsertItem(int index, T item)
    {
        base.InsertItem(index, item);
        TrimData(); /* Delete old data if lenght too long */
    }

    private void TrimData()
    {
        int num = Math.Max(0, base.Count - _maxitems);
        while (num > 0)
        {
            base.RemoveAt(0);
            num--;
        }
    }
}

Answer 2

Like others have stated, you need to add the new keyword. The reason for this is because in the base class (List<T>) the Add method hasn't been marked with the keyword "virtual" which basically means "overridable". Therefore, it should be marked as "new".

Answer 3

You need to declare your 'Add' method as a 'new' (replacement) method. Try this:

public class LimitedList<T> : List<T>
{
    private int _maxitems = 500;

    public new void Add(T value) /* Adding a new Value to the buffer */
    {
        base.Add(value);
        TrimData(); /* Delete old data if length too long */
    }

    private void TrimData()
    {
        int num = Math.Max(0, base.Count - _maxitems);
        base.RemoveRange(0, num);
    }
}

notice the 'new' keyword in the 'Add(...' declaration.

Although, in this instance, you should create your own generic class implementing the IList interface. Hope that helps.

Answer 4

You can avoid this warning by adding "new" to the declaration.

public new void Add(T value) { 
 ...
}

However I think you may be approaching this problem a bit wrong by using Inheritance. From my perspective LimitedList is not a List because it expresses very different behavior as it puts a hard constraint on the amount of data in the List. I think it would be much better to not inherit from List but have a List as a member variable.

Another reason why this is a bad idea is that you won't be able to satisfy your class's contract when it is viewed as a List. The following code will use the List`s Add method and not LimitedList.

List<int> list = new LimitedList<int>(10);
for ( i = 0; i < 10000; i++ ) {
  list.Add(i);
}