C# 处理派生列表中不同类的对象<；T>；班

我有几个类（A，B，C，…），它们都使用

列表来存储对“其他”对象的引用。但“其他”对于A、B、C类来说都是不同的。
所以
A类包含
列表
B类包含
列表
C类包含
列表

在我看来，与其在A、B、C中实现添加/删除/搜索（etc）功能，不如从
List
创建一个类
ListRef

公共类ListRef:List
{
受保护的ListRef ListOfObjects=null；
受保护的字符串名称=null；
公共列表参考
{
ListOfObjects=新ListRef（）；
}
}

使用上面的代码（这是我想要的正确代码吗？）我不知道如何提供正确的类（class_X，class_Y，class_Z），替换/指定将使用ListRef的每个类（A，B，C）的构造函数中的

在类A的构造函数中，我想编写如下内容：

public A() : base<Class_X>
{
}

public A（）：base
{
}

如何从类A中指定需要在ListOfObjects中存储哪些类型的对象

我宁愿不写

public A()
{
    ListOfObjects = new ListRef<Class_X();
}

public A（）
{
ListOfObjects=新建ListRef怎么样

public interface ISomeOtherClass
{
}

public class Class_X : ISomeOtherClass
{
}

public class Class_Y : ISomeOtherClass
{
}

public class BaseClass<T> where T : ISomeOtherClass
{
   public ListRef<T> OtherObjects { get; set; }
}

public class A : BaseClass<Class_x>
{
}

public class B : BaseClass<Class_Y>
{
}

公共接口类
{
}
公共类X类：其他类
{
}
公共类Y类：其他类
{
}
公共类基类，其中T:ISomeOtherClass
{
公共ListRef其他对象{get；set；}
}
公共A类：基本类
{
}
公共类B：基本类
{
}
我希望我正确理解了您的问题。以下是我将如何做到这一点：

interface ILetter<T>
{
    IList<T> OtherObjects { get; }
}

class A : ILetter<Class_X> 
{
    public IList<Class_X> OtherObjects
    {
        get { /* ... */ }
    }
}

class B : ILetter<Class_Y> 
{
    public IList<Class_X> OtherObjects
    {
        get { /* ... */ }
    }
}

// etc...

interface-ILetter
{
IList其他对象{get；}
}
甲级：ILetter
{
公共IList其他对象
{
获取{/*…*/}
}
}
B类：ILetter
{
公共IList其他对象
{
获取{/*…*/}
}
}
//等等。。。

使用此界面，您可以确保每种类型都有一个公共的
IList
属性，您可以使用该属性执行任何操作。
以下是我建议您执行此操作的方式

public class ABC_Base<TChild>
{
    public IEnumberable<TChild> Children { get; set; }

    public void AddChild(TChild item) 
    {
    }

    public void RemoveChild(TChild item)
    {
    }

    //etc
}

public class A : ABC_Base<X> // X is the type for your child
{

}

//Used like so...
A myA = new A();

myA.AddChild(new X());

// or if you are wanting to specify when created then this...

public class A<TChild> : ABC_Base<TChild>
{
}

//Used like so...
A myA = new A<X>();
A myOtherA = new A<Y>();

myA.Addchild(new X());
myOtherA.AddChild(new Y());

公共类ABC\u库
{
公共IEnumberable子项{get；set；}
公共void AddChild（TChild项）
{
}
公共无效删除child（TChild项）
{
}
//等
}
公共A类：ABC_Base//X是适合您孩子的类型
{
}
//像这样使用。。。
A myA=新的A（）；
myA.AddChild（新的X（））；
//或者，如果您想指定何时创建，则此。。。
公共A类：ABC\U基地
{
}
//像这样使用。。。
A myA=新的A（）；
A myOtherA=新的A（）；
myA.Addchild（新的X（））；
myOtherA.AddChild（新Y（））；
如果我正确理解您的问题，听起来您想要做的是创建一组类a、B、C等，每个类管理其他类型（X、Y、Z）的集合，但您不想在a、B和C之间复制一些列表管理逻辑

实现这一点有两种不同的方法

首先，继承方法：您可以为A、B和C提供一个通用基类，该基类根据各自要管理的项的类型进行参数化。下面是一个代码示例：

public abstract class ABCBase<T>
{
   protected IList<T> m_List = new List<T>();

   // methods that manage the collection
   // I chose to make the virtual so that derived 
   // classes could alter then behavior - may not be needed
   public virtual void Add( T item )    { ... }
   public virtual void Remove( T item ) { ... }
   public virtual int  Find( T item )   { ... } 
}

public class A : ABCBase<X> { ... }

public class B : ABCBase<Y> { ... }

public class C : ABCBase<Z> { ... }

公共抽象类ABCBase
{
受保护的IList m_List=新列表（）；
//管理集合的方法
//我选择了虚拟化，以便
//类可以改变行为-可能不需要
公共虚拟空添加（T项）{…}
公共虚拟无效删除（T项）{…}
公共虚拟整数查找（T项）{…}
}
公共A类：ABCBase{…}
公共类B:ABCBase{…}
公共类C:ABCBase{…}

其次是组合方法：为您的同事创建一个管理器类，该类实现子列表上的操作，并聚合a、B和C中的每个操作：

public class ListManager<T>
{
   private IList<T> m_List = new List<T>();

   public void Add( T item )    { ... }
   public void Remove( T item ) { ... }
   public int  Find( T item )   { ... }
}

public class A
{
   public ListManager<X> ListOfX { get; protected set; }

   public A() { ListOfX = new ListManager<X>(); }
}

public class B
{
   public ListManager<Y> ListOfX { get; protected set; }

   public B() { ListOfY = new ListManager<Y>(); }
}

public class C
{
   public ListManager<Z> ListOfX { get; protected set; }

   public C() { ListOfX = new ListManager<Z>(); }
}

公共类列表管理器
{
私有IList m_List=新列表（）；
公共无效添加（T项）{…}
公共无效删除（T项）{…}
公共整数查找（T项）{…}
}
公共A类
{
公共ListManager ListOfX{get；protected set；}
public A（）{ListOfX=new ListManager（）；}
}
公共B级
{
公共ListManager ListOfX{get；protected set；}
public B（）{ListOfY=new ListManager（）；}
}
公共C类
{
公共ListManager ListOfX{get；protected set；}
public C（）{ListOfX=new ListManager（）；}
}

您也可以选择混合使用这两种方法-创建列表管理类，同时为a、B、C创建基类（或接口），以便每种方法都公开一致的属性ChildList（或类似的）消费者可以在不必知道类型的情况下使用实际类型A、B、C。
为什么要从List继承，然后在类中使用子类？这似乎是非常循环的。如果您演示如何使用此类，可能会有所帮助，这样我们就可以更好地理解您试图使其执行的操作。在Listref I JU内部我不想添加、删除和搜索对象。所以我实际上没有使用这些类（Class_X，Class_Y，Class_Z）。目前我有一个公共类A{private List ListOfObjects=null；A（）{ListOfObjects=new List（）；}public void Add（字符串名）{Class_xobject=newclass_X（Name）；listofoobjects.Add（Object）；}public void Delete（Class_xobject）{listofoobjects.Remove（Object）；}如果包含代码，这里很难阅读hmmm注释；我会将其添加到问题中是的，您正确理解了我的问题。我不想（可以）使用继承方法，因为其中一个类（B）已经派生，并且C#中不允许多重继承（当然，我可以通过引入另一个类来解决）.虽然我不得不使用ListOfX.Add（item）；而不仅仅是Add（item）；但组合方法对我来说似乎更好；有什么想法吗
public abstract class ABCBase<T>
{
   protected IList<T> m_List = new List<T>();

   // methods that manage the collection
   // I chose to make the virtual so that derived 
   // classes could alter then behavior - may not be needed
   public virtual void Add( T item )    { ... }
   public virtual void Remove( T item ) { ... }
   public virtual int  Find( T item )   { ... } 
}

public class A : ABCBase<X> { ... }

public class B : ABCBase<Y> { ... }

public class C : ABCBase<Z> { ... }

public class ListManager<T>
{
   private IList<T> m_List = new List<T>();

   public void Add( T item )    { ... }
   public void Remove( T item ) { ... }
   public int  Find( T item )   { ... }
}

public class A
{
   public ListManager<X> ListOfX { get; protected set; }

   public A() { ListOfX = new ListManager<X>(); }
}

public class B
{
   public ListManager<Y> ListOfX { get; protected set; }

   public B() { ListOfY = new ListManager<Y>(); }
}

public class C
{
   public ListManager<Z> ListOfX { get; protected set; }

   public C() { ListOfX = new ListManager<Z>(); }
}