Condividi tramite

Classi astratte e classi sealed e membri della classe (Guida alla programmazione C#)

La parola chiave abstract consente di creare classi e membri di classe incompleti e che 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 astratte e membri della classe

Le classi possono essere dichiarate come astratte inserendo la parola chiave abstract prima della definizione della classe. Per esempio:

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

Non è possibile creare un'istanza di una classe astratta. Lo scopo di una classe astratta è fornire una definizione comune di una classe base che più classi derivate possono condividere. Ad esempio, una libreria di classi può definire una classe astratta usata come parametro per molte delle relative funzioni e richiedere ai programmatori di usare tale libreria per fornire la propria implementazione della classe creando una classe derivata.

Le classi astratte possono anche definire metodi astratti. A tale scopo, aggiungere la parola chiave abstract prima del tipo restituito del metodo . Per esempio:

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

I metodi astratti non hanno implementazione, quindi 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. Per 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.
    }
}

Se un virtual metodo viene dichiarato abstract, è ancora virtuale per 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 nella classe F non può chiamare DoWork sulla classe D. In questo modo, una classe astratta può forzare le classi derivate a fornire nuove implementazioni del metodo per i metodi virtuali.

Classi sealed e membri di classe

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

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

Una classe sealed non può essere utilizzata come classe di base. Per questo motivo, non può essere anche una classe astratta. Le classi sealed impediscono la derivazione. Poiché non possono mai essere usati come classe base, alcune ottimizzazioni della fase di esecuzione possono rendere leggermente più veloce la chiamata dei membri della classe sealed.

Un metodo, un indicizzatore, una proprietà o un evento, in 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 altra classe derivata. Questo si realizza inserendo la parola chiave sealed prima della parola chiave override nella dichiarazione del membro della classe. Per esempio:

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

Vedere anche