Condividi tramite

modificatore new (Riferimenti per C#)

Se usato come modificatore di dichiarazione, la new parola chiave nasconde in modo esplicito un membro ereditato da una classe di 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. Anche se è possibile nascondere public o protected i membri senza usare il modificatore, viene visualizzato un avviso del new compilatore. Se si usa new per nascondere in modo esplicito un membro, questo avviso viene eliminato.

È anche possibile usare la new parola chiave 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 del membro e modificarlo con la new parola chiave . Per 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.

Il nome nascosto tramite ereditarietà accetta una delle forme 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. Ci sono casi speciali. Ad esempio, se si dichiara un nuovo campo con nome N per avere un tipo che non è chiamabile e un tipo di base dichiara N di essere un metodo, il nuovo campo non nasconde la dichiarazione di base nella sintassi di chiamata. Per altre informazioni, vedere la sezione Ricerca membro della specifica del linguaggio C#.

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

  • Un indicizzatore introdotto in una classe o in uno struct nasconde tutti gli indicizzatori di classi di base con la stessa firma.

È un errore usare sia new che eseguire l'override sullo stesso membro, perché i due modificatori hanno significati che si escludono a vicenda. Il new modificatore crea un nuovo membro con lo stesso nome e fa sì che il membro originale diventi nascosto. Il override modificatore estende l'implementazione per un membro ereditato.

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

Esempi

In questo esempio, una classe base, BaseCe una classe derivata, DerivedC, usano lo stesso nome xdi campo , che nasconde il valore del campo ereditato. Nell'esempio viene illustrato l'uso del new modificatore. Viene inoltre illustrato come accedere ai membri nascosti della classe di 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 nidificata nasconde una classe con lo stesso nome nella classe di base. Nell'esempio viene illustrato come usare il new modificatore per eliminare il messaggio di avviso e come accedere ai membri della classe nascosti usando 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 new modificatore, il programma verrà comunque compilato ed eseguito, ma verrà visualizzato l'avviso seguente:

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

Specificazione del linguaggio C#

Per altre informazioni, vedere la sezione New modifier (Nuovo modificatore ) della specifica del linguaggio C#.

Vedere anche

  • Last updated on