Classi e membri delle classi astratte e sealed (Guida per programmatori C#)

  • Articolo

La parola chiave abstract consente di creare classi e membri di classe, che sono incompleti e devono essere implementati in una classe derivata.

La parola chiave sealed consente di impedire l'ereditarietà di una classe o di determinati membri di classe contrassegnati in precedenza come virtuali.

Classi e membri di classi astratte

Una classe può essere dichiarata astratta inserendo la parola chiave abstract prima della definizione della classe. Ad esempio:

public abstract class A
{
    // Class members here.
}

Non è possibile creare un'istanza di una classe astratta. Lo scopo di una classe astratta è quello di fornire una definizione comune di una classe base condivisibile da più classi derivate. Una libreria di classi può, ad esempio, definire una classe astratta utilizzata come parametro per molte funzioni e richiedere ai programmatori che utilizzano tale libreria di fornire un'implementazione personalizzata della classe creando una classe derivata.

Le classi astratte possono inoltre definire metodi astratti aggiungendo la parola chiave abstract prima del tipo restituito del metodo. Ad esempio:

public abstract class A
{
    public abstract void DoWork(int i);
}

I metodi astratti non prevedono implementazione, pertanto la definizione del metodo è seguita da un punto e virgola, anziché da un normale blocco di metodi. Le classi derivate della classe astratta devono implementare tutti i metodi astratti. Quando una classe astratta eredita un metodo virtuale da una classe base, la classe astratta può eseguire l'override del metodo virtuale con un metodo astratto. Ad esempio:

// compile with: -target:library
public class D
{
    public virtual void DoWork(int i)
    {
        // Original implementation.
    }
}

public abstract class E : D
{
    public abstract override void DoWork(int i);
}

public class F : E
{
    public override void DoWork(int i)
    {
        // New implementation.
    }
}

Un metodo virtual dichiarato abstract rimane virtuale in qualsiasi classe che eredita dalla classe astratta. Una classe che eredita un metodo astratto non può accedere all'implementazione originale del metodo. Nell'esempio precedente, DoWork sulla classe F non può chiamare DoWork sulla classe D. In questo modo una classe astratta può imporre alle classi derivate di fornire nuove implementazioni per i metodi virtuali.

Classi e membri di classi sealed

Le classi possono essere dichiarate sealed inserendo la parola chiave sealed prima della definizione della classe. Ad esempio:

public sealed class D
{
    // Class members here.
}

Una classe sealed non può essere utilizzata come classe base. Per questo motivo non può neppure essere una classe astratta. Le classi sealed impediscono la derivazione. Poiché non possono mai essere utilizzate come classe base, in alcune ottimizzazioni runtime la chiamata ai membri di classi sealed può risultare leggermente più rapida.

Un metodo, un indicizzatore, una proprietà o un evento di una classe derivata che esegue l'override di un membro virtuale della classe base può dichiarare tale membro come sealed. In questo modo viene negato l'aspetto virtuale del membro per qualsiasi ulteriore classe derivata. A questo scopo è necessario inserire la parola chiave sealed prima della parola chiave override nella dichiarazione del membro di classe. Ad esempio:

public class D : C
{
    public sealed override void DoWork() { }
}

Vedi anche