Partager via

Opérateurs - et -= - soustraction (moins)

Les types numériques entiers et à virgule flottante, ainsi que les types délégués, prennent tous en charge les opérateurs - et -=.

Pour plus d’informations sur l’opérateur arithmétique -, consultez les sections Plus et moins unaires et l’opérateur de soustraction de l’article Opérateurs arithmétiques.

Suppression de délégués

Pour les opérandes du même type de délégué , l’opérateur - retourne une instance de délégué calculée comme suit :

  • Si les deux opérandes sont non null et que la liste d’appel de l’opérande de droite est une sous-liste contiguë appropriée de la liste d’appel de l’opérande de gauche, le résultat de l’opération est une nouvelle liste d’appel obtenue en supprimant les entrées de l’opérande de droite de la liste d’appel de l’opérande de gauche. Si la liste de l’opérande de droite correspond à plusieurs sous-listes contiguës dans la liste de l’opérande de gauche, seule la sous-liste correspondante la plus à droite est supprimée. Si la suppression entraîne une liste vide, le résultat est null.

    Action a = () => Console.Write("a");
Action b = () => Console.Write("b");

var abbaab = a + b + b + a + a + b;
abbaab();  // output: abbaab
Console.WriteLine();

var ab = a + b;
var abba = abbaab - ab;
abba();  // output: abba
Console.WriteLine();

var nihil = abbaab - abbaab;
Console.WriteLine(nihil is null);  // output: True

  • Si la liste d’appel de l’opérande de droite n’est pas une sous-liste contiguë appropriée de la liste d’appel de l’opérande de gauche, le résultat de l’opération est l’opérande de gauche. Par exemple, la suppression d’un délégué qui ne fait pas partie du délégué de multidiffusion ne fait rien et entraîne le délégué de multidiffusion inchangé.

    Action a = () => Console.Write("a");
Action b = () => Console.Write("b");

var abbaab = a + b + b + a + a + b;
var aba = a + b + a;

var first = abbaab - aba;
first();  // output: abbaab
Console.WriteLine();
Console.WriteLine(object.ReferenceEquals(abbaab, first));  // output: True

Action a2 = () => Console.Write("a");
var changed = aba - a;
changed();  // output: ab
Console.WriteLine();
var unchanged = aba - a2;
unchanged();  // output: aba
Console.WriteLine();
Console.WriteLine(object.ReferenceEquals(aba, unchanged));  // output: True

    L’exemple précédent montre également que durant la suppression de délégué, les instances de délégués sont comparées. Par exemple, les délégués qui sont produits à partir de l’évaluation d’expressions lambda identiques ne sont pas égaux. Pour plus d’informations sur l’égalité des délégués, consultez la section Opérateurs d’égalité des délégués de la spécification du langage C#.

  • Si l’opérande de gauche est null, le résultat de l’opération est null. Si l’opérande de partie droite est null, le résultat de l’opération est l’opérande de partie gauche.

    Action a = () => Console.Write("a");

var nothing = null - a;
Console.WriteLine(nothing is null);  // output: True

var first = a - null;
a();  // output: a
Console.WriteLine();
Console.WriteLine(object.ReferenceEquals(first, a));  // output: True

Pour combiner des délégués, utilisez l'opérateur +.

Pour plus d’informations sur les types de délégués, consultez Délégués.

Opérateur d’assignation de soustraction -=

Expression utilisant l’opérateur -= , par exemple

x -= y

Équivaut à

x = x - y

Sauf que x est évalué une seule fois.

L’exemple suivant illustre l’utilisation de l’opérateur -= :

int i = 5;
i -= 9;
Console.WriteLine(i);
// Output: -4

Action a = () => Console.Write("a");
Action b = () => Console.Write("b");
var printer = a + b + a;
printer();  // output: aba

Console.WriteLine();
printer -= a;
printer();  // output: ab

Vous utilisez également l’opérateur -= pour spécifier une méthode de gestionnaire d’événements à supprimer lorsque vous vous désabonnez d’un événement. Pour plus d’informations, consultez Comment s’abonner et se désabonner des événements.

Surcharge des opérateurs

Un type défini par l’utilisateur peut surcharger l’opérateur - . Lorsqu’un opérateur binaire - est surchargé, l’opérateur -= est également implicitement surchargé. À compter de C# 14, un type défini par l’utilisateur peut surcharger explicitement l’opérateur -= pour fournir une implémentation plus efficace. En règle générale, un type surcharge l’opérateur -= , car la valeur peut être mise à jour en place, plutôt que d’allouer une nouvelle instance pour stocker le résultat de la soustraction. Si un type ne fournit pas de surcharge explicite, le compilateur génère la surcharge implicite.

Spécification du langage C#

Pour plus d’informations, consultez les sections de l’opérateur Unary moins et de l’opérateur Soustraction de la spécification du langage C#. Pour plus d’informations sur la surcharge des opérateurs d’affectation composée en C# 14 et versions ultérieures, consultez la spécification de la fonctionnalité d’affectation composée définie par l’utilisateur .

Voir aussi