Modificatore new (Riferimenti per C#)

  • Articolo

Se usata come modificatore di dichiarazione, la parola chiave new nasconde in modo esplicito un membro ereditato da una classe base. Quando si nasconde un membro ereditato, la versione derivata del membro sostituisce la versione della classe base. Ciò presuppone che la versione della classe di base del membro sia visibile, perché sarebbe già nascosta se fosse contrassegnata come private o, in alcuni casi, internal. Sebbene sia possibile nascondere public o protected membri senza usare il modificatore new, viene visualizzato un avviso del compilatore. Se si usa new in modo esplicito per nascondere un membro, esso elimina l'avviso.

È anche possibile usare la parola chiave new per creare un'istanza di un tipo o come vincolo di tipo generico.

Per nascondere un membro ereditato, dichiararlo nella classe derivata usando lo stesso nome di membro e modificarlo con la parola chiave new. Ad esempio:

public class BaseC
{
    public int x;
    public void Invoke() { }
}
public class DerivedC : BaseC
{
    new public void Invoke() { }
}

In questo esempio BaseC.Invoke è nascosto da DerivedC.Invoke. Il campo x non è interessato perché non è nascosto da un nome simile.

Un nome nascosto tramite ereditarietà accetta uno dei formati seguenti:

  • In genere, una costante, un campo, una proprietà o un tipo introdotto in una classe o uno struct nasconde tutti i membri della classe base che condividono il nome. Esistono casi particolari. Se, ad esempio, si dichiara che un nuovo campo con il nome N dispone di un tipo non richiamabile e un tipo di base dichiara che N sia un metodo, il nuovo campo non nasconde la dichiarazione di base nella sintassi di chiamata. Per altre informazioni, vedere la sezione Ricerca di membri della specifica del linguaggio C#.

  • Un metodo inserito in una classe o uno struct nasconde proprietà, campi e tipi che condividono il nome con la classe base. Nasconde inoltre tutti i metodi della classe base con la stessa firma.

  • Un indicizzatore inserito in una classe o uno struct nasconde tutti gli indicizzatori della classe base con la stessa firma.

Non è possibile usare sia new sia override nello stesso membro, in quanto i significati dei due modificatori si escludono reciprocamente. Il modificatore new crea un nuovo membro con lo stesso nome e fa sì che il membro originale venga nascosto. Il modificatore override estende l'implementazione per un membro ereditato.

L'utilizzo del modificatore new in una dichiarazione che non nasconde un membro ereditato genera un avviso.

Esempi

In questo esempio, una classe base, BaseC, e una classe derivata, DerivedC, usano lo stesso nome di campo x, che nasconde il valore del campo ereditato. Nell'esempio viene illustrato l'utilizzo del modificatore new. Viene inoltre descritto come accedere ai membri nascosti della classe base usando i relativi nomi completi.

public class BaseC
{
    public static int x = 55;
    public static int y = 22;
}

public class DerivedC : BaseC
{
    // Hide field 'x'.
    new public static int x = 100;

    static void Main()
    {
        // Display the new value of x:
        Console.WriteLine(x);

        // Display the hidden value of x:
        Console.WriteLine(BaseC.x);

        // Display the unhidden member y:
        Console.WriteLine(y);
    }
}
/*
Output:
100
55
22
*/

In questo esempio, una classe annidata nasconde una classe che ha lo stesso nome nella classe base. L'esempio illustra come usare il modificatore new per eliminare il messaggio di avviso e come accedere ai membri di classe nascosti tramite i relativi nomi completi.

public class BaseC
{
    public class NestedC
    {
        public int x = 200;
        public int y;
    }
}

public class DerivedC : BaseC
{
    // Nested type hiding the base type members.
    new public class NestedC
    {
        public int x = 100;
        public int y;
        public int z;
    }

    static void Main()
    {
        // Creating an object from the overlapping class:
        NestedC c1  = new NestedC();

        // Creating an object from the hidden class:
        BaseC.NestedC c2 = new BaseC.NestedC();

        Console.WriteLine(c1.x);
        Console.WriteLine(c2.x);
    }
}
/*
Output:
100
200
*/

Se si rimuove il modificatore new, la compilazione e l'esecuzione del programma saranno comunque possibili, ma verrà visualizzato il messaggio di avviso riportato di seguito:

The keyword new is required on 'MyDerivedC.x' because it hides inherited member 'MyBaseC.x'.

Specifiche del linguaggio C#

Per altre informazioni, vedere la sezione Modificatore new della specifica del linguaggio C#.

Vedi anche