Partage via

new, modificateur (référence C#)

  • Article

En cas d'utilisation comme un modificateur de déclaration, le mot clé new masque explicitement un membre qui est hérité d'une classe de base. Lorsque vous masquez un membre hérité, la version dérivée du membre remplace la version de classe de base. Cela suppose que la version de classe de base du membre est visible, car elle serait déjà masquée si elle était marquée comme private ou, dans certains cas, internal. Bien que vous puissiez masquer des membres public ou protected sans utiliser le modificateur new, vous obtenez un avertissement du compilateur. Si vous utilisez new pour masquer explicitement un membre, il supprime cet avertissement.

Vous pouvez également utiliser le mot clé new pour créer une instance d’un type ou l’utiliser comme une contrainte de type générique.

Pour masquer un membre hérité, déclarez-le dans la classe dérivée en utilisant le même nom de membre, puis modifiez-le à l'aide du mot-clé new. Par exemple :

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

Dans cet exemple, BaseC.Invoke est masqué par DerivedC.Invoke. Le champ x n'est pas affecté parce qu'il n'est pas masqué par un nom semblable.

Le masquage de noms par le biais de l'héritage peut prendre l'une des formes suivantes :

  • En général, une constante, un champ, une propriété ou un type qui est introduit dans une classe ou une structure masque tous les membres de la classe de base qui partagent son nom. Il existe des cas spéciaux. Par exemple, si vous déclarez un nouveau champ avec le nom N pour avoir un type qui n'est pas invocable, et qu'un type de base déclare N en tant que méthode, le nouveau champ ne masquera pas la déclaration de base dans la syntaxe d'appel. Pour plus d’informations, consultez la section Recherche de membres de la spécification du langage C#.

  • Une méthode introduite dans une classe ou une structure masque les propriétés, les champs et les types qui partagent ce nom, dans la classe de base. Cela masque également toutes les méthodes de la classe de base ayant la même signature.

  • Un indexeur introduit dans une classe ou un struct masque tous les indexeurs de la classe de base ayant la même signature.

L’utilisation des opérateurs new et override sur le même membre est une erreur, car ces deux modificateurs ont des significations qui s’excluent mutuellement. Le modificateur new crée un nouveau membre avec le même nom et entraîne le masquage du membre d'origine. Le modificateur override étend l'implémentation pour un membre hérité.

L'utilisation du modificateur new dans une déclaration qui ne masque pas un membre hérité génère un avertissement.

Exemples

Dans cet exemple, une classe de base, BaseC et une classe dérivée, DerivedC, utilisent le même nom de champ x, masquant ainsi la valeur du champ hérité. Cet exemple illustre l'utilisation du modificateur new. Il montre aussi comment accéder aux membres masqués de la classe de base en utilisant leurs noms complets.

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
*/

Dans cet exemple, une classe imbriquée masque une classe du même nom dans la classe de base. Cet exemple illustre l'utilisation du modificateur new pour éliminer le message d'avertissement, ainsi que l'accès aux membres de la classe masquée à l'aide de leurs noms complets.

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
*/

Si vous supprimez le modificateur new, le programme peut encore être compilé et exécuté, mais vous obtiendrez l'avertissement suivant :

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

spécification du langage C#

Pour plus d’informations, consultez la section Modificateur new de la spécification du langage C#.

Voir aussi