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

Question

У меня есть общая сборка/проект, который имеет абстрактный базовый класс, а затем несколько производных классов, которые я хочу публиковать в других сборках.

Я не хочу, абстрактный базовый класс, чтобы показать в этих других сборок в Intellisense, поэтому я думал, что сделать это internal, но я получаю эту ошибку:

Inconsistent accessibility: base class 'Settings' is less accessible than class 'IrcSettings' ....

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

Как я могу сделать этот класс internal?

Answer 1

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

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

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

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

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

Answer 2

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

Answer 3

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

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

[assembly:InternalsVisibleTo("cs_friend_assemblies_2")] 

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

Answer 4

Вы не можете одновременно сделать класс доступным для других сборок для наследования, но также и частным, чтобы он не мог быть видимым для других потребителей. Вы можете сделать класс внутренним и выставить его на определенную сборку (если это сборка друзей), используя атрибут [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 не всегда уважая этот атрибут.

Answer 5

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

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

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

Помогло ли это?

Answer 6

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

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

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

Answer 7

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

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 полностью, если общественность не нужно знать об этом, и ваши внутренности не либо.