Unity中如何构建带依赖项的合理继承结构？

直接修改基类Init签名给单个派生类加专属参数的做法是典型的接口污染，会彻底破坏里氏替换原则：后续每新增一个带专属依赖的派生类，你就要给Init加一个新参数，参数列表会越来越臃肿，基类会耦合所有派生类的实现细节，完全失去抽象的意义。以下是Unity开发场景下实际可用的解决方案，按改动成本从低到高排列：

方案1：派生类自行管理专属依赖（推荐优先使用） #

这是最适配Unity工作流、改动量最小的方案，完全不需要调整现有基类和上层调用逻辑：

• 将派生类独有的依赖直接通过[SerializeField]标记在派生类自身，在Inspector面板直接拖入引用，不需要经过Foo类统一传递
• 如果依赖是运行时动态生成的，也可以在派生类重写的Init方法里自行通过GetComponent、FindObjectOfType或者从已有的全局管理器获取
  代码实现：

public class Inheritor2 : Base 
{
    // 直接在Inheritor2组件的Inspector面板拖入对应引用即可
    [SerializeField]
    private Inheritor2Tool _inheritor2Tool;

    public override void Init(BaseTool baseTool)
    {
        base.Init(baseTool);
        // 此处直接使用_inheritor2Tool完成自身初始化即可，不需要额外传参
    }
}

适用场景：绝大多数常规业务开发场景，专属依赖不需要上层调用方感知的情况，也是Unity项目里最通用的做法。

方案2：封装统一初始化上下文 #

如果项目要求所有依赖都由上层调用方统一管控、不允许组件自行查找依赖，可以把所有初始化参数封装成一个上下文对象，一劳永逸解决方法签名频繁变动的问题：

1. 首先定义初始化上下文容器，后续新增任何派生类的专属依赖，都只需要往这个容器里加字段，不需要修改Init方法签名：

public class InitContext
{
    public BaseTool BaseTool;
    public Inheritor2Tool Inheritor2Tool;
    // 后续新增其他派生类依赖直接在这里追加即可
}

2. 修改基类Init方法的参数为上下文类型：

public abstract class Base : MonoBehaviour
{
    protected BaseTool _baseTool;
    
    public virtual void Init(InitContext context)
    {
        _baseTool = context.BaseTool;
    }
}

3. 派生类重写时只取自己需要的参数即可：

public class Inheritor2 : Base 
{
    private Inheritor2Tool _inheritor2Tool;

    public override void Init(InitContext context)
    {
        base.Init(context);
        _inheritor2Tool = context.Inheritor2Tool;
    }
}

4. 上层Foo类调用时只需要统一组装一次上下文：

public class Foo : MonoBehaviour
{
    [SerializeField]
    private Base _base;
    [SerializeField]
    private BaseTool _baseTool;
    [SerializeField]
    private Inheritor2Tool _inheritor2Tool;

    void Start()
    {
        var context = new InitContext
        {
            BaseTool = _baseTool,
            Inheritor2Tool = _inheritor2Tool
        };
        _base.Init(context);
    }
}

适用场景：中大型项目、需要统一管控所有对象初始化依赖的场景，扩展性远优于频繁修改方法签名的做法。

方案3：标记式依赖注入 #

如果项目依赖较多，不想维护臃肿的上下文对象，可以实现轻量的特性注入逻辑，给需要注入的字段打标记，初始化时自动完成赋值：

// 用于标记需要注入字段的特性
[AttributeUsage(AttributeTargets.Field, AllowMultiple = false)]
public class InjectAttribute : Attribute { }

// 简易注入器实现
public static class Injector
{
    public static void Inject(MonoBehaviour target, Dictionary<Type, object> dependencyContainer)
    {
        var fields = target.GetType().GetFields(BindingFlags.Instance | BindingFlags.NonPublic | BindingFlags.Public);
        foreach (var field in fields)
        {
            if (field.GetCustomAttribute<InjectAttribute>() != null && dependencyContainer.TryGetValue(field.FieldType, out var value))
            {
                field.SetValue(target, value);
            }
        }
    }
}

基类和派生类实现时只需要给依赖字段打[Inject]标记即可，不需要手写赋值逻辑：

public abstract class Base : MonoBehaviour
{
    [Inject]
    protected BaseTool _baseTool;
    
    public virtual void Init(Dictionary<Type, object> container)
    {
        Injector.Inject(this, container);
    }
}

public class Inheritor2 : Base 
{
    [Inject]
    private Inheritor2Tool _inheritor2Tool;

    public override void Init(Dictionary<Type, object> container)
    {
        base.Init(container);
        // 不需要额外处理_inheritor2Tool的赋值，注入逻辑会自动完成
    }
}

适用场景：大型项目、依赖关系复杂的场景，注意这种方案有极少量的反射性能开销，对绝大多数业务逻辑来说完全可以忽略。

❌ 绝对不要为了单个派生类的需求修改基类Init方法签名、追加专属参数：这种做法会让基类耦合所有派生类的实现细节，完全违背抽象类的设计初衷，后续维护成本会指数级上升。

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