Condividi tramite

sealed (Riferimenti per C#)

  • Articolo

Quando applicato a una classe, il modificatore sealed impedisce che altre classi ereditino da esso. Nell'esempio seguente, la classe B eredita dalla classe A, ma nessuna classe può ereditare dalla classe B.

class A {}
sealed class B : A {}

È anche possibile usare il modificatore sealed su un metodo o su una proprietà che esegue l'override di un metodo o di una proprietà virtuale in una classe di base. In questo modo è possibile consentire alle classi di derivare dalla classe e impedire l'override di proprietà o metodi virtuali specifici.

Esempio

Nell'esempio seguente, Z eredita da Y ma Z non può eseguire l'override della funzione virtuale F dichiarata in X e bloccata in Y.

class X
{
    protected virtual void F() { Console.WriteLine("X.F"); }
    protected virtual void F2() { Console.WriteLine("X.F2"); }
}

class Y : X
{
    sealed protected override void F() { Console.WriteLine("Y.F"); }
    protected override void F2() { Console.WriteLine("Y.F2"); }
}

class Z : Y
{
    // Attempting to override F causes compiler error CS0239.
    // protected override void F() { Console.WriteLine("Z.F"); }

    // Overriding F2 is allowed.
    protected override void F2() { Console.WriteLine("Z.F2"); }
}

Quando si definiscono nuovi metodi o proprietà in una classe, è possibile impedire alle classi derivate di eseguire l'override non dichiarandole come virtuali.

È un errore usare il modificatore abstract con una classe sealed, poiché la classe astratta deve essere ereditata da una classe che fornisce un'implementazione dei metodi o delle proprietà astratti.

Quando applicato a un metodo o a una proprietà, il modificatore sealed deve sempre essere usato con override.

Poiché gli struct sono sealed in modo implicito, non possono essere ereditati.

Per altre informazioni, vedere Ereditarietà.

Per altri esempi, vedere Classi e membri delle classi astratte e sealed.

sealed class SealedClass
{
    public int x;
    public int y;
}

class SealedTest2
{
    static void Main()
    {
        var sc = new SealedClass();
        sc.x = 110;
        sc.y = 150;
        Console.WriteLine($"x = {sc.x}, y = {sc.y}");
    }
}
// Output: x = 110, y = 150

Nell'esempio precedente è possibile ereditare dalla classe sealed tramite l'istruzione seguente:

class MyDerivedC: SealedClass {} // Error

Il risultato è un messaggio di errore:

'MyDerivedC': cannot derive from sealed type 'SealedClass'

Osservazioni:

Per determinare se bloccare una classe, proprietà o metodo, è consigliabile in genere considerare i due punti seguenti:

  • I potenziali vantaggi di cui le classi derivate possono usufruire grazie alla possibilità di personalizzare la classe.

  • La possibilità che le classi derivate possono modificare le classi in uso in modo tale che non funzionino più correttamente o come previsto.

Specifiche del linguaggio C#

Per altre informazioni, vedere la specifica del linguaggio C#. La specifica del linguaggio costituisce il riferimento ufficiale principale per la sintassi e l'uso di C#.

Vedi anche