Inheritable nur innerhalb der Assembly in C#

Question

In C# Gibt es eine Möglichkeit, eine Klasse anzugeben, die nur von einer Klasse geerbt wird, die in derselben Assembly vorhanden ist, und sich für andere Assemblys wie ein öffentlicher versiegelter Typ verhält.

Answer 1

denke ich, Eric Lippert die bestimmenden Zitate hier bekommt:

• Preventing third-party derivation part one
• Preventing third-party derivation part two

Answer 2

Nein. In der C# -Sprache gibt es keine solche Bestimmung. Allerdings können Umgehungslösungen - wie von anderen hier vorgeschlagen - ausreichen.

Answer 3

Die Sprache selbst hat nichts, was dies einfach macht, aber Sie sollten dies tun können, indem Sie Ihre Konstruktoren intern machen. Wenn Sie dies jedoch tun, können Sie es nicht von externen Assemblys neu erstellen, daher müssen Sie eine Factory-Methode hinzufügen.

public class Foo 
{ 
    internal Foo() 
    { 
    } 

    public Foo Create() 
    { 
     return new Foo(); 
    } 
} 

Hier ist eine Alternative, die Sie neu, um die Klasse in externen Baugruppen

public sealed class Foo : FooBase 
{ 

} 

public class FooBase 
{ 
    internal FooBase() { } 
} 

Eine Frage, können Sie sich vielleicht fragen, ist jedoch genau warum Sie die Klasse wollen versiegelt werden. Manchmal ist es unvermeidlich, aber ich habe gesehen, dass das Stichwort sealed so oft missbraucht wurde, dass ich dachte, ich würde es aufbringen. Oft schließen Entwickler Klassen ab, weil sie ihren Code zu sehr schützen. Die meiste Zeit, wenn eine Klasse gut entworfen ist, muss sie nicht versiegelt werden.

Answer 4

Wenn Ihre Klasse abstrakt ist, gibt es eine sehr einfache Art und Weise, es zu tun:

public abstract class Foo { 
    internal abstract void DoNothing(); 
    // ... other members 
} 

Nun, obwohl die Klasse und die meisten Mitglieder der Öffentlichkeit sind, das interne abstrakte Mitglied macht es unmöglich, aus der Klasse abzuleiten außerhalb Versammlung.

Answer 5

Sie nicht, dass mit Sprachkonstrukte tun, sondern versuchen, mit Reflexion

public class MyClass{ 
    public MyClass(){ 
    if(this.GetType().Assembly != typeof(MyClass).Assembly){ 
     throw new Exception("Can't derive from this type!"); 
    } 
} 

Karo es auf. Scheint zu arbeiten. Das einzige Problem ist, dass, wenn jemand Dokumentation liest, das Problem zur Laufzeit bekannt ist.

Answer 6

Die einzige Möglichkeit, die ich denken kann würde eine öffentliche Wrapper auf eine interne Klasse zu verwenden, wahrscheinlich mit einer gemeinsamen Schnittstelle:

public interface IFoo 
{ 
} 

internal class Foo : IFoo 
{ 
} 

public sealed class PublicFoo : IFoo 
{ 
    private Foo m_Foo = new Foo(); 
} 

Answer 7

I Ich weiß, das ist ein alter Post, aber ich habe einen anderen Weg gefunden, der wirklich gut funktioniert, und ich wollte ihn für andere Leute veröffentlichen.

1. Erstellen Sie eine Basisklasse mit einem internen Konstruktor.
2. Lassen Sie Ihre abgeleiteten Klassen von der Basisklasse erben und versiegeln.

`` ``

public abstract class LockResult { 
    internal LockResult() { 

    } 
} 

public sealed class LockSucceededResult : LockResult { 
    //Info for when a lock succeeded 
} 

public sealed class LockFailedResult : LockResult { 
    //Info for when a lock failed 
} 

`` ``