Freigeben über

Operatoren „-“ und „-=“ - Subtraktion (minus)

Die integrierten integralen und Gleitpunkt numerischen Typen und Delegattypen unterstützen alle die - und -= Operatoren.

Informationen zum arithmetischen - Operator finden Sie in den Abschnitten Unärer Plus- und Minusoperator und Subtraktionsoperator des Artikels Arithmetische Operatoren.

Entfernen von Delegierten

Für Operanden desselben Delegattyps gibt der - Operator eine Delegateninstanz zurück, die wie folgt berechnet wird:

  • Wenn beide Operanden nicht null sind und die Aufrufliste des rechten Operanden eine ordnungsgemäße zusammenhängende Unterliste der Aufrufliste des linken Operanden ist, ist das Ergebnis des Vorgangs eine neue Aufrufliste, die durch Entfernen der Einträge des rechten Operanden aus der Aufrufliste des linken Operanden abgerufen wird. Wenn die Liste des rechten Operanden mehreren zusammenhängenden Unterlisten aus der Liste des linken Operanden entspricht, wird nur die äußerst rechte übereinstimmende Unterliste entfernt. Wenn das Entfernen zu einer leeren Liste führt, lautet nulldas Ergebnis .

    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

  • Wenn es sich bei der Aufrufliste des rechten Operanden nicht um eine ordnungsgemäße zusammenhängende Unterliste der Aufrufliste des linken Operanden handelt, ist das Ergebnis des Vorgangs der linke Operand. Beispielsweise bewirkt das Entfernen eines Delegaten, der nicht Teil des Multicastdelegats ist, nichts und führt zu dem unveränderten Multicastdelegat.

    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

    Das vorherige Beispiel veranschaulicht auch, dass Delegatinstanzen beim Entfernen von Delegaten verglichen werden. Delegaten, die durch die Auswertung identischer Lambdaausdrücke erzeugt werden, sind beispielsweise nicht gleich. Weitere Informationen zur Stellvertretungsgleichstellung finden Sie im Abschnitt " Stellvertretungs-Gleichheitsoperatoren " der C#-Sprachspezifikation.

  • Wenn der linke Operand null ist, ist das Ergebnis des Vorgangs null. Ist der rechte Operand null, ist das Ergebnis des Vorgangs der linke Operand.

    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

Verwenden Sie den + Operator zur Kombination von Delegaten.

Weitere Informationen zu Stellvertretungstypen finden Sie unter Delegaten.

Subtraktionszuweisungsoperator „-=“

Ein Ausdruck, der den -= Operator verwendet, z. B.

x -= y

Ist äquivalent zu

x = x - y

Mit der Ausnahme, dass x nur einmal ausgewertet wird.

Im folgenden Beispiel wird die Verwendung des -=-Operators veranschaulicht:

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

Sie verwenden auch den -= Operator, um eine Ereignishandlermethode anzugeben, die entfernt werden soll, wenn Sie ein Ereignis kündigen. Weitere Informationen finden Sie unter Abonnieren und Kündigen von Ereignissen.

Operatorüberladbarkeit

Ein benutzerdefinierter Typ kann den Operator -. Wenn ein binärer - Operator überladen ist, wird der -= Operator auch implizit überladen. Ab C# 14 kann ein benutzerdefinierter Typ den -= Operator explizit überladen, um eine effizientere Implementierung bereitzustellen. In der Regel überlastet ein Typ den -= Operator, da der Wert direkt aktualisiert werden kann, anstatt eine neue Instanz zuzuweisen, um das Ergebnis der Subtraktion zu speichern. Wenn ein Typ keine explizite Überladung bereitstellt, generiert der Compiler die implizite Überladung.

C#-Sprachspezifikation

Weitere Informationen finden Sie in den Abschnitten " Unary minus" und " Subtraktionsoperator " der C#-Sprachspezifikation. Weitere Informationen zum Überladen der Verbundzuordnungsoperatoren in C# 14 und höher finden Sie in der benutzerdefinierten Spezifikation der zusammengesetzten Zuordnungsfunktion .

Siehe auch