Tengo el código fuente que recibí de un desarrollador externo, este código se divide en 4 tipos de proyectos: su marco, el entorno para mi proyecto (llamémoslo "ENV"), la base de la aplicación (llámelo "Base") y la aplicación en sí (unos 20 dlls llamaré colectivamente "Aplicación").

Ahora, he agregado otra capa a este desastre, un dll con el nombre AdvanceFeatures. Se encuentra justo debajo de ENV (en la parte superior del marco). Este dll no hace referencia a nada más que al marco, y el ENV lo hace referencia. Solo el ENV hace uso de este dll AdvanceFeatures, mientras que Base y App usan solo el ENV.

La forma en que estoy trabajando aquí es que la mayoría de los objetos en la aplicación se definen en Base y heredan / implementan clases / interfaces en ENV. También una pequeña parte de esos objetos (en App y Base) heredan / implementan clases / interfaces del propio framework (pero esto es bastante raro).

Hasta ahora todo está bien, aparte de un hecho. El compilador exige que agregue una referencia al dll AdvanceFeatures de cada uno de los dlls en la aplicación, y de Base.

No utilizo AdvanceFeatures fuera de ENV, entonces, ¿por qué se necesitan estas referencias?

Edit: he creado un proyecto de demostración para este problema. Estos son los detalles del proyecto:

Assembly: AdvanceFeatures
References: Nothing (Reference project-folder is empty)
Classes: Decorator, IEnvClass, IDecorator
IDecorator contents:
namespace AdvanceFeatures
{
    public interface IDecorator
    {
        IEnvClass Decorated { get; }
        void Decorate();
    }
}

IEnvClass contents: 
namespace AdvanceFeatures
{
    public interface IEnvClass
    {
        string Name { get; set; }
    }
}

Decorator contents:
namespace AdvanceFeatures
{
    public class Decorator : IDecorator
    {

        public Decorator(IEnvClass decorated)
        {
            Decorated = decorated;
        }

        #region Implementation of IDecorator

        public IEnvClass Decorated { get; set; }

        public void Decorate()
        {
            Decorated.Name = "NewName";
        }   

        #endregion
    }
}

Assembly: ENV
References: AdvanceFeatures (Compiled DLL)
Contents of only class SomeEnvClass:

namespace ENV
{
    public class SomeEnvClass : AdvanceFeatures.IEnvClass
    {
        public string Name { get; set; }
        private readonly AdvanceFeatures.IDecorator _decorator;

        public SomeEnvClass(string name)
        {
            Name = name;
            _decorator = new AdvanceFeatures.Decorator(this);
            _decorator.Decorate();
        }

        public string Foo()
        {
            return Name;
        }
    }
}


Assembly: TestBase
References: ENV (compiled DLL)
Contents of only class SomeEnvExtendingClass:

namespace TestBase
{
    public class SomeEnvExtandingClass : ENV.SomeEnvClass
    {
        public SomeEnvExtandingClass(string name) : base(name)
        {
        }
    }
}

Me sale el error:

Error 1 El tipo 'AdvanceFeatures.IEnvClass' se define en un ensamblado al que no se hace referencia. Debe agregar una referencia al ensamblado 'AdvanceFeatures, Version = 1.0.0.0, Culture = neutral, PublicKeyToken = null'. E: \ Proyectos \ Dev \ TestReferenceInheritance \ TestBase \ SomeEnvExtandingClass.cs 3 18 TestBase

Ahora, sé por qué la DLL debe estar disponible para el ejecutable compilado, pero ¿por qué el desarrollador debe conocer el funcionamiento interno de ENV (más específicamente, es el árbol de herencia) para extenderlo?