Generics, abstract classes, constructors

Question

I have an abstract base class

class AbstractClass 
{
    Col<AbstractClass> parent

    public AbstractClass()
    {
        //do stuff
    }
}

I have two implementations

class A : AbstractClass 
{ 
    Col<A> parent

    public A(Col<A> parent)
        :base(parent)
    {
        this.parent = parent;
    }  

}

class B : AbstractClass 
{ 
    Col<B> parent

    public B(Col<B> parent)
        :base(parent)
    {
        this.parent = parent;
    }
}

I have a collection

class Col<T> : IList<T> where T : AbstractClass

Which is to be used in another class as Col<A> and Col<B>, let's call this class C.

class C
{
    List<A> a = new List<A>()
    List<B> b = new List<B>()
}

This would all work, except that I want types A and B to know about their parent collection. I thought having the following constructors in AbstractClass, A, B would be ok, but it seems generic constraints are only available for classes and not on methods. Essentially I would like the following constructors:

public AbstractClass(Col<T> where T : AbstractClass)
public A(Col<A>)
public B(Col<B>)

instances of A, B need to know what collection they're in, but I can't call the base constructor from the derived classes because they're different types.

Help!

Answer 1

I want types A and B to know about their parent collection

You might be interested in this article. I wrote it with XML serialization in mind, but it can be used in a more general context

Answer 2

Use a custom Collection<T> type instead of a List<T>. They basically provide the same functionality (Collection<T> uses List<T> internally), and is intended precisely for this purposes.

You can then override InsertItem to set the parent of any item added to the collection.

public class MyCollection<T> : System.Collections.ObjectModel.Collection<T>
{
    protected override void InsertItem(int index, T item)
    {
        base.InsertItem(index, item);
        item.Parent = this;
    }
}

Answer 3

As far as I understand it, this can't be done in C# 2.0. The functionality is already sitting in the CLR, but C# doesn't allow it. In C# 2.0 we have invariant generics. In C# 4.0 there will be support for variance.

Here are my references:

http://blogs.msdn.com/rmbyers/archive/2005/02/16/375079.aspx

http://code.msdn.microsoft.com/csharpfuture

http://channel9.msdn.com/pdc2008/TL16/

Am I right?

Answer 4

I often use a pattern related to the C++ curiously recurring template pattern when I want to do something like this:

abstract class AbstractClass<TDerivedClass>
    where TDerivedClass : AbstractClass<TDerivedClass>
{
    Col<TDerivedClass> parent;

    public AbstractClass(Col<TDerivedClass> parent)
    {
        // do stuff
        this.parent = parent;
    }
}

class A : AbstractClass<A>
{ 
    public A(Col<A> parent)
        :base(parent) {}
}

class B : AbstractClass<B>
{ 
    public A(Col<B> parent)
        :base(parent) {}
}