接口默认实现能否替代抽象类方法？如何避免显式调用？

问题背景 #

能否通过继承带有默认实现的接口来重写方法？若不能，应如何重构代码以避免显式调用接口的实现？

原始类结构 #

interface IInputProcessor
{
    public ProcessInputsResult ProcessInputs(Item[] inputs);
}

abstract class MachineComponent : IInputProcessor
{
    public abstract ProcessInputsResult ProcessInputs(Item[] inputs);
}

interface IComponentContainer<T> where T : MachineComponent
{
    public T[] Components { get; }
}

class MachineSystem : MachineComponent, IComponentContainer<MachineComponent>
{
    public MachineComponent[] Components { get; }
}

需求与尝试 #

目标是在IComponentContainer接口中提供ProcessInputs的共享实现，因为所有组件容器都需要处理旗下组件的输入，且该逻辑可在派生类间复用。

尝试让IComponentContainer继承IInputProcessor并添加默认方法实现：

interface IComponentContainer<T> : IInputProcessor where T : MachineComponent
{
    public T[] Components { get; }

    ProcessInputsResult IInputProcessor.ProcessInputs(Item[] inputs)
    {
        // 处理组件输入的共享逻辑
    }
}

但继承MachineComponent和IComponentContainer<MachineComponent>的MachineSystem仍必须显式调用接口实现，违背了接口默认实现的初衷：

class MachineSystem : MachineComponent, IComponentContainer<MachineComponent>
{
    // ...

    public override ProcessInputsResult ProcessInputs(Item[] inputs) =>
        ((IComponentContainer<MachineComponent>)this).ProcessInputs(inputs);
}

补充说明 #

使用共享基类的方案不可行，因为实现IComponentContainer的类处于类层次结构的不同层级（例如MachineSystem直接继承MachineComponent，而CompositeComponent继承SimpleComponent，后者派生自MachineComponent），C#不支持泛型基类多继承，无法强制统一层级。

解决方案 #

原因分析 #

在C#中，抽象类的抽象方法优先级高于接口的默认实现。由于MachineComponent实现了IInputProcessor并定义了抽象的ProcessInputs方法，所有继承MachineComponent的子类必须重写该方法，接口的默认实现无法自动满足抽象方法的要求。

可行方案：使用扩展方法封装共享逻辑 #

将组件容器的ProcessInputs共享逻辑提取为静态扩展方法，这样所有实现IComponentContainer的类都可以直接调用，无需显式转换接口类型：

1. 定义扩展方法

public static class ComponentContainerExtensions
{
    public static ProcessInputsResult ProcessContainerInputs<T>(this IComponentContainer<T> container, Item[] inputs) 
        where T : MachineComponent
    {
        // 这里放置原来接口默认实现的共享逻辑
        var finalResult = new ProcessInputsResult();
        foreach (var component in container.Components)
        {
            var componentResult = component.ProcessInputs(inputs);
            // 根据需求合并结果，例如：
            // finalResult.Success &= componentResult.Success;
            // finalResult.Messages.AddRange(componentResult.Messages);
        }
        return finalResult;
    }
}

2. 在子类中调用扩展方法

class MachineSystem : MachineComponent, IComponentContainer<MachineComponent>
{
    public MachineComponent[] Components { get; }

    public override ProcessInputsResult ProcessInputs(Item[] inputs)
    {
        // 直接调用扩展方法，代码简洁且无需显式接口转换
        return this.ProcessContainerInputs(inputs);
    }
}

class CompositeComponent : SimpleComponent, IComponentContainer<SimpleComponent>
{
    public SimpleComponent[] Components { get; }

    public override ProcessInputsResult ProcessInputs(Item[] inputs)
    {
        return this.ProcessContainerInputs(inputs);
    }
}

优势 #

• 共享逻辑集中维护，修改时只需调整扩展方法即可
• 子类调用方式简洁，避免了显式接口转换的冗余代码
• 适配不同层级的类继承结构，无需修改原有类层次

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