Delen via

- en -= operatoren - aftrekken (minteken)

De ingebouwde integrale en drijvende komma numerieke typen en gedelegeerdentypen ondersteunen allemaal de - en -= operators.

Zie de - 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

    Het voorgaande voorbeeld laat ook zien dat tijdens het verwijderen van gedelegeerden vergelijking van gedelegeerde instanties plaatsvindt. Zo zijn afgevaardigden die zijn geproduceerd op basis van de evaluatie van identieke lambda-expressies niet gelijk. Zie de sectie Gelijkheidsoperatoren voor delegaten van de C#-taalspecificatie voor meer informatie over gelijkheid van delegaten.

  • Als de linkeroperand null is, is het resultaat van de bewerking null. Als de rechteroperand null is, is het 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.

Aftrekkingstoewijzingsoperator -=

Een expressie met behulp van de -= operator, zoals

x -= y

Is gelijk aan

x = x - y

Behalve dat 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 Abonneren op en afmelden voor gebeurtenissenvoor meer informatie.

Overbelasting van operatoren

Een door de gebruiker gedefinieerd type kan de operator -. Wanneer een binaire - operator overbelast is, wordt de -= operator ook impliciet overbelast. Vanaf C# 14 kan een door de gebruiker gedefinieerd type de -= operator expliciet overbelasten om een efficiëntere implementatie te bieden. Normaal gesproken overbelast een type de -= operator omdat de waarde kan worden bijgewerkt in plaats van een nieuw exemplaar toe te wijzen om het resultaat van de aftrekking op te slaan. Als een type geen expliciete overbelasting biedt, genereert de compiler de impliciete overbelasting.

C#-taalspecificatie

Zie de secties Unary minus operator en Aftrekken operator van de C#-taalspecificatie voor meer informatie. Zie de door de gebruiker gedefinieerde functiespecificatie voor samengestelde toewijzingen voor meer informatie over het overbelasten van de samengestelde toewijzingsoperatoren in C# 14 en hoger.

Zie ook