Предоставить реализацию абстрактного метода из интерфейса

Можно ли переопределить реализацию метода, наследуя интерфейс, который дает реализацию по умолчанию для этого метода? Если нет, то как мне реструктурировать свой код, чтобы избежать явных вызовов методов реализации интерфейса?

Вот обзор структуры классов в моем проекте:

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; }
}

Моя цель — предоставить реализацию ProcessInputs внутри IComponentContainer интерфейса, поскольку все контейнеры компонентов должны обрабатывать входные данные каждого из своих компонентов, и реализация для этого может быть общей для всех производных классов.

Чтобы добиться этого, я попытался создать реализацию метода по умолчанию для ProcessInputs внутри IComponentContainer, например:

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

    ProcessInputsResult IInputProcessor.ProcessInputs(Item[] inputs)
    {
        ...
    }
}

Обратите внимание, что я также сделал IComponentContainer производным от IInputProcessor, поскольку все контейнеры компонентов должны обрабатывать входные данные для всех своих компонентов.

Я надеялся, что это новое определение будет означать, что MachineSystem, который является одновременно MachineComponent и IComponentContainer<MachineComponent>, не нужно будет указывать реализацию для MachineComponent.ProcessInputs, поскольку она задана в интерфейсе IComponentContainer.

Это было не так, и мне пришлось явно сослаться на реализацию метода, указанную в интерфейсе, вот так:

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

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

Я думаю, что это противоречит цели предоставления реализации по умолчанию в интерфейсе, поскольку производные классы должны указывать, что они хотят ее использовать.

Есть ли хорошее решение этой проблемы или мне следует изменить структуру кода?

ОБНОВЛЕНИЕ: В ответ на ответ Ивана Петрова

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

class ComponentContainer<T> : MachineComponent, IComponentContainer<T> 
where T : MachineComponent {
    public T[] Components { get; }
    public override ProcessInputsResult ProcessInputs(Item[] inputs) {
    // implementation will serve for interface method too
    }
}

class MachineSystem : ComponentContainer<MachineComponent> {
    // we can still override ProcessInputsResult here too
}

Использование общего базового класса для реализации обработки контейнера компонентов в моей ситуации не сработало бы, поскольку классы, реализующие IComponentContainer и все производные от абстрактного класса MachineComponent, находятся на разных уровнях иерархии классов. Например, MachineSystem : IComponentContainer<MachineComponent> наследует MachineComponent напрямую, тогда как CompositeComponent : IComponentContainer<SimpleComponent> наследует другой класс SimpleComponent, который, в свою очередь, является производным от MachineComponent. По этой причине использование одного базового класса, от которого все они происходят, наложит на них одну и ту же иерархию. Эту проблему можно было бы легко решить, если бы были возможны общие типы наследования, например:

class ComponentContainer<TContainer, TBase> : TBase, IComponentContainer<TContainer> 
where TContainer : MachineComponent 
where TBase : MachineComponent 
{
    public T[] Components { get; }
    public override ProcessInputsResult ProcessInputs(Item[] inputs) 
    {
        ...
    }
}

Но поскольку это не поддерживается, я не вижу способа заставить его работать с общим базовым классом.