Dela via

- och -= operatorer - subtraktion (minus)

  • Artikel

Operatorerna - och -= stöds av de inbyggda numeriska typerna integral och flyttalstyp och delegeringstyper .

Information om den aritmetiska - operatorn finns i avsnitten Unary plus och minus operator och Subtraktion - i artikeln Aritmetiska operatorer .

Borttagning av ombud

För operander av samma delegattyp returnerar operatorn - en delegatinstans som beräknas på följande sätt:

  • Om båda operanderna inte är null och anropslistan för den högra operanden är en korrekt sammanhängande underlista i listan över anrop till den vänstra operanden är resultatet av åtgärden en ny anropslista som erhålls genom att ta bort den högra operandens poster från anropslistan för den vänstra operanden. Om den högra operandens lista matchar flera sammanhängande underlistor i den vänstra operandens lista tas endast den matchande underlistan till höger bort. Om borttagningen resulterar i en tom lista blir nullresultatet .

    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

  • Om anropslistan för den högra operanden inte är en korrekt sammanhängande underlista för anropslistan för den vänstra operanden är resultatet av åtgärden den vänstra operanden. Om du till exempel tar bort ett ombud som inte är en del av multicast-ombudet sker ingenting och resulterar i det oförändrade multicast-ombudet.

    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

    Föregående exempel visar också att under delegatborttagning jämförs delegeringsinstanser. Till exempel är ombud som skapas från utvärdering av identiska lambda-uttryck inte lika. Mer information om ombudsjämlikhet finns i avsnittet Delegera likhetsoperatorer i C#-språkspecifikationen.

  • Om den vänstra operanden är nullär nullresultatet av åtgärden . Om den högra operanden är nullär resultatet av åtgärden den vänstra operanden.

    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

Använd operatorn om + du vill kombinera ombud.

Mer information om ombudstyper finns i Ombud.

Subtraktionstilldelningsoperator -=

Ett uttryck som använder operatorn -= , till exempel

x -= y

motsvarar

x = x - y

förutom att x endast utvärderas en gång.

I följande exempel visas hur operatorn -= används:

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

Du använder också operatorn -= för att ange en händelsehanterarmetod som du vill ta bort när du avslutar prenumerationen på en händelse. Mer information finns i Så här prenumererar du på och avbryter prenumerationen på händelser.

Överlagring av operator

En användardefinierad typ kan överbelasta operatorn - . När en binär - operator är överbelastad är operatorn -= också implicit överbelastad. En användardefinierad typ kan inte uttryckligen överbelasta operatorn -= .

Språkspecifikation för C#

Mer information finns i avsnitten Unary minus operator och Subtraktion operator i C#-språkspecifikationen.

Se även