C#多种类型的通用列表的通用列表

以下是对我的问题的抽象和简化：

我有一套玩具和一个相应的盒子。我希望用户能够指定盒子可以容纳的最大玩具类型：

public class Box<T> {}

公共类框{}

然后在Box类中，我希望有一个玩具的通用列表，但是盒子中包含的每个玩具都有一个通用类型：

public class Box<T>
{
    public List<Toy> = new List<Toy>();
    public bool Whatever;

    [member functions, constructors...]
    [The member functions will depend on T]
}

公共类框
{
公共列表=新列表（）；
不管什么公共场所；
[成员函数、构造函数…]
[成员职能将取决于T]
}

玩具类将如下所示：

public class Toy<T> where T : struct //T is any type
{
    public List<T> = new List<T>();
    public string Name;
    public string Color;

    [member functions, constructors...]
}

MultiGenericList<T> Join<C1, C2, T>(MultiGenericList<C1> child1, 
                                    MultiGenericList<C2> child2) where C1 : T, C2 : T
{
    ...
}

public class MyGenericType<T>
{
    public T Data;
    public string SomeString;
}

公共类玩具，其中T:struct//T是任何类型
{
公共列表=新列表（）；
公共字符串名称；
公共字符串颜色；
[成员函数、构造函数…]
}

我希望能够创建许多不同类型的玩具，然后将它们插入到另一个指定类型的盒子中。然后，我想能够添加框一起返回最大类型的框

我真的不知道如何开始。一个具有多种类型的泛型类的列表真是让我大吃一惊。我读了很多关于使用抽象类或接口的文章，但还没有找到一个例子或任何能实现类似于我所要做的事情的东西

任何人能提供的任何帮助都将不胜感激

解决方案可以是C#4.0

未来可能的澄清：

我希望Toy是泛型的，并在实例化时接受一个参数，因为Toy还必须有一个列表作为成员

玩具中的嵌套列表是我的主要问题。然后，我想在框中列出一个存放玩具的列表，但每个玩具都有不同类型的构造函数

更新： 我把一个盒子接一个盒子的问题解决了

更新2：

Toy tyPlastic=新玩具（“Name1”，蓝色，新塑料[]{0xFFEE00，0xF34684，0xAA35B2}）；
玩具泰伍德=新玩具（“名称2”，纹理，新木材[]{a1，f4，h7}）；
Box bxBox=新的Box（）//这个盒子可以装塑料和木制玩具。塑料>木材>纸张

最后：我最终删除了框的通用性要求。然后我使用反射来创建动态类型的玩具。谢谢大家。

您的最后一行“每个玩具都有不同的构造函数”意味着您需要一个玩具基类，每个特定的玩具都继承自该类：

public abstract class Toy{} // abstract base class

public class Ball : Toy
{
    public Ball(){} // Ball constructor
}

或者一个接口来定义通用玩具，每个特定类型的玩具都实现这个接口。。。接口或基类都可以定义泛型列表

---

需要这样做的原因是，如果对所有类型的

Toy

使用单个类，则无法根据类型更改构造函数。。。这不是行为泛型的支持。

我不确定这是否是您真正想要做的，因为这有点不成熟。如果你想要列出每种可能的玩具类型，包括Box可能不知道的玩具，你需要使用你的通用参数来筛选出正确的玩具。我不建议这样做，除非这个盒子只是一块空白的石板，用来把普通的东西塞进里面（例如a）

例如，您可以只拥有一个列表，所有方法在操作它们之前检查内容的类型是否正确。您也可以使用字典来跳过逐项筛选步骤，但会导致继承方面的一些问题（动物列表中不会包含添加到长颈鹿列表中的内容）

下面是字典方法的一个简单实现：

public class MultiGenericList
{
    private readonly Dictionary<Type, Object> map = new Dictionary<Type,Object>();

    public List<T> GetList<T>()
    {
        if (!this.map.ContainsKey(typeof(T))) this.map.Add(typeof(T), new List<T>());
        return (List<T>)this.map[typeof(T)];
    }
}

公共类多泛型列表
{
私有只读字典映射=新字典（）；
公共列表GetList（）
{
如果（！this.map.ContainsKey（typeof（T）））this.map.Add（typeof（T），newlist（））；
返回（列出）此.map[typeof（T）]；
}
}

您可以修改此代码以将列表限制为特定类型，还可以进一步修改，以便可以加入共享公共基类型的列表。可能是这样的：

public class Toy<T> where T : struct //T is any type
{
    public List<T> = new List<T>();
    public string Name;
    public string Color;

    [member functions, constructors...]
}

MultiGenericList<T> Join<C1, C2, T>(MultiGenericList<C1> child1, 
                                    MultiGenericList<C2> child2) where C1 : T, C2 : T
{
    ...
}

public class MyGenericType<T>
{
    public T Data;
    public string SomeString;
}

MultiGenericList联接（MultiGenericList child1，
多泛型列表（2），其中C1:T，C2:T
{
...
}

我引用MSDN:

泛型类封装操作 不是特定于某个特定的 数据类型。最常用于 泛型类与集合一起使用 像链表，哈希表， 堆栈、队列、树等在哪里 添加和删除等操作 收藏中的项目包括 以几乎相同的方式执行 无论正在处理的数据类型如何 储存的

根据您的描述，最接近的对象是盒子，但您知道它将包含玩具，并且玩具最大化，并且玩具有一个类型（球、马…）。我在这里可能错了，但使用泛型可能不是真的必要。我的想法是：

    public class Box
    {
        public ToyType MaxType { get; set; }
        public List<Toy> Toys = new List<Toy>();

        public void Add(Toy toy)
        {
            if (toy.Type.Size <= MaxType.Size) //if its not larger, or whatever compatibility test you want
                Toys.Add(toy);
        }
    }

    public class Toy
    {
        public ToyType Type { get; set; }
        public Toy(ToyType type)
        {
            Type = type;
        }  
    }

    public abstract class ToyType
    {
        public abstract string TypeName { get; set; }
        public abstract int Size { get; set; }
    }

公共类框
{
公共ToyType MaxType{get；set；}
公共列表玩具=新列表（）；
公共空间添加（玩具）
{
如果（toy.Type.Size您正在构建的代码能够很好地模拟现实，那么您将能够更好地理解它

建模“A/B”的方法是使用泛型。一组可以容纳一种东西的盒子将被建模为
box
。一个只能容纳玩具的盒子将是
box
。一组可以容纳一种东西的盒子将是
盒子，其中T:toy

到目前为止还不错。但是
玩具的概念在现实生活中并不适用。你可能有一盒饼干或一盒玩具，但你没有饼干玩具、洋娃娃玩具或长颈鹿玩具。“玩具”的概念没有任何意义，所以不要建模

一个更明智的建模方法是“有一类叫做玩具的东西，没有一种东西仅仅是一个玩具，每一个玩具都是一个m
Box<Doll> dollbox = new Box<Doll>() { new Doll() };
Box<Ball> ballbox = new Box<Ball>() { new Ball() };
Box<Toy> toybox2 = Box<Toy>.MergeBoxes(ballbox, dollbox);

Box<Toy> toybox2 = Box<Toy>.MergeBoxes(ballbox.Cast<Toy>(), dollbox.Cast<Toy>());

public class MyGenericType<T>
{
    public T Data;
    public string SomeString;
}

List<MyGenericType<dynamic>> myList = new List<MyGenericType<dynamic>>();
myList.Add(new MyGenericType<dynamic>(){ Data = "my string" });
myList.Add(new MyGenericType<dynamic>(){ Data = null });
myList.Add(new MyGenericType<dynamic>(){ Data = new EvenOtherType() });