Teilen über

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

  • Artikel

Die Operatoren - und -= werden von den integrierten numerischen integral- und floating-point-Typen sowie delegate-Typen unterstützt.

Informationen zum arithmetischen Operator - finden Sie in den Abschnitten Unäre Plus- und Minusoperatoren und Subtraktionsoperator - des Artikels Arithmetische Operatoren (C#-Referenz).

Delegatentfernung

Für Operanden des gleichen Delegattyps gibt der Operator - eine wie folgt berechnete Delegatinstanz zurück:

  • Wenn beide Operanden nicht NULL sind und es sich bei der Aufrufliste des rechten Operanden um eine ordnungsgemäße zusammenhängende Unterliste der Aufrufliste des linken Operanden handelt, entsteht durch den Vorgang eine neue Aufrufliste, bei der die Einträge des rechten Operanden aus der Aufrufliste des linken Operanden entfernt wurden. 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. Sollte durch die Entfernung eine leere Liste entstehen, ist das Ergebnis null.

    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. Beim Entfernen eines Delegaten, der nicht Teil des Multicastdelegaten ist, passiert nichts, und der Multicastdelegat bleibt unverändert.

    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 über die Delegatgleichheit finden Sie in der C#-Sprachspezifikation unter Delegieren von Gleichheitsoperatoren.

  • Ist der linke Operand null, 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 zum Kombinieren von Delegaten den +-Operator.

Weitere Informationen zu Delegattypen finden Sie unter Delegaten.

Subtraktionszuweisungsoperator „-=“

Ein Ausdruck mit dem Operator -=, z.B.

x -= y

für die folgende Syntax:

x = x - y

außer dass x nur einmal überprüft 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

Mit dem Operator -= können Sie auch eine Ereignishandlermethode zum Entfernen angeben, wenn Sie das Abonnement eines Ereignisses kündigen. Weitere Informationen finden Sie unter Abonnieren von Ereignissen und Kündigen von Ereignisabonnements.

Operatorüberladbarkeit

Ein benutzerdefinierter Typ kann den Operator -überladen. Wenn ein binärer Operator vom Typ - überladen wird, wird der Operator -= implizit ebenfalls überladen. Ein benutzerdefinierter Typ kann den Operator -= nicht explizit überladen.

C#-Sprachspezifikation

Weitere Informationen finden Sie in den Abschnitten Unärer Minusoperator und Subtraktionsoperator der C#-Sprachspezifikation.

Weitere Informationen