C# 泛型、抽象类、构造函数

我有一个抽象基类

class AbstractClass 
{
    Col<AbstractClass> parent

    public AbstractClass()
    {
        //do stuff
    }
}

除了我想让类型

A

和

B

知道它们的父集合之外，这一切都会起作用。我认为在

AbstractClass

中使用以下构造函数是可以的，A，B，但似乎泛型约束只适用于类，而不适用于方法。基本上，我需要以下构造函数：

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

公共抽象类（Col，其中T:AbstractClass）
公共A（Col）
公共图书馆（Col）

A，B的实例需要知道它们在哪个集合中，但我不能从派生类调用基构造函数，因为它们是不同的类型

救命啊

我想让A型和B型了解他们的父集合

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

---

你可能会对它感兴趣。我在编写它时考虑了XML序列化，但它可以在更一般的上下文中使用

使用自定义的

集合

类型，而不是

列表

。它们基本上提供相同的功能（

Collection

在内部使用

List

），并且正是为了实现这一目的

然后，您可以覆盖

InsertItem

，以设置添加到集合中的任何项的父项

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

公共类MyCollection:System.Collections.ObjectModel.Collection
{
受保护的覆盖无效插入项（int索引，T项）
{
基本插入项（索引，项目）；
item.Parent=此项；
}
}

据我所知，这不能在C#2.0中完成。该功能已经存在于CLR中，但C#不允许。在C#2.0中，我们有不变的泛型。在C#4.0中，将支持差异

以下是我的推荐信：

---

当我想做这样的事情时，我经常使用与C++相关的模式：

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) {}
}

抽象类抽象类
其中TDerivedClass:AbstractClass
{
亲本；
公共抽象类（列父级）
{
//做事
this.parent=parent；
}
}
A类：抽象类
{ 
公共A（Col家长）
：基（父）{}
}
B类：抽象类
{ 
公共A（Col家长）
：基（父）{}
}

那么，去掉构造器吗？@Matt:为了简洁起见，我没有包括构造器。当然，你会想添加链接到基本构造函数的构造函数。我编辑了我的问题，以便更好地解释我的问题。我想我们走对了though@Matt：您可以使用

new

关键字将

Col

属性隐藏在基类中，也可以保持原样并强制转换它。但是，您不能重写，这是您必须接受的。另外，请注意，您可以对方法/构造函数具有泛型类型约束。e、 g.

公共void Foo（T bar），其中T:AbstractClass{…}

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