Alternative to hiding non-virtual members with new

Question

Suppose I want to do something like this:

class Foo
{
    public event BarHandler Bar;
    ...
}

class FooList<T> : List<T> where T : Foo
{
    public override void Add(T item)
    {
        item.Bar += Bar_Handler;
        base.Add(item);
    }

    private void Bar_Handler ...

    ...
}

But Add in List<T> is not virtual, so I cannot use override, I would have to resort to new instead. This however does not provide polymorphism, and I am worried about subtle bugs that could be introduced by refering to FooList as simply List, which would lead to my Event-Handler not being added.

My current specific case of this is: I want to subclass ObservableCollection for Items that implement INotifyPropertyChanged, and add/remove an Event-Handler to those Items if they are added/removed. Then I provide an Event that is raised if any Item in Collection changes.

I would like a solution for my particular problem as well as the underlying general problem, as this is somethink I stumbled upon a few times, coming from a java background.

Thorsten Dittmar · Accepted Answer · 2015-01-06T08:31:50.847

8

Instead of extending List<T> you could implement the IList<T> interface and hold an internal List<T> member variable. That way you don't break the existing List<T> functionality and still implement the same interface as List<T>.

Example:

class FooList<T> : IList<T> where T : Foo
{
    private List<T> m_internalList = new List<T>();

    public void Add(T item)
    {
        item.Bar += Bar_Handler;
        m_internalList.Add(item);
    }

    // other methods
}

edited Jan 06 '15 at 08:31

answered Jan 06 '15 at 08:26

Thorsten Dittmar

55,956
8
91
139

2

Composition over Inheritance, now I feel stupid for not seeing it. thanks! – quantumbyte Jan 06 '15 at 08:34
1

Oh that `m_` prefix makes me sad, but +1 ;) – Sriram Sakthivel Jan 06 '15 at 08:37
And why does the `m_` prefix make you sad? Don't you like to separate your instance variables from your locals? ;-) – Thorsten Dittmar Jan 06 '15 at 08:37
That bring c++ coding standard to c#. If at all you want to distinguish the field vs local variable, then use `this.internalList`. – Sriram Sakthivel Jan 06 '15 at 08:47
@SriramSakthivel I guess it's something I just got used to... To me it's just faster to type `m_` instead of `this.`, but of course of have a valid point. – Thorsten Dittmar Jan 06 '15 at 09:11

score 3 · Answer 2 · edited May 23 '17 at 10:33

List<T> is not intended to inherit and thus Add method isn't virtual, but Collection<T> is. You can inherit Collection<T> instead and override InsertItem method.

internal class MyCollection<T> : Collection<T> where T : Foo
{
    protected override void InsertItem(int index, T item)
    {
        item.Bar += Bar_Handler;
        base.InsertItem(index, item);
    }
}

Related: Why not inherit from List<T>?

FWIW ObservableCollection<T> class itself inherits Collection<T>.

Alternative to hiding non-virtual members with new

2 Answers2