Dela via

- och -= operatorer - subtraktion, även kallat minus

De inbyggda typerna för heltal och flyttal samt delegerade typer stöder alla operatorerna och .

Information om den aritmetiska - operatorn finns i avsnitten unar plus- och minusoperator och Subtraktionsoperator - i artikel 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 delegater som skapas från utvärdering av identiska lambda-uttryck inte samma. Mer information om delegerad jämlikhet finns i avsnittet Delegat likhetsoperatorer i C#-språkspecifikationen.

  • Om den vänstra operanden är null, är resultatet av operationen null. Om den högra operanden är null, är resultatet av operationen 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+ för att kombinera delegeringar.

Mer information om ombudstyper finns i Ombud.

Subtraktionstilldelningsoperator -=

Ett uttryck med operatorn -=, till exempel

x -= y

Motsvarar

x = x - y

Förutom att x bara utvärderas en gång.

I följande exempel visas användningen av operatorn -=:

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.

Möjlighet till operatoröverbelastning

En användardefinierad typ kan överlagra--operatorn. När en binär - operator är överbelastad är -= operatorn också implicit överbelastad. Från och med C# 14 kan en användardefinierad typ uttryckligen överbelasta operatorn -= för att ge en effektivare implementering. Normalt överbelastar en typ operatorn -= eftersom värdet kan uppdateras på plats, i stället för att allokera en ny instans för att lagra resultatet av subtraktionen. Om en typ inte ger någon explicit överlagring genererar kompilatorn den implicita överbelastningen.

Språkspecifikation för C#

Mer information finns i avsnitten Unary minus operator och Subtraktion operator i C#-språkspecifikationen. Mer information om överlagring av de sammansatta tilldelningsoperatorerna i C# 14 och senare finns i funktionsspecifikationen för användardefinierade sammansatta tilldelningar .

Se även