Delen via

- en -= operatoren - aftrekken (minteken)

  • Artikel

De - operators -= en operators worden ondersteund door de ingebouwde integrale en numerieke typen drijvende komma en gedelegeerde typen.

Zie de unaire plus- en min-operatoren en de aftrekkingsoperator ( secties van het artikel Rekenkundige operatoren) voor meer informatie over de rekenkundige - operator.

Verwijdering delegeren

Voor operanden van hetzelfde gemachtigdetype retourneert de - operator een gemachtigde instantie die als volgt wordt berekend:

  • Als beide operanden niet null zijn en de aanroeplijst van de rechteroperand een juiste aaneengesloten sublijst van de aanroeplijst van de linkeroperand is, is het resultaat van de bewerking een nieuwe aanroeplijst die wordt verkregen door de vermeldingen van de rechteroperand te verwijderen uit de lijst met aanroepen van de linkeroperand. Als de lijst van de rechteroperand overeenkomt met meerdere aaneengesloten sublijsten in de lijst van de linkeroperand, wordt alleen de meest rechts overeenkomende sublijst verwijderd. Als het verwijderen resulteert in een lege lijst, is nullhet resultaat .

    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

  • Als de aanroeplijst van de rechteroperand geen juiste aaneengesloten sublijst van de aanroeplijst van de linkeroperand is, is het resultaat van de bewerking de linkeroperand. Als u bijvoorbeeld een gemachtigde verwijdert die geen deel uitmaakt van de multicast-gemachtigde, doet dit niets en resulteert dit in de ongewijzigde multicast-gemachtigde.

    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

    In het voorgaande voorbeeld ziet u ook dat tijdens het verwijderen van gemachtigden gedelegeerden worden vergeleken. Zo zijn gedelegeerden die zijn geproduceerd op basis van de evaluatie van identieke lambda-expressies niet gelijk. Zie de sectie Gelijkheidsoperatoren delegeren van de C#-taalspecificatie voor meer informatie over gelijkheid van gemachtigden.

  • Als de linkeroperand is, is nullnullhet resultaat van de bewerking . Als de rechteroperand is, is nullhet resultaat van de bewerking de linkeroperand.

    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

Als u gemachtigden wilt combineren, gebruikt u de + operator.

Zie Gemachtigden voor meer informatie over typen gemachtigden.

Toewijzingsoperator aftrekken -=

Een expressie met behulp van de -= operator, zoals

x -= y

is gelijk aan

x = x - y

behalve dat dit x slechts eenmaal wordt geëvalueerd.

In het volgende voorbeeld ziet u het gebruik van de -= operator:

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

U gebruikt de -= operator ook om een gebeurtenishandlermethode op te geven die moet worden verwijderd wanneer u zich afmeldt voor een gebeurtenis. Zie Hoe u zich kunt abonneren op en afmelden voor gebeurtenissen voor meer informatie.

Overbelasting van operatoren

Een door de gebruiker gedefinieerd type kan de - operator overbelasten. Wanneer een binaire - operator overbelast is, wordt de -= operator ook impliciet overbelast. Een door de gebruiker gedefinieerd type kan de -= operator niet expliciet overbelasten.

C#-taalspecificatie

Zie de secties Unary minus operator en Aftrekken operator van de C#-taalspecificatie voor meer informatie.

Zie ook