Partager via

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

  • Article

Les opérateurs - et -= sont pris en charge par les types numériques intégraux et à virgule flottante intégrés et les types délégués.

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

Suppression de délégué

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

  • Si les deux opérandes ont des valeurs non Null et que la liste d’appel de l’opérande de partie droite est une sous-liste contiguë correcte de la liste d’appel de l’opérande de partie droite, le résultat de l’opération est une nouvelle liste d’appel obtenue en supprimant les entrées de l’opérande de partie droite à partir de la liste d’appel de l’opérande de gauche. Si la liste des opérandes de partie droite correspond à plusieurs sous-listes contiguës dans la liste des opérandes de partie gauche, seule la sous-liste correspondante la plus à droite est supprimée. Si la suppression aboutit à 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 partie droite n’est pas une sous-liste contiguë correcte de la liste d’appel de l’opérande de partie gauche, le résultat de l’opération est l’opérande de partie gauche. Par exemple, la suppression d’un délégué qui ne fait pas partie du délégué multicast ne fait rien et génère un délégué multicast 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é de délégués de la spécification du langage C#.

  • Si l’opérande de partie 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 n’est évalué qu’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 quand vous vous désabonnez d’un événement. Pour plus d’informations, consultez Guide pratique pour s’abonner et annuler l’abonnement à des événements.

Capacité de surcharge de l’opérateur

Un type défini par l’utilisateur peut surcharger l’opérateur -. Quand un opérateur binaire - est surchargé, l’opérateur -= est aussi implicitement surchargé. Un type défini par l’utilisateur ne peut pas surcharger explicitement l’opérateur -=.

spécification du langage C#

Pour plus d’informations, consultez les sections Opérateur moins unaire et Opérateur de soustraction de la spécification du langage C#.

Voir aussi