Sdílet prostřednictvím

- a -= operátory – odčítání (minus)

  • Článek

Operátory - a -= operátory jsou podporovány integrovanými celočíselnými typy a typy delegátů s plovoucí desetinou čárkou.

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 správný souvislý podsestavový seznam vyvolání levého operandu, výsledkem operace je nový seznam vyvolání, který je získán odebráním položek operandu z pravého operandu ze seznamu vyvolání operandu z 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í správný souvislý dílčí seznam vyvolání levého operandu, je výsledkem operace levý operand 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áta instance delegáta jsou porovnány. Delegáti, kteří se vytvářejí například z vyhodnocení identických výrazů lambda, se nerovnají. Další informace o rovnosti delegáta naleznete v části Delegovat operátory rovnosti specifikace jazyka C#.

  • Pokud je nulllevý operand , výsledek operace je null. Pokud je nulloperand zprava, je výsledkem operace 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ů najdete 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 ekvivalentem

x = x - y

s tím rozdílem, že x se vyhodnotí pouze 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ásit odběr událostí.

Přetížení operátoru

Uživatelem definovaný typ může přetížit - operátor. Pokud je binární - operátor přetížen, -= operátor je také implicitně přetížen. Uživatelem definovaný typ nemůže explicitně přetížit -= operátor.

specifikace jazyka C#

Další informace najdete v částech unárního operátoru minus a odčítání specifikace jazyka C#.

Viz také