Внутренний абстрактный класс: как скрыть использование вне сборки?

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

Способ сделать это - сделать абстрактный базовый класс общедоступным, но дать ему внутренний конструктор по умолчанию:

public abstract class MyClass
{
    internal MyClass() { }
}

Это позволит MyClass (и, следовательно, его членам) быть видимыми и доступными для классов вне вашей сборки, но классы вне вашей сборки не могут наследовать от него (получат ошибку компиляции).

Изменить: если классы, которые могут быть видны внешними сборками, наследуются от MyClass, вы не можете запретить MyClass также видеть - например, отображаться в Intellisense. Однако вы можете предотвратить их использование, выполнив указанные выше действия.

Абстрактный базовый класс должен быть общедоступным, поскольку должна быть видна вся иерархия наследования для класса. Это гарантирует, что полиморфизм работает и действителен; однако все члены базовых классов могут быть внутренними (включая конструктор) и, следовательно, не могут использоваться за пределами вашей сборки

На самом деле нет особой выгоды в том, чего вы пытаетесь достичь, но то, чего вы на самом деле хотите достичь, похоже на это.

Создайте абстрактный базовый класс в одной сборке со всем внутренним. В AssemblyInfo для этой сборки вам нужно добавить

[assembly:InternalsVisibleTo("cs_friend_assemblies_2")]

Затем в другой сборке у вас есть все классы, которые вы хотите сделать общедоступными. Обратите внимание, что вы по-прежнему сможете получить доступ к базовому классу из intellisense для любого кода внутри cs_friend_assemblies_2 или того, как вы называете свою сборку, но не где-либо еще.

Вы не можете одновременно сделать класс доступным для других сборок для наследования, но также и частным, чтобы он не был виден другим потребителям. Вы можете сделать класс внутренним и предоставить его конкретной сборке (если это дружественная сборка) с помощью атрибута [InternalsVisibleTo], но я не думаю, что это то, что вам нужно.

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

abstract class MyBaseClass
{
    protected MyBaseClass() { ... } // only inheritors can access this...
}

Вы можете скрыть члены класса от Intellisense, используя атрибут EditorBrowsable:

abstract class MyBaseClass
{ 
    [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)]
    public void SomeMethodToBeHidden() { }
}

Следует отметить, что некоторые люди сообщали о проблемах с IDE, которые не всегда соблюдали этот атрибут.

Насколько я понимаю, это не проблема. Наблюдать:

public abstract class Foo {
    public void virtual Bar() {
        // default implementation
    }
}

public class NormalFoo : Foo { }

public class SpecialFoo : Foo {
    public override void Bar() {
        // special implementation
    }
}

var foolist = new List<Foo>();

foolist.Add( new NormalFoo() );
foolist.Add( new SpecialFoo() );

foreach (var f in foolist) {
    f.Bar();
}

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

Будут ли другие сборки унаследованы от вашего абстрактного базового класса или каких-либо общедоступных классов, которые наследуются от вашего абстрактного базового класса?

Если это так, вы должны сделать абстрактный базовый класс общедоступным. Просто сделайте методы, которые вы не хотите видеть вне сборки, внутренними.

Если нет, может, интерфейсы помогут? Определите общедоступные интерфейсы, сделайте так, чтобы ваши общедоступные классы реализовали их, и предоставьте фабрику для получения экземпляров. Таким образом, единственное, что intellisense видит вне сборки, - это интерфейс.

Это помогает?

Способ обойти это ограничение - использовать композицию вместо наследования (есть другие веские причины сделать это тоже). Например, вместо:

internal abstract class MyBase
{
    public virtual void F() {}
    public void G() {}
}

public class MyClass : MyBase // error; inconsistent accessibility
{
    public override void F() { base.F(); /* ... */ }
}

Сделай это:

public interface IMyBase
{
    void F();
}

internal sealed class MyBase2 : IMyBase
{
    public void F() {}
    public void G() {}
}

public sealed class MyClass2 : IMyBase
{
    private readonly MyBase2 _decorated = new MyBase2();
    public void F() { _decorated.F(); /* ... */ }
    public void G() { _decorated.G(); }
}

Вы можете полностью опустить IMyBase интерфейс, если публике не нужно знать о нем и вашим внутренним компонентам тоже.