在 C# 中创建复合泛型子类型的泛型列表

Question

我已经实现了以下分层数据结构：Tree → Branch → T。

更新：很多人问：为什么不使用 object 而不是 （或 或其他）？所以我修改了我的问题以说明我的“限制”。我们开始...

这里是示例Trees：

*
├─Negative
│ ├─-2
├─0
│ ├─0
├─Positive
│ ├─2
│ ├─12
│ ├─2147483647

*
├─Spring
│ ├─Mar
│ ├─Apr
│ ├─May
├─Summer
│ ├─Jun
│ ├─Jul
│ ├─Aug
├─Fall
│ ├─Sep
│ ├─Oct
│ ├─Nov
├─Winter
│ ├─Dec
│ ├─Jan
│ ├─Feb

C#中的实现：

public class Tree<T>
{
    public readonly List<Branch<T>> Branches = new List<Branch<T>>();
}

public class Branch<T>
{
    public readonly List<T> Leaves = new List<T>();
    public string Name { get; set; }
}

public class StringLeaf
{
    public StringLeaf(string value) { Label = value; }
    public string Label { get; private set; }
    public override string ToString() { return Label; }
}

public class PositiveIntLeaf
{
    private readonly int _value;
    public PositiveIntLeaf(int value) { _value = value; }

    public string Value
    {
        get { return _value < 0 ? "-" : _value.ToString(); }
    }
    public override string ToString() { return Value; }
}

public class IntTree : Tree<IntLeaf>
{
    private readonly Branch<IntLeaf> _negatives = new Branch<IntLeaf> { Name = "Negative" };
    private readonly Branch<IntLeaf> _zeros = new Branch<IntLeaf> { Name = "0" };
    private readonly Branch<IntLeaf> _positives = new Branch<IntLeaf> { Name = "Positive" };

    public IntTree()
    {
        Branches.AddRange(new []{
            _negatives,
            _zeros,
            _positives
        });
    }

    public void Add(int value)
    {
        if (value < 0) _negatives.Leaves.Add(new IntLeaf(value));
        else if (value > 0) _positives.Leaves.Add(new IntLeaf(value));
        else _zeros.Leaves.Add(new IntLeaf(value));
    }
}

假设我有不同的树，我无法将它们放入列表中：

IntTreeintTree = new IntTree();
intTree.Add(-2); intTree.Add(2); intTree.Add(0); intTree.Add(12); intTree.Add(int.MaxValue);
Tree<StringLeaf> months = new Tree<StringLeaf>{ Branches =
{
    new Branch<StringLeaf> { Name = "Spring", Leaves = { new StringLeaf( "Mar"),new StringLeaf("Apr") ,new StringLeaf("May")} },
    new Branch<StringLeaf> { Name = "Summer", Leaves = {  new StringLeaf( "Jun"),new StringLeaf("Jul") ,new StringLeaf("Aug")} },
    new Branch<StringLeaf> { Name = "Fall", Leaves = { new StringLeaf( "Sep"),new StringLeaf("Oct") ,new StringLeaf("Nov")} },
    new Branch<StringLeaf> { Name = "Winter", Leaves = { new StringLeaf( "Dec"),new StringLeaf("Jan") ,new StringLeaf("Feb")} }
}};

var list = new [] { intTree, months };
var currentTree = list[0];
// Work with the current tree:
var count = currentTree.Branches.Count;
Display(currentTree);

错误是：没有为隐式类型数组找到最佳类型

如何从所有这些树中获取列表？

我想强调一下，我只是想把它们放在一个列表中，也许遍历它并访问当前树和所有它的分支（例如显示他们的名字）。我不在乎 T 是对象还是抽象基类！假设我只是打电话给.ToString()。具体类型对于像IntTree 这样的子类型很重要。

Answer 1

你真的不能。这是泛型中称为协变和逆变的问题。 你不能把长颈鹿和老虎塞进动物列表中，并希望一切都会好起来，因为你的收藏是动物列表。

关于这个问题的文章太多了，我就不详细描述了。只需查看MSDN 或谷歌其他文章。

Answer 2

一个共同的集合将知道只一种类型的元素。就像List<int> 知道它的元素是int，List<T> 知道它的元素是T。

所以，如果你知道你所有的树都是相同的类型，但你不知道哪个，你必须从那个类型中抽象出来：

class MyTreeHandler<T>
{
    public List<Tree<T>> myListOfTrees = new List<Tree<T>>();
}

和“给你”。当然，当尝试将异类树放入该列表时它不会起作用，因为T 是一种类型的项目。

因此，由于像 List 这样的集合只知道其项目的一种类型，因此在您将异构对象放入一个公共列表/集合之前，您必须找到所有对象的“共同点”。

最简单的公分母是object，当然是。因此，最愚蠢且始终有效的方法是：

List<object>

你可以在那里放置任何树。

但是，当然，您也不想听到它。这只是为了向您展示共同点。

你的树有什么共同点？正如你所介绍的 - 没有。当然，它们是Trees<T> aka Tree``1（应该是一个反引号，但我不知道如何在这里写），但请注意，除了极少数情况，您不能在 C# 中使用未参数化类型 Tree<>。而且，你不能使用Tree<T> 而不将 T 定义为某事。在您定义它之后，Tree<T1> 和 Tree<T2> 将被视为两个单独的类层次结构，除非 T1==T2 或除非您使用一些 in/out 方差说明符（如 IEnumerable<out> 那样，因此 IEnumerable<Kangaroo> 可转换为IEnumerable<object>）。我假设你想要一个混合方差，所以不是一个选项。但是，如果您希望您的树是仅输入或仅输出，请立即使用协/逆变说明符！

所以，让我们离开泛型及其变体。为了提供 C# 语言/编译器可以理解的通用基础，您必须引入更多 .. 基本的东西。

object 以外的常见abstract 基数，一些常见的interface。任何你认为最不脏的东西。

当我真的不得不混合和存储不同类型的泛型时，我通常会引入一个简单的双接口：

public interface IMyThing //Typeless
{
    Type TypeParam {get;}

    object Operation(object a);
    object Property {get;set;}
}

public interface IMyThing<T> //TypeD
{
    T Operation(T a);
    T Property {get;set;}
}

public class MyThing<T> : IMyThing<T>, IMyThing
{
    public T Operation(T a) { .. }
    public T Property {get;set;}

    Type IMyThing.TypeParam {get{return typeof(T);}}
    object IMyThing.Operation(object a){return this.Operation((T)a);}
    object IMyThing.Property {get{return this.Property;}set{this.Property=(T)value;}}
}

现在我可以将所有事物转换为常见的 IMyThing 并将它们存储为混合的、无类型的 List<IMyThing>。由于显式接口实现，除非我实际转换它，否则我不会看到任何“无类型”成员，因此其他 T 感知位置将看起来像往常一样。

但是，当我必须混合类型时，我现在可以将它们转换为通用的无类型接口，并且由于该接口，我仍然可以访问操作/属性。假设我会以某种方式保证 args 可以转换为正确的 T。但我总是可以检查 TypeParam 并手动处理它。

所以，纯属讨厌。尽管感觉不对，但请注意 IEnumerable<T> 和 IEnumerable 的做法完全相同！

为dynamic 哭泣，但实际上，没有动态（即拥有没有 DLR 的 .Net 3.5 平台？）几乎没有其他解决方案的空间。

Answer 3

另一种方法是使用dynamic 类型。请尝试以下操作：

static void Main(string[] args)
{
    Tree<dynamic> intTree = CreateTree<dynamic>
        (1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 12, 15);
    Tree<dynamic> charTree = CreateTree<dynamic>
        ('1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'C', 'E');
    Tree<dynamic> months = CreateTree<dynamic>
        ("Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec");
    IEnumerable<Tree<object>> list = 
        new List<Tree<object>> { intTree, charTree, months };
}

private static Tree<T> CreateTree<T>(params T[] values)
{
    var t = new Tree<T>();
    var b = new Branch<T>();

    // some branching logic
    for (int i = 0; i < values.Length; i++)
    {
        if (i % 4 == 3)
        {
            b.Leaves.Add(values[i]);
            t.Branches.Add(b);
            b = new Branch<T>();
        }
        else

            b.Leaves.Add(values[i]);
    }
    if (b.Leaves.Count != 0)
        t.Branches.Add(b);

    return t;
}

你也可以为你的目的创建一个扩展方法：

public static Tree<dynamic> MakeDynamic<T>(this Tree<T> inputTree)
{
    var newTree = new Tree<dynamic>();
    for (int i = 0; i < inputTree.Branches.Count; i++)
    {
        var newBranch=new Branch<dynamic>();
        newTree.Branches.Add(newBranch);
        for (int j = 0; j < inputTree.Branches[i].Leaves.Count; j++)
        {
            dynamic d = inputTree.Branches[i].Leaves[j];
            inputTree.Branches[i].Leaves[j] = d;
        }
    }
    return newTree;
}

在后一种情况下，您可以保留原始类型并使用以下示例：

IEnumerable<Tree<object>> list = new List<Tree<object>> { 
    intTree.MakeDynamic(), 
    charTree.MakeDynamic(), 
    months.MakeDynamic() 
};