6

Let's assume this class in C#:

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

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

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

The compiler gives me this warning in the line "public void Add(T value)":

warning CS0108: 'System.LimitedList.Add(T)' hides inherited member 'System.Collections.Generic.List.Add(T)'. Use the new keyword if hiding was intended.

What do I have to do to avoid this warning?

Thx 4 your help

Improve this question
1
  • 1
    Don't forget to override the behavior of the rest of the interface also if your going to use inheritance. Otherwise you just need to make a collection that Has a collection, not is a collection. Commented May 22, 2009 at 14:41

4 Answers 4

Reset to default
14

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--;
        }
    }
}
Improve this answer
Sign up to request clarification or add additional context in comments.

11 Comments

This is a much better explanation on how to properly code this. Thanks Marc
than i have to implement the whole interface ?!
@Bigbohne, yes. You would have to forward all of the calls into your class
@JaredPar - not if you inherit from Collection<T> (which does all that forwarding for you to the base IList<T>)
@Marc, I think that even inheriting from Collection is wrong because it's violating an implicit controct. I would expect anything I add to a Collection<T> via Add to be available until I 1) lose control of the object or 2) explicitly remove it. LimitedCollection would violate this contract
|
11

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);
}
Improve this answer

3 Comments

@Marc completely agree this is wrong. I added an example of where this is broken.
@Dan agreed, this is why inheritance is bad here.
+1, agreeing that it would be much better to encapsulate a List<T> instance instead of inheriting from it.
0

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.

Improve this answer

1 Comment

See the other replies about polymorphism to see why this isn't a good idea.
-1

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".

Improve this answer

Comments

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy.