Sdílet prostřednictvím

- a -= operátory – odčítání (se znaménkem minus)

Vestavěné celočíselné a plovoucí desetinné typy čísel a typy delegátové všechny podporují operátory - a -=.

Informace o aritmetickém - operátoru naleznete v unární operátor plus a minus a operátor odčítání - části článku Aritmetické operátory .

Odebrání delegáta

Pro operandy stejného typu delegáta- vrátí operátor instanci delegáta, která se vypočítá takto:

  • Pokud oba operandy nejsou null a seznam vyvolání pravého operandu je podseznamem seznamu vyvolání levého operandu, výsledkem operace je nový seznam vyvolání, který se získá odebráním položek pravého operandu ze seznamu vyvolání levého operandu. Pokud seznam operandu vpravo odpovídá více souvislým dílčím seznamům v seznamu operandů na levé straně, odebere se pouze odpovídající podsestava zprava. Pokud je výsledkem odebrání prázdný seznam, výsledek je 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

  • Pokud seznam vyvolání pravého operandu není souvislý a správný podseznam seznamu vyvolání levého operandu, je výsledkem operace levý operand. Odebrání delegáta, který není součástí delegáta vícesměrového vysílání, například nedělá nic a vede k tomu, že se delegát vícesměrového vysílání nezmění.

    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

    Předchozí příklad také ukazuje, že při odebrání delegátů se instance delegátů porovnávají. Například delegáti, kteří se vytvářejí z vyhodnocení identických výrazů lambda, se nerovnají. Další informace o rovnosti delegátů naleznete v sekci Operátory rovnosti delegátůspecifikace jazyka C#.

  • Pokud je levý operand null, výsledek operace je null. Pokud je operand napravo null, výsledkem operace je levý 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

Ke kombinování delegátů použijte + operátor.

Další informace o typech delegátů naleznete v tématu Delegáti.

Operátor přiřazení odčítání -=

Výraz používající operátor -=, například

x -= y

Je ekvivalentní

x = x - y

Kromě toho, že x se vyhodnotí jenom jednou.

Následující příklad ukazuje použití operátoru -=:

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

Pomocí operátoru -= můžete také určit metodu obslužné rutiny události, která se má odebrat při odhlášení odběru události. Další informace najdete v tématu Jak se přihlásit k odběru a odhlášení odběru událostí.

Přetížení operátoru

Uživatelem definovaný typ může přetížení operátor -. Pokud je binární - operátor přetížen, je operátor -= také implicitně přetížen. Počínaje jazykem C# 14 může uživatelem definovaný typ explicitně přetížit -= operátor, aby poskytoval efektivnější implementaci. Typ obvykle přetěžuje -= operátor, protože hodnotu lze aktualizovat místo přidělení nové instance k uložení výsledku odčítání. Pokud typ neposkytuje explicitní přetížení, kompilátor vygeneruje implicitní přetížení.

Specifikace jazyka C#

Další informace najdete v částech unárního minus operátoru a operátoru odčítáníspecifikace jazyka C#. Další informace o přetížení operátorů složeného přiřazení v jazyce C# 14 a novějších najdete ve specifikaci funkce složeného přiřazení definované uživatelem .

Viz také