Неявное внедрение зависимости в базовый класс, в то время как производный класс разрешается через Unity

Нет, единство этого сделать не может. На самом деле, нет ни одного контейнера, который мог бы это сделать. Конструктор предназначен для создания экземпляра класса. Если вы вызовете два конструктора, у вас будет два экземпляра. Если базовый класс является абстрактным, вы даже не можете вызвать его конструктор (кроме производных конструкторов, как вы знаете).

Таким образом, из-за ограничений C # .net, если вы хотите использовать внедрение конструктора, он будет работать только в том случае, если вы явно вставите значение в конструктор Derived, который вызывает конструктор Base, отличный от используемого по умолчанию.

Однако вместо этого вы можете использовать внедрение свойств или методов. С их помощью вам не нужно добавлять зависимость к каждому конструктору производного класса.

Внедрение свойств:

class Base
{
    [Dependency]
    public IDep Dep { get; set; }
} 

Внедрение метода:

class Base
{
     private IDep dep;

     [InjectionMethod]
     public void Initialize(IDep dep)
     {
         this.dep = dep;
     }
}

Пожалуйста, обрати внимание:

• Объект создается (внедрение ctor) до того, как будет выполнено внедрение метода / свойства.
• Возможно, будет достаточно адаптировать дизайн так, чтобы базовый класс не требовался, см. Композиция вместо наследования

Вот как вы должны решить проблему:

class abstract Base : IBase
{
    private readonly IDep dep;

    protected Base(IDep dep)
    {
        if (dep == null) throw new ArgumentNullException("dep");
        this.dep = dep;
    }
}

Теперь у вашего базового класса есть только один конструктор, и этот конструктор определяет все зависимости, которые требуются классу. Есть только один способ создать этот класс, и этот класс будет защищать свои инварианты. Зависимость помещается в частное поле, поскольку другие классы не могут использовать эту зависимость.

С этим базовым классом производный класс будет выглядеть так:

class Derived : Base
{
    private readonly IDep dep;

    public Derived(IDep dep) : base(dep)
    {
        this.dep = dep;
    }
}

Здесь производный класс также имеет один единственный конструктор, определяющий зависимости, необходимые для этого класса. По-другому его не создать. В случае, если класс использует саму зависимость, он должен сохранить зависимость в частном поле для дальнейшего использования. Также обратите внимание, что, поскольку этот класс имеет только один конструктор, нет никакой двусмысленности в том, какой конструктор вызывать, и нет причин отмечать конструктор атрибутом [InjectionConstructor].

Обратите внимание, что я согласен с BatteryBackupUnit. Поскольку я применяю к своим приложениям внедрение зависимостей и принципы SOLID, я не вижу причин для дальнейшего использования базовых классов. Использование композиции вместо наследования часто снижает сложность системы.

Простое и прямое решение - иметь «InjectionMethod» в вашем базовом классе.

> public abstract class Base : IBase
>     {
> 
>         private IDep dep;
> 
>         [InjectionMethod]
>         public void Initialize(IDep dep)
>         {
>             if (dep == null) throw new ArgumentNullException("dep");
>             this.dep = dep;
> 
>             OnInitialize();
>         }
> 
>         public dep DepProperty
>         {
>             get
>             {
>                 return dep;
>             }
>         }
>         protected abstract void OnInitialize();
>     }

// теперь ваш конструктор производного класса не будет вынужден иметь параметр IDep

class Derived : Base
{
    public Derived()
    {

    }

    protected override void OnInitialize()
    {
        // you can access the baseclass dependency Instance in this override
        object depObject = this.DepProperty;
    }
}