Sdílet prostřednictvím

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

Integrované typy delegátů a celočíselné a číselné typy s plovoucí desetinou čárkou podporují všechny operátory - a -= operátory.

Referenční dokumentace jazyka C# dokumentuje naposledy vydané verze jazyka C#. Obsahuje také počáteční dokumentaci k funkcím ve verzi Public Preview pro nadcházející jazykovou verzi.

Dokumentace identifikuje všechny funkce, které byly poprvé představeny v posledních třech verzích jazyka nebo v aktuálních verzích Public Preview.

Návod

Informace o tom, kdy byla funkce poprvé představena v jazyce C#, najdete v článku o historii verzí jazyka C#.

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

U operandů 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ý dílčí seznam seznamu vyvolání levého operandu, je výsledkem operace nový seznam vyvolání, který získáte 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ě, operace odebere pouze odpovídající dílčí seznam 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, který používá -= 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 -. Při přetížení binárního - operátoru také implicitně přetěžujte -= operátor. 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é

  • Last updated on