Partager via

nouveau modificateur (référence C#)

Lorsqu’il est utilisé comme modificateur de déclaration, le new mot clé masque explicitement un membre 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 ou protected membres public sans utiliser le new modificateur, vous obtenez un avertissement du compilateur. Si vous utilisez new pour masquer explicitement un membre, il supprime cet avertissement.

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

Pour masquer un membre hérité, déclarez-le dans la classe dérivée à l’aide du même nom de membre et modifiez-le avec le new mot clé. 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é, car il n’est pas masqué par un nom similaire.

Le nom masqué via l’héritage prend l’une des formes suivantes :

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

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

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

Il s’agit d’une erreur d’utilisation new et de substitution sur le même membre, car les deux modificateurs ont des significations mutuellement exclusives. Le new modificateur crée un nouveau membre portant le même nom et entraîne la masquée du membre d’origine. Le override modificateur étend l’implémentation d’un membre hérité.

L’utilisation du new modificateur 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, BaseCet une classe dérivée, DerivedCutilisent le même nom xde champ, qui masque la valeur du champ hérité. L’exemple illustre l’utilisation du new modificateur. Il montre également comment accéder aux membres masqués de la classe de base à l’aide de 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 qui porte le même nom dans la classe de base. L’exemple montre comment utiliser le new modificateur pour éliminer le message d’avertissement et comment accéder aux membres de classe masqués à 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 new modificateur, le programme est toujours compilé et exécuté, mais vous recevez 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 nouvelle section modificateur de la spécification du langage C#.

Voir aussi

  • Last updated on