C#如何实现兼具指定基类与接口的类型约束？含混合数组场景

我正在使用无法修改的第三方类库Godot，自定义类均继承自该库中的类，但并非继承同一类，而是拥有共同的祖先类Node2D。我希望编写工具方法，接收这些自定义类并调用其共同基类的方法。

为自定义类添加ICommon接口来定义通用方法很容易，但无法同时要求类型必须继承指定基类。类层级结构如下：

Node (API class)
|
+-Node2D (API class)
  |
  +-RigidBody2D (API class)
  | |
  | +-MyClassA : ICommon (自定义类+接口)
  |
  +-Area2D (API class)
    |
    +-MyClassB : ICommon (自定义类+接口)

我需要编写方法接收ICommon类型，但同时要求该类型必须继承Node2D。目前想到的唯一方法是使用泛型：

T MyMethod<T>(T arg) where T : Node2D, ICommon

但这种方式十分繁琐，且无法满足返回其他同样兼具Node2D与ICommon约束的类型的需求；另外，若要处理混合数组（如同时包含MyClassA和MyClassB的数组），泛型方法：

T[] OtherMethod<T>(T[] arg) where T : Node2D, ICommon

也无法实现，因为它要求数组元素为同一类。请问是否有更优的解决方案？

1. 封装双重约束的包装器类 #

创建通用包装类，内部持有同时满足Node2D和ICommon的实例，对外统一暴露两者的方法，完美适配混合类型场景：

public class Node2DCommonWrapper
{
    public Node2D Node2DInstance { get; }
    public ICommon CommonInstance { get; }

    public Node2DCommonWrapper(Node2D node)
    {
        if (node is not ICommon common)
            throw new ArgumentException("节点必须实现ICommon接口");
        
        Node2DInstance = node;
        CommonInstance = common;
    }

    // 可直接封装常用的组合逻辑，避免重复类型检查
    public void ExecuteCombinedLogic()
    {
        // 调用Node2D基类方法
        Node2DInstance.Position = new Vector2(0, 0);
        // 调用ICommon自定义方法
        CommonInstance.DoCommonAction();
    }
}

使用示例：

var mixedNodes = new Node2D[] { myClassAInstance, myClassBInstance };
var wrappedList = mixedNodes.Select(n => new Node2DCommonWrapper(n)).ToList();

foreach (var wrapper in wrappedList)
{
    wrapper.ExecuteCombinedLogic();
}

2. 利用模式匹配简化类型校验 #

无需额外类，直接在方法中通过模式匹配同时验证两种类型，处理混合数组时直接遍历即可：

public void ProcessMixedNodes(IEnumerable<Node2D> nodes)
{
    foreach (var node in nodes)
    {
        if (node is ICommon commonNode)
        {
            // 直接调用Node2D的方法
            node.Rotation = 0;
            // 直接调用ICommon的方法
            commonNode.DoCommonAction();
        }
        // 可添加else分支处理不符合条件的节点
    }
}

3. 扩展方法结合动态调用 #

给Node2D编写带双重约束的扩展方法，处理单个实例时类型安全，处理混合数组时通过动态调用绕开编译时类型限制：

public static class Node2DCommonExtensions
{
    public static void ProcessAsCommon<T>(this T node) where T : Node2D, ICommon
    {
        node.Scale = new Vector2(1,1);
        node.DoCommonAction();
    }
}

使用示例：

var mixedNodes = new Node2D[] { myClassA, myClassB };
foreach (var node in mixedNodes.OfType<ICommon>().Cast<Node2D>())
{
    (node as dynamic).ProcessAsCommon();
}

注意：此方式会牺牲部分编译时类型安全，适合对代码简洁性要求较高的场景。

方案对比 #

• 包装器类：类型安全最高，代码结构清晰，适合频繁复用的场景，但需要额外的包装操作。
• 模式匹配：最简洁，无需额外代码，适合简单逻辑处理，灵活性强。
• 扩展方法：保留泛型的约束优势，同时能处理混合集合，但失去部分编译时安全。

内容的提问来源于stack exchange，提问作者Lee