Question

我有几个类（A，B，C，...）都使用List<AnotherClass>来存储对“其他”对象的引用。但是对于A，B，C类中的每一个，“其他”是不同的。所以 A类包含List<Class_X> B类包含List<Class_Y> C类包含List<Class_Z>

而不是在A，B，C中实现添加/删除/搜索（等）功能，从ListRef<T>

创建一个类List<T>似乎合乎逻辑

public class ListRef<T>: List<T>
{
    protected ListRef<T> ListOfObjects = null;
    protected string name = null;

    public ListRef<T>
    {
        ListOfObjects = new ListRef<T>();
    }
}

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

在A类的构造函数中，我想写类似的东西：

public A() : base<Class_X>
{
}

如何从WITHIN类A指定需要在ListOfObjects中存储哪种对象？

我不想写

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

因为我希望将ListOfObjects声明为私有而不是受保护

在Listref中我只想要能够添加，删除，搜索对象。所以我实际上并没有使用这些类（Class_X，Class_Y，Class_Z）。

目前我有

public class A
{
     private List<Class_X> ListOfObjects = null;
     A()
     {
         ListOfObjects = new List<Class_X>();
     }

     public void Add(string Name)
     {
        Class_X Object = new Class_X(Name);
        ListOfObjects.Add(Object);
     }
     public void Delete(Class_X Object)
     {
        ListOfObjects.Remove(Object);
     }
}

和B类（使用Class_Y）和C类（使用class_Z）的相同类型的代码。对我来说，使用ONE类ListRef来执行Add和Delete操作并维护我使用的所有类的列表似乎是合乎逻辑的。（当然真正的代码更复杂）

Answer 1

以下是我推荐的方法......

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());

Answer 2

如果我理解你的问题是正确的，那么你想要做的就是创建一组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> { ... }

其次，是构图方法：为您的集合创建一个管理器类，该集合实现子列表上的操作，并在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>(); }
}

您也可以选择混合使用这两种方法 - 创建列表管理类，同时为A，B，C创建基类（或接口），以便每个方法都公开一致的属性ChildList （或某些此类）消费者可以使用而不必总是知道类型实际类型A，B，C。

Answer 3

怎么样

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

Answer 4

我希望我能正确理解你的问题。我将如何做到这一点：

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

使用此界面，您可以确保每种类型都有一个公共IList<T>属性，您可以将其用于任何您希望的操作。

处理派生List <t>类</t>中不同类的对象

4 个答案: