Heredable solo dentro del ensamblaje en C#

Question

En C# ¿Hay manera de especificar una clase para que sea heredada solo por una clase presente en el mismo ensamblaje y para otros ensamblajes debe comportarse como un tipo sellado público.

Answer 1

Creo que Eric Lippert pone las comillas que definen aquí:

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

Answer 2

No. No existe tal disposición en el lenguaje C# en sí. Sin embargo, las soluciones alternativas (como sugieren otros aquí) pueden ser suficientes.

Answer 3

El lenguaje en sí no tiene nada que lo haga fácil, pero debería poder hacer esto haciendo que sus constructores sean internos. Sin embargo, si hace esto, no podrá actualizarlo desde conjuntos externos, por lo que deberá agregar un método de fábrica.

public class Foo 
{ 
    internal Foo() 
    { 
    } 

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

Aquí es una alternativa que le permite nuevo a la clase de montajes externos

public sealed class Foo : FooBase 
{ 

} 

public class FooBase 
{ 
    internal FooBase() { } 
} 

Una pregunta que cabe preguntarse, sin embargo, es exactamente qué desea que la clase para ser sellado. A veces es inevitable, pero he visto abusar tan a menudo de la palabra clave sealed que pensé que lo sacaría. A menudo, los desarrolladores sellarán clases porque son sobreprotectores de su código. La mayoría de las veces, si una clase está bien diseñada, no es necesario sellarla.

Answer 4

Si la clase es abstracta, no hay una forma muy sencilla de hacerlo:

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

Ahora bien, aunque su clase y la mayoría de los miembros son públicos, el miembro abstracta interna hace que sea imposible derivar de la clase fuera de su montaje.

Answer 5

No se puede hacer eso con las construcciones del lenguaje, pero tratar con la reflexión

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

comprobado hacia arriba. Parece estar funcionando. El único problema es que, a menos que alguien lea la documentación, el problema se conoce en tiempo de ejecución.

Answer 6

La única manera que puedo pensar sería utilizar un envoltorio pública en una clase interna, probablemente con una interfaz común:

public interface IFoo 
{ 
} 

internal class Foo : IFoo 
{ 
} 

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

Answer 7

I Sé que esta es una publicación anterior, pero encontré otra manera que funciona muy bien y quise publicarla para otras personas.

1. Haz una clase base con un constructor interno.
2. Haga que sus clases derivadas hereden de la clase base y se sellen.

`` ``

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 
} 

`` ``