如何处理递归泛型类继承的类型转换问题？

问题背景 #

现有一个抽象泛型基类ContainerBase<T>：

public abstract class ContainerBase<T>
{
    public Guid Id { get; init; }
    public IList<T> Items { get; set; }
    public bool IsLeaf { get; set; } = false;
    // 省略构造函数等内容
}

随后有一系列数量不确定的具体容器类，每个类都以另一个ContainerBase<...>作为泛型参数T，形成递归嵌套结构：

public class RootContainer : ContainerBase<ChildContainer1>
{...}

public class ChildContainer1: ContainerBase<ChildContainer2>
{...}

public class ChildContainer2: ContainerBase<ChildContainer3>
{...}

// ...

public class ChildContainerNminus1: ContainerBase<ChildContainerN>
{...}

public class ChildContainerN: ContainerBase<int> // 递归终止，叶子节点
{
    ...
    public ChildContainerN()
    {
        IsLeaf = true;
    }
}

现在需要实现ContainerUtility中的查找与添加容器方法，但由于每个层级的ContainerBase<T>泛型参数不同，无法直接统一处理Items集合，导致类型转换和操作受阻。

核心问题 #

递归结构中每个节点都是不同的ContainerBase<具体类型>，泛型参数的差异使得无法用统一类型处理子节点集合，既不能顺畅完成递归查找，也无法在找到父容器后直接添加对应类型的子容器。

解决方案：引入非泛型顶层接口 #

步骤1：定义非泛型接口IContainer #

这个接口暴露所有容器的通用属性和非泛型操作方法，摆脱泛型参数的类型绑定：

public interface IContainer
{
    Guid Id { get; }
    bool IsLeaf { get; }
    // 非泛型添加方法，内部做类型校验
    bool AddItem(object item);
    // 非泛型枚举子节点，用于递归查找
    IEnumerable<IContainer> GetChildren();
}

步骤2：让ContainerBase<T>实现IContainer #

在泛型基类中实现接口方法，内部完成类型转换与验证：

public abstract class ContainerBase<T> : IContainer
{
    public Guid Id { get; init; }
    public IList<T> Items { get; set; } = new List<T>();
    public bool IsLeaf { get; set; } = false;

    // 实现IContainer的AddItem方法
    public bool AddItem(object item)
    {
        if (item is T typedItem)
        {
            Items.Add(typedItem);
            return true;
        }
        return false;
    }

    // 实现IContainer的GetChildren方法
    public IEnumerable<IContainer> GetChildren()
    {
        // 仅当T是IContainer实现类时返回子节点，叶子节点（如T=int）返回空集合
        return Items.OfType<IContainer>();
    }
}

步骤3：重构ContainerUtility方法 #

基于非泛型接口实现递归查找与添加，无需再纠结泛型参数差异：

public static class ContainerUtility
{
    // 查找方法返回统一的IContainer类型
    public static IContainer FindContainer(Guid id, IContainer currentContainer)
    {
        if (currentContainer.Id == id)
            return currentContainer;

        if (currentContainer.IsLeaf)
            return null;

        foreach (var child in currentContainer.GetChildren())
        {
            var potential = FindContainer(id, child);
            if (potential != null)
                return potential;
        }

        return null;
    }

    public static bool AddContainer<T>(ContainerBase<T> container, Guid parentId)
    {
        var parentContainer = FindContainer(parentId, RootContainer.Instance);
        if (parentContainer == null)
            return false;

        // 调用非泛型AddItem，内部自动校验类型合法性
        return parentContainer.AddItem(container);
    }
}

方案优势 #

1. 保留类型安全：AddItem方法内部会验证传入对象是否符合当前容器的泛型参数T，避免非法类型添加。
2. 统一递归逻辑：通过GetChildren统一枚举子容器，无需关心每个节点的具体泛型类型。
3. 扩展性强：新增容器子类时，只要继承ContainerBase<T>就自动实现IContainer接口，无需修改工具类。

注意事项 #

• 叶子节点（如ChildContainerN: ContainerBase<int>）的GetChildren会返回空集合，自然终止递归逻辑。
• AddItem的返回值可用于判断添加是否成功，方便调用方处理类型不匹配等失败场景。

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