Ereditabile solo all'interno dell'assieme in C#

Question

In C# Esiste un modo per specificare una classe che deve essere ereditata solo da una classe presente nello stesso assembly e che per altri assiemi dovrebbe comportarsi come un tipo sealed pubblico.

Answer 1

Credo che Eric Lippert ottiene le quotazioni che definiscono qui:

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

Answer 2

No. Non esiste una tale disposizione nel linguaggio C# stesso. Tuttavia, soluzioni alternative, come suggerito da altri qui, potrebbero essere sufficienti.

Answer 3

Il linguaggio stesso non ha nulla che lo renda facile, ma dovresti essere in grado di farlo rendendo i tuoi costruttori interni. Se lo fai, tuttavia, non potrai rinnovarlo dagli assembly esterni, quindi dovrai aggiungere un metodo factory.

public class Foo 
{ 
    internal Foo() 
    { 
    } 

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

Ecco un'alternativa che consente di nuovo la classe in assembly esterni

public sealed class Foo : FooBase 
{ 

} 

public class FooBase 
{ 
    internal FooBase() { } 
} 

Una domanda si potrebbe chiedere a te stesso, tuttavia, è esattamente perché si desidera la classe da sigillare. A volte è inevitabile, ma ho visto la parola chiave sealed venire maltrattata così spesso che ho pensato di farla apparire. Spesso gli sviluppatori sigillano le classi perché sono iperprotettivi del loro codice. La maggior parte delle volte, se una classe è ben progettata, non ha bisogno di essere sigillata.

Answer 4

Se la classe è astratta, c'è un modo molto semplice per farlo:

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

Ora, anche se la classe e la maggior parte dei membri sono pubblici, il membro astratto interna rende impossibile derivare dalla classe fuori della vostra montaggio.

Answer 5

Non puoi farlo con costrutti del linguaggio, ma cercare con la riflessione

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

Controllato in su. Sembra funzionare. L'unico problema è che a meno che qualcuno legga la documentazione, il problema è noto al runtime.

Answer 6

L'unico modo che posso pensare sarebbe quella di utilizzare un wrapper pubblica su una classe interna, probabilmente con un'interfaccia comune:

public interface IFoo 
{ 
} 

internal class Foo : IFoo 
{ 
} 

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

Answer 7

I so che questo è un vecchio post, ma ho trovato un altro modo che funziona davvero bene e volevo pubblicarlo per altre persone.

1. Creare una classe base con un costruttore interno.
2. Rendi le tue classi derivate ereditate dalla classe base ed essere sigillate.

`` ``

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 
} 

`` ``