Dela via

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

De inbyggda ombudstyperna och de numeriska typerna för integrerad och flyttal stöder alla operatorerna - och -= .

C#-språkreferensen dokumenterar den senaste versionen av C#-språket. Den innehåller även inledande dokumentation för funktioner i offentliga förhandsversioner för den kommande språkversionen.

Dokumentationen identifierar alla funktioner som först introducerades i de tre senaste versionerna av språket eller i aktuella offentliga förhandsversioner.

Tips/Råd

Information om när en funktion först introducerades i C# finns i artikeln om språkversionshistoriken för C#.

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 null är det och anropslistan för den högra operanden är en korrekt sammanhängande underlista i listan över anrop för den vänstra operanden, är resultatet av åtgärden en ny anropslista som du får 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 tar åtgärden bara bort den matchande underlistan till höger. 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 som använder operatorn -= , till exempel

x -= y

Motsvarar

x = x - y

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

I följande exempel visas hur du använder 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 du överbelastar en binär - operator överbelastar du även operatorn -= implicit. 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

  • Last updated on