指定“任何子类”在 C# 类型约束中而不是“一个特定子类”

Question

如果我想编写一个采用可变数量的“TDerived”的方法，其中 TDerived 是“Base”类的任何子类，有什么方法可以做到这一点？

以下代码仅适用于单个特定的指定子类：

void doStuff<TDerived>(params TDerived[] args) where TDerived : Base
{
    //stuff
}

即，如果我有

class Super { }
class Sub0 : Super { }
class Sub1 : Super { }

，那么我无法执行此操作，

Sub0 s0 = new Sub0();
Sub1 s1 = new Sub1();
doStuff(s0, s1);

因为我得到“最佳重载匹配...有一些无效参数”。

无论编译器如何处理类型约束和可变参数函数，这似乎（据我所知）完全类型安全。我知道我可以进行强制转换，但如果这是类型安全的，为什么不允许它呢？

编辑：

也许一个更有说服力的例子：

void doStuff<TDerived>(params SomeReadOnlyCollection<TDerived>[] args) where TDerived : Base
{
    foreach(var list in args)
    {
        foreach(TDerived thing in list)
        {
            //stuff
        }
    }
}

Answer 1

TDerived 需要能够解析为单一类型。在您的示例中，它可以解析的唯一类型是Super，但编译器不会实现这一飞跃。您可以让编译器实现这一飞跃。

doStuff(new Super[] { s0, s1 });
doStuff<Super>(s0, s1);

---

关于您的更新，请考虑（而不是通用方法）定义一个接受 IEnumerable 的方法，该方法将支持派生类型，因为 IEnumerable code> 是协变的（从 .NET 4 开始）。 IEnumerable 本质上也是只读和只进的，如果您有 foreach 循环，则非常完美。完整的工作示例：

class Program
{
    static void Main()
    {
        var sub0s = new Sub0[] { new Sub0() };
        var sub1s = new List<Sub1> { new Sub1() };
        doStuff(sub0s, sub1s);
    }

    static void doStuff(params IEnumerable<ISuper>[] args)
    {
        foreach (var sequence in args)
        {
            foreach (var obj in sequence)
            {
                Console.WriteLine(obj.GetType());
                // you have the ability to invoke any method or access 
                // any property defined on ISuper
            }
        }
    } 
}

interface ISuper { }
class Super : ISuper { }
class Sub0 : Super { }
class Sub1 : Super { }  

IEnumerable 从 .NET 2.0 开始由 BCL 集合实现，包括 T[]、List、< code>ReadOnlyCollection、HashSet 等。

Answer 2

在您的示例中，您实际上是在告诉编译器，doStuff 的所有参数在编译时必须具有相同类型，并且该类型必须从 Base 继承。如果您想允许参数具有不同类型，那么就不要使用泛型：

void doStuff(params Base[] args)
{}

编辑

这同样适用于您的新示例 - 而不是您的特定SomeReadOnlyCollection可以使用 IEnumerable，因为它是协变 :

void doStuff(params IEnumerable<Base>[] args)
{
    foreach (var list in args)
    {
        foreach (var thing in list)
        {
        }
    }
}

Answer 3

好吧，你当然可以更改

Sub0 s0 = new Sub0();
Sub1 s1 = new Sub1();

为

Super s0 = new Sub0();
Super s1 = new Sub1();

，然后如果 Super 是 TDerived 就可以了。

我可能会误解您的意思，但使方法采用基类的任何子类的唯一方法是声明该方法以采用对基类型的引用。

Answer 4

您可以使用的另一种替代方法是简单地显式指定通用参数。例如：

var s0 = new Sub0();
var s1 = new Sub1();

doStuff<Super>(s0, s1);

您应该能够对 SomeReadOnlyCollection 的情况应用相同的原则，只要它是 协变。例如，IEnumerable就是这样一个集合：

static void doStuff2<TDerived>(params IEnumerable<TDerived>[] args) where TDerived : Super {
    // ...
}

// ...

var l0 = new List<Sub0>();
var l1 = new List<Sub1>();

doStuff2<Super>(l0, l1);